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

noshot/data/ML TS XAI/NLP/NLP 3/Backward-Procedure.ipynb

@@ -1,597 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "8d2eeff8-b13a-497d-a879-98946745f92e",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdin",
-     "output_type": "stream",
-     "text": [
-      "Enter the states (comma-separated):  cp,ip\n",
-      "Enter the possible observations (comma-separated):  lem,icet,cola\n",
-      "Enter the observation sequence as space-separated names (options: ['lem', 'icet', 'cola']):  lem icet cola\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "Enter the state transition probabilities:\n"
-     ]
-    },
-    {
-     "name": "stdin",
-     "output_type": "stream",
-     "text": [
-      "P(cp | cp):  0.7\n",
-      "P(ip | cp):  0.5\n",
-      "P(cp | ip):  0.3\n",
-      "P(ip | ip):  0.5\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "Enter the emission probabilities:\n"
-     ]
-    },
-    {
-     "name": "stdin",
-     "output_type": "stream",
-     "text": [
-      "P(lem | cp):  0.3\n",
-      "P(icet | cp):  0.1\n",
-      "P(cola | cp):  0.6\n",
-      "P(lem | ip):  0.2\n",
-      "P(icet | ip):  0.7\n",
-      "P(cola | ip):  0.1\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "Enter the initial state probabilities (comma-separated):\n"
-     ]
-    },
-    {
-     "name": "stdin",
-     "output_type": "stream",
-     "text": [
-      "Enter initial probabilities for ['cp', 'ip']:  1.0,0.0\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "Backward Matrix:\n",
-      " [[0.1134 0.47   1.    ]\n",
-      " [0.0946 0.23   1.    ]]\n",
-      "Probability of the observation sequence (using backward procedure): 0.03401999999999999\n",
-      "\n",
-      "Viterbi Matrix:\n",
-      " [[0.3     0.021   0.0189 ]\n",
-      " [0.      0.105   0.00525]]\n",
-      "Most probable state sequence: ['cp', 'ip', 'cp']\n"
-     ]
-    }
-   ],
-   "source": [
-    "import numpy as np\n",
-    "\n",
-    "# Step 1: Define states and observations based on user input\n",
-    "states = list(map(str.strip, input(\"Enter the states (comma-separated): \").split(',')))\n",
-    "observations = list(map(str.strip, input(\"Enter the possible observations (comma-separated): \").split(',')))\n",
-    "\n",
-    "# Step 2: Get user input for the observation sequence\n",
-    "observation_seq = list(map(str.strip, input(f\"Enter the observation sequence as space-separated names (options: {observations}): \").split()))\n",
-    "\n",
-    "# Step 3: Convert observation sequence to indices\n",
-    "try:\n",
-    "    observation_indices = [observations.index(obs) for obs in observation_seq]\n",
-    "except ValueError as e:\n",
-    "    print(f\"Error: {e}. Please make sure your observation sequence contains only valid options: {observations}.\")\n",
-    "    exit()\n",
-    "\n",
-    "# Step 4: Get user input for the transition matrix\n",
-    "print(\"\\nEnter the state transition probabilities:\")\n",
-    "transition_matrix = np.zeros((len(states), len(states)))\n",
-    "for i in range(len(states)):\n",
-    "    for j in range(len(states)):\n",
-    "        transition_matrix[i, j] = float(input(f\"P({states[j]} | {states[i]}): \"))\n",
-    "\n",
-    "# Step 5: Get user input for the emission matrix\n",
-    "print(\"\\nEnter the emission probabilities:\")\n",
-    "emission_matrix = np.zeros((len(states), len(observations)))\n",
-    "for i in range(len(states)):\n",
-    "    for j in range(len(observations)):\n",
-    "        emission_matrix[i, j] = float(input(f\"P({observations[j]} | {states[i]}): \"))\n",
-    "\n",
-    "# Step 6: Set initial state probabilities (ask the user to input them)\n",
-    "initial_probabilities = np.zeros(len(states))\n",
-    "print(\"\\nEnter the initial state probabilities (comma-separated):\")\n",
-    "initial_probabilities = list(map(float, input(f\"Enter initial probabilities for {states}: \").split(',')))\n",
-    "\n",
-    "# Step 7: Backward Procedure\n",
-    "def backward_procedure(observation_seq, transition_matrix, emission_matrix):\n",
-    "    num_states = len(transition_matrix)\n",
-    "    num_observations = len(observation_seq)\n",
-    "    \n",
-    "    # Initialize the backward matrix\n",
-    "    backward_matrix = np.zeros((num_states, num_observations))\n",
-    "    \n",
-    "    # Initialization step: Fill the last column with 1 (termination condition)\n",
-    "    backward_matrix[:, num_observations - 1] = 1\n",
-    "    \n",
-    "    # Recursion step\n",
-    "    for t in range(num_observations - 2, -1, -1):\n",
-    "        for i in range(num_states):\n",
-    "            backward_matrix[i, t] = sum(transition_matrix[i, j] * emission_matrix[j, observation_seq[t + 1]] * backward_matrix[j, t + 1] for j in range(num_states))\n",
-    "    \n",
-    "    # Compute the probability of the observation sequence\n",
-    "    prob_observation = sum(initial_probabilities[i] * emission_matrix[i, observation_seq[0]] * backward_matrix[i, 0] for i in range(num_states))\n",
-    "    \n",
-    "    return backward_matrix, prob_observation\n",
-    "\n",
-    "# Step 8: Viterbi Algorithm (to find the best state sequence)\n",
-    "def viterbi_algorithm(observation_seq, transition_matrix, emission_matrix, initial_probabilities):\n",
-    "    num_states = len(transition_matrix)\n",
-    "    num_observations = len(observation_seq)\n",
-    "    \n",
-    "    # Initialize the Viterbi matrix and the backpointer matrix\n",
-    "    viterbi_matrix = np.zeros((num_states, num_observations))\n",
-    "    backpointer = np.zeros((num_states, num_observations), dtype=int)\n",
-    "    \n",
-    "    # Initialization step\n",
-    "    for i in range(num_states):\n",
-    "        viterbi_matrix[i, 0] = initial_probabilities[i] * emission_matrix[i, observation_seq[0]]\n",
-    "    \n",
-    "    # Recursion step\n",
-    "    for t in range(1, num_observations):\n",
-    "        for j in range(num_states):\n",
-    "            probabilities = [viterbi_matrix[i, t - 1] * transition_matrix[i, j] * emission_matrix[j, observation_seq[t]] for i in range(num_states)]\n",
-    "            viterbi_matrix[j, t] = max(probabilities)\n",
-    "            backpointer[j, t] = np.argmax(probabilities)\n",
-    "    \n",
-    "    # Termination step\n",
-    "    best_last_state = np.argmax(viterbi_matrix[:, num_observations - 1])\n",
-    "    \n",
-    "    # Backtrack to find the most probable state sequence\n",
-    "    best_path = [best_last_state]\n",
-    "    for t in range(num_observations - 1, 0, -1):\n",
-    "        best_last_state = backpointer[best_last_state, t]\n",
-    "        best_path.insert(0, best_last_state)\n",
-    "    \n",
-    "    best_state_sequence = [states[state_index] for state_index in best_path]\n",
-    "    \n",
-    "    return best_state_sequence, viterbi_matrix\n",
-    "\n",
-    "# Step 9: Compute the backward matrix and the probability of the observation sequence\n",
-    "backward_matrix, prob_observation_backward = backward_procedure(observation_indices, transition_matrix, emission_matrix)\n",
-    "print(\"\\nBackward Matrix:\\n\", backward_matrix)\n",
-    "print(\"Probability of the observation sequence (using backward procedure):\", prob_observation_backward)\n",
-    "\n",
-    "# Step 10: Compute the most probable state sequence using Viterbi algorithm\n",
-    "best_state_sequence, viterbi_matrix = viterbi_algorithm(observation_indices, transition_matrix, emission_matrix, initial_probabilities)\n",
-    "print(\"\\nViterbi Matrix:\\n\", viterbi_matrix)\n",
-    "print(\"Most probable state sequence:\", best_state_sequence)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "2acfa85e-c9f1-41ce-9ebf-6283066554cc",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdin",
-     "output_type": "stream",
-     "text": [
-      "Enter the states (comma-separated):  1,2,3\n",
-      "Enter the possible observations (comma-separated):  up,down,unchanged\n",
-      "Enter the observation sequence as space-separated names (options: ['up', 'down', 'unchanged']):  up up up up up\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "Enter the state transition probabilities:\n"
-     ]
-    },
-    {
-     "name": "stdin",
-     "output_type": "stream",
-     "text": [
-      "P(1 | 1):  0.6\n",
-      "P(2 | 1):  0.2\n",
-      "P(3 | 1):  0.2\n",
-      "P(1 | 2):  0.5\n",
-      "P(2 | 2):  0.3\n",
-      "P(3 | 2):  0.2\n",
-      "P(1 | 3):  0.4\n",
-      "P(2 | 3):  0.1\n",
-      "P(3 | 3):  0.5\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "Enter the emission probabilities:\n"
-     ]
-    },
-    {
-     "name": "stdin",
-     "output_type": "stream",
-     "text": [
-      "P(up | 1):  0.7\n",
-      "P(down | 1):  0.1\n",
-      "P(unchanged | 1):  0.2\n",
-      "P(up | 2):  0.1\n",
-      "P(down | 2):  0.6\n",
-      "P(unchanged | 2):  0.3\n",
-      "P(up | 3):  0.3\n",
-      "P(down | 3):  0.3\n",
-      "P(unchanged | 3):  0.4\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "Enter the initial state probabilities (comma-separated):\n"
-     ]
-    },
-    {
-     "name": "stdin",
-     "output_type": "stream",
-     "text": [
-      "Enter initial probabilities for ['1', '2', '3']:  0.5,0.2,0.3\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "Backward Matrix:\n",
-      " [[0.05859736 0.1199     0.2452     0.5        1.        ]\n",
-      " [0.05125318 0.104882   0.2146     0.44       1.        ]\n",
-      " [0.04997512 0.102362   0.2104     0.44       1.        ]]\n",
-      "Probability of the observation sequence (using backward procedure): 0.026031900399999995\n",
-      "\n",
-      "Viterbi Matrix:\n",
-      " [[0.35       0.147      0.06174    0.0259308  0.01089094]\n",
-      " [0.02       0.007      0.00294    0.0012348  0.00051862]\n",
-      " [0.09       0.021      0.00882    0.0037044  0.00155585]]\n",
-      "Most probable state sequence: ['1', '1', '1', '1', '1']\n"
-     ]
-    }
-   ],
-   "source": [
-    "import numpy as np\n",
-    "\n",
-    "# Step 1: Define states and observations based on user input\n",
-    "states = list(map(str.strip, input(\"Enter the states (comma-separated): \").split(',')))\n",
-    "observations = list(map(str.strip, input(\"Enter the possible observations (comma-separated): \").split(',')))\n",
-    "\n",
-    "# Step 2: Get user input for the observation sequence\n",
-    "observation_seq = list(map(str.strip, input(f\"Enter the observation sequence as space-separated names (options: {observations}): \").split()))\n",
-    "\n",
-    "# Step 3: Convert observation sequence to indices\n",
-    "try:\n",
-    "    observation_indices = [observations.index(obs) for obs in observation_seq]\n",
-    "except ValueError as e:\n",
-    "    print(f\"Error: {e}. Please make sure your observation sequence contains only valid options: {observations}.\")\n",
-    "    exit()\n",
-    "\n",
-    "# Step 4: Get user input for the transition matrix\n",
-    "print(\"\\nEnter the state transition probabilities:\")\n",
-    "transition_matrix = np.zeros((len(states), len(states)))\n",
-    "for i in range(len(states)):\n",
-    "    for j in range(len(states)):\n",
-    "        transition_matrix[i, j] = float(input(f\"P({states[j]} | {states[i]}): \"))\n",
-    "\n",
-    "# Step 5: Get user input for the emission matrix\n",
-    "print(\"\\nEnter the emission probabilities:\")\n",
-    "emission_matrix = np.zeros((len(states), len(observations)))\n",
-    "for i in range(len(states)):\n",
-    "    for j in range(len(observations)):\n",
-    "        emission_matrix[i, j] = float(input(f\"P({observations[j]} | {states[i]}): \"))\n",
-    "\n",
-    "# Step 6: Set initial state probabilities (ask the user to input them)\n",
-    "initial_probabilities = np.zeros(len(states))\n",
-    "print(\"\\nEnter the initial state probabilities (comma-separated):\")\n",
-    "initial_probabilities = list(map(float, input(f\"Enter initial probabilities for {states}: \").split(',')))\n",
-    "\n",
-    "# Step 7: Backward Procedure\n",
-    "def backward_procedure(observation_seq, transition_matrix, emission_matrix):\n",
-    "    num_states = len(transition_matrix)\n",
-    "    num_observations = len(observation_seq)\n",
-    "    \n",
-    "    # Initialize the backward matrix\n",
-    "    backward_matrix = np.zeros((num_states, num_observations))\n",
-    "    \n",
-    "    # Initialization step: Fill the last column with 1 (termination condition)\n",
-    "    backward_matrix[:, num_observations - 1] = 1\n",
-    "    \n",
-    "    # Recursion step\n",
-    "    for t in range(num_observations - 2, -1, -1):\n",
-    "        for i in range(num_states):\n",
-    "            backward_matrix[i, t] = sum(transition_matrix[i, j] * emission_matrix[j, observation_seq[t + 1]] * backward_matrix[j, t + 1] for j in range(num_states))\n",
-    "    \n",
-    "    # Compute the probability of the observation sequence\n",
-    "    prob_observation = sum(initial_probabilities[i] * emission_matrix[i, observation_seq[0]] * backward_matrix[i, 0] for i in range(num_states))\n",
-    "    \n",
-    "    return backward_matrix, prob_observation\n",
-    "\n",
-    "# Step 8: Viterbi Algorithm (to find the best state sequence)\n",
-    "def viterbi_algorithm(observation_seq, transition_matrix, emission_matrix, initial_probabilities):\n",
-    "    num_states = len(transition_matrix)\n",
-    "    num_observations = len(observation_seq)\n",
-    "    \n",
-    "    # Initialize the Viterbi matrix and the backpointer matrix\n",
-    "    viterbi_matrix = np.zeros((num_states, num_observations))\n",
-    "    backpointer = np.zeros((num_states, num_observations), dtype=int)\n",
-    "    \n",
-    "    # Initialization step\n",
-    "    for i in range(num_states):\n",
-    "        viterbi_matrix[i, 0] = initial_probabilities[i] * emission_matrix[i, observation_seq[0]]\n",
-    "    \n",
-    "    # Recursion step\n",
-    "    for t in range(1, num_observations):\n",
-    "        for j in range(num_states):\n",
-    "            probabilities = [viterbi_matrix[i, t - 1] * transition_matrix[i, j] * emission_matrix[j, observation_seq[t]] for i in range(num_states)]\n",
-    "            viterbi_matrix[j, t] = max(probabilities)\n",
-    "            backpointer[j, t] = np.argmax(probabilities)\n",
-    "    \n",
-    "    # Termination step\n",
-    "    best_last_state = np.argmax(viterbi_matrix[:, num_observations - 1])\n",
-    "    \n",
-    "    # Backtrack to find the most probable state sequence\n",
-    "    best_path = [best_last_state]\n",
-    "    for t in range(num_observations - 1, 0, -1):\n",
-    "        best_last_state = backpointer[best_last_state, t]\n",
-    "        best_path.insert(0, best_last_state)\n",
-    "    \n",
-    "    best_state_sequence = [states[state_index] for state_index in best_path]\n",
-    "    \n",
-    "    return best_state_sequence, viterbi_matrix\n",
-    "\n",
-    "# Step 9: Compute the backward matrix and the probability of the observation sequence\n",
-    "backward_matrix, prob_observation_backward = backward_procedure(observation_indices, transition_matrix, emission_matrix)\n",
-    "print(\"\\nBackward Matrix:\\n\", backward_matrix)\n",
-    "print(\"Probability of the observation sequence (using backward procedure):\", prob_observation_backward)\n",
-    "\n",
-    "# Step 10: Compute the most probable state sequence using Viterbi algorithm\n",
-    "best_state_sequence, viterbi_matrix = viterbi_algorithm(observation_indices, transition_matrix, emission_matrix, initial_probabilities)\n",
-    "print(\"\\nViterbi Matrix:\\n\", viterbi_matrix)\n",
-    "print(\"Most probable state sequence:\", best_state_sequence)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "47ad375b-4939-4c61-84b9-cff0eb2485c8",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdin",
-     "output_type": "stream",
-     "text": [
-      "Enter the number of states:  2\n",
-      "Enter state 1:  cp\n",
-      "Enter state 2:  ip\n",
-      "Enter the number of observations:  3\n",
-      "Enter observation 1:  lem\n",
-      "Enter observation 2:  icet\n",
-      "Enter observation 3:  cola\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "Enter start probabilities for each state:\n"
-     ]
-    },
-    {
-     "name": "stdin",
-     "output_type": "stream",
-     "text": [
-      "Start probability for cp:  1.0\n",
-      "Start probability for ip:  0.0\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "Enter transition probabilities (from each state to other states):\n"
-     ]
-    },
-    {
-     "name": "stdin",
-     "output_type": "stream",
-     "text": [
-      "Transition probability from cp to cp:  0.7\n",
-      "Transition probability from cp to ip:  0.3\n",
-      "Transition probability from ip to cp:  0.5\n",
-      "Transition probability from ip to ip:  0.5\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "Enter emission probabilities (from each state to each observation):\n"
-     ]
-    },
-    {
-     "name": "stdin",
-     "output_type": "stream",
-     "text": [
-      "Emission probability of lem from cp:  0.3\n",
-      "Emission probability of icet from cp:  0.1\n",
-      "Emission probability of cola from cp:  0.6\n",
-      "Emission probability of lem from ip:  0.2\n",
-      "Emission probability of icet from ip:  0.7\n",
-      "Emission probability of cola from ip:  0.1\n",
-      "\n",
-      "Enter the observation sequence (space-separated):  lem icet cola\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "Best state sequence: ['cp', 'ip', 'cp']\n",
-      "Best path probability: 0.0189\n"
-     ]
-    }
-   ],
-   "source": [
-    "import numpy as np\n",
-    "class HiddenMarkovModel:\n",
-    "    def __init__(self, states, observations, start_prob, trans_prob, emission_prob):\n",
-    "        self.states = states  # Possible hidden states (tags)\n",
-    "        self.observations = observations  # Possible observations (words)\n",
-    "        self.start_prob = start_prob  # Initial probabilities of states\n",
-    "        self.trans_prob = trans_prob  # Transition probabilities between states\n",
-    "        self.emission_prob = emission_prob  # Emission probabilities of states producing observations\n",
-    "\n",
-    "    def viterbi(self, obs_seq):\n",
-    "        n_states = len(self.states)\n",
-    "        n_observations = len(obs_seq)\n",
-    "\n",
-    "        viterbi_table = np.zeros((n_states, n_observations))\n",
-    "        backpointer = np.zeros((n_states, n_observations), dtype=int)\n",
-    "\n",
-    "        for s in range(n_states):\n",
-    "            viterbi_table[s, 0] = self.start_prob[s] * self.emission_prob[s][self.observations.index(obs_seq[0])]\n",
-    "            backpointer[s, 0] = 0\n",
-    "\n",
-    "        for t in range(1, n_observations):\n",
-    "            for s in range(n_states):\n",
-    "\n",
-    "                max_prob, max_state = max(\n",
-    "                    (viterbi_table[prev_s, t-1] * self.trans_prob[prev_s][s] *\n",
-    "                     self.emission_prob[s][self.observations.index(obs_seq[t])], prev_s)\n",
-    "                    for prev_s in range(n_states)\n",
-    "                )\n",
-    "                viterbi_table[s, t] = max_prob\n",
-    "                backpointer[s, t] = max_state\n",
-    "        \n",
-    "        best_path_prob = max(viterbi_table[:, -1])\n",
-    "        best_path_pointer = np.argmax(viterbi_table[:, -1])\n",
-    "        best_path = [best_path_pointer]\n",
-    "        \n",
-    "        for t in range(n_observations - 1, 0, -1):\n",
-    "            best_path_pointer = backpointer[best_path_pointer, t]\n",
-    "            best_path.insert(0, best_path_pointer)\n",
-    "        \n",
-    "        best_state_sequence = [self.states[i] for i in best_path]\n",
-    "        return best_state_sequence, best_path_prob\n",
-    "\n",
-    "\n",
-    "def get_user_input():\n",
-    "    num_states = int(input(\"Enter the number of states: \"))\n",
-    "    states = []\n",
-    "    for i in range(num_states):\n",
-    "        state = input(f\"Enter state {i + 1}: \")\n",
-    "        states.append(state)\n",
-    "    \n",
-    "    num_observations = int(input(\"Enter the number of observations: \"))\n",
-    "    observations = []\n",
-    "    for i in range(num_observations):\n",
-    "        observation = input(f\"Enter observation {i + 1}: \")\n",
-    "        observations.append(observation)\n",
-    "    \n",
-    "    print(\"\\nEnter start probabilities for each state:\")\n",
-    "    start_prob = []\n",
-    "    for state in states:\n",
-    "        prob = float(input(f\"Start probability for {state}: \"))\n",
-    "        start_prob.append(prob)\n",
-    "    \n",
-    "    print(\"\\nEnter transition probabilities (from each state to other states):\")\n",
-    "    trans_prob = []\n",
-    "    for i, from_state in enumerate(states):\n",
-    "        trans_row = []\n",
-    "        for j, to_state in enumerate(states):\n",
-    "            prob = float(input(f\"Transition probability from {from_state} to {to_state}: \"))\n",
-    "            trans_row.append(prob)\n",
-    "        trans_prob.append(trans_row)\n",
-    "    \n",
-    "    print(\"\\nEnter emission probabilities (from each state to each observation):\")\n",
-    "    emission_prob = []\n",
-    "    for i, state in enumerate(states):\n",
-    "        emission_row = []\n",
-    "        for j, observation in enumerate(observations):\n",
-    "            prob = float(input(f\"Emission probability of {observation} from {state}: \"))\n",
-    "            emission_row.append(prob)\n",
-    "        emission_prob.append(emission_row)\n",
-    "    \n",
-    "    return states, observations, start_prob, trans_prob, emission_prob\n",
-    "\n",
-    "\n",
-    "if __name__ == \"__main__\":\n",
-    "    states, observations, start_prob, trans_prob, emission_prob = get_user_input()\n",
-    "\n",
-    "    hmm = HiddenMarkovModel(states, observations, start_prob, trans_prob, emission_prob)\n",
-    "\n",
-    "    obs_seq = input(\"\\nEnter the observation sequence (space-separated): \").split()\n",
-    "\n",
-    "    best_sequence, best_prob = hmm.viterbi(obs_seq)\n",
-    "    print(\"\\nBest state sequence:\", best_sequence)\n",
-    "    print(\"Best path probability:\", best_prob)\n",
-    "    "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "a7d52d1f-c7fb-4b4b-acc5-cc8c4ee70dbe",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "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.7"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}