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

noshot/data/ML TS XAI/NLP/NLP 2/Lab05(WSD)/word-sense-disambiguation.ipynb

@@ -1,507 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "aad973c4",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "The sense of 'Chair' in the given text is: furniture\n"
-     ]
-    }
-   ],
-   "source": [
-    "import nltk\n",
-    "import math\n",
-    "from nltk.corpus import wordnet as wn\n",
-    "\n",
-    "# Define the senses and their priors\n",
-    "senses = {\n",
-    "    'furniture': 3/5,\n",
-    "    'position': 2/5\n",
-    "}\n",
-    "\n",
-    "# Read the input text from a file\n",
-    "def read_input_text(filename):\n",
-    "    with open(filename, 'r') as file:\n",
-    "        text = file.read()\n",
-    "    return text\n",
-    "\n",
-    "# Tokenize the input text\n",
-    "def tokenize_text(text):\n",
-    "    return nltk.word_tokenize(text)\n",
-    "\n",
-    "# Calculate the conditional probabilities for each sense\n",
-    "def calculate_conditional_probabilities(word, sense):\n",
-    "    sense_count = len(wn.synsets(sense))\n",
-    "    word_count = sense.count(word) + 1\n",
-    "    v_size = 17  # Assuming V size is 17\n",
-    "\n",
-    "    return math.log(senses[sense]) + math.log(word_count / (sense_count + v_size))\n",
-    "\n",
-    "# Calculate the sense scores\n",
-    "def calculate_sense_scores(tokens):\n",
-    "    scores = {sense: 0 for sense in senses}\n",
-    "\n",
-    "    for token in tokens:\n",
-    "        for sense in senses:\n",
-    "            scores[sense] += calculate_conditional_probabilities(token, sense)\n",
-    "\n",
-    "    return scores\n",
-    "\n",
-    "# Determine the most probable sense\n",
-    "def disambiguate_word_sense(text):\n",
-    "    tokens = tokenize_text(text)\n",
-    "    sense_scores = calculate_sense_scores(tokens)\n",
-    "\n",
-    "    # Find the sense with the highest score\n",
-    "    max_sense = max(sense_scores, key=sense_scores.get)\n",
-    "    return max_sense\n",
-    "\n",
-    "if __name__ == \"__main__\":\n",
-    "    input_filename = 'input.txt'\n",
-    "    input_text = read_input_text(input_filename)\n",
-    "    result = disambiguate_word_sense(input_text)\n",
-    "    print(f\"The sense of 'Chair' in the given text is: {result}\")\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "6210aa4b",
-   "metadata": {},
-   "source": [
-    "**Input text (`input.txt`)**\n",
-    "\n",
-    "```txt\n",
-    "Put, coat, back, Chair, sat, down Furniture\n",
-    "Chair, made, timber, company Furniture\n",
-    "Chair, institute, best Position\n",
-    "Award, IT, Chair Position\n",
-    "Type, different, Chair, Award, fun, use Furniture\n",
-    "Award, Chair, IT, company ?\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "9e59efe1",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "The sense of 'Bass' in the last context is: Fish\n"
-     ]
-    }
-   ],
-   "source": [
-    "from collections import defaultdict\n",
-    "\n",
-    "# Define the senses and their priors\n",
-    "senses = {\n",
-    "    'Fish': 3/5,\n",
-    "    'music': 2/5\n",
-    "}\n",
-    "\n",
-    "# Laplace smoothing parameter\n",
-    "alpha = 1\n",
-    "\n",
-    "# Read the input file\n",
-    "def read_input_file(filename):\n",
-    "    contexts = []\n",
-    "    with open(filename, 'r') as file:\n",
-    "        for line in file:\n",
-    "            parts = line.strip().split(' ')\n",
-    "            context = parts[0].split(', ')\n",
-    "            sense = parts[1]\n",
-    "            contexts.append((context, sense))\n",
-    "    return contexts\n",
-    "\n",
-    "# Calculate the conditional probabilities with Laplace smoothing\n",
-    "def calculate_conditional_probabilities(word, sense, context_list):\n",
-    "    sense_count = sum(1 for _, s in context_list if s == sense)\n",
-    "    word_count = sum(1 for c, s in context_list if s == sense and word in c) + alpha\n",
-    "    v_size = len(context_list[0][0])  # Assuming V size is equal to the context size\n",
-    "\n",
-    "    return (word_count / (sense_count + v_size * alpha)) * senses[sense]\n",
-    "\n",
-    "# Determine the most probable sense using the Decision Rule\n",
-    "def disambiguate_word_sense(context, context_list):\n",
-    "    sense_scores = {sense: 0 for sense in senses}\n",
-    "    \n",
-    "    for word in context:\n",
-    "        for sense in senses:\n",
-    "            sense_scores[sense] += calculate_conditional_probabilities(word, sense, context_list)\n",
-    "\n",
-    "    # Find the sense with the highest score\n",
-    "    max_sense = max(sense_scores, key=sense_scores.get)\n",
-    "    return max_sense\n",
-    "\n",
-    "if __name__ == \"__main__\":\n",
-    "    input_filename = 'input.txt' \n",
-    "    input_data = read_input_file(input_filename)\n",
-    "    context_to_disambiguate = [word.lower() for word in input_data[-1][0]]  # Use the last context\n",
-    "    \n",
-    "    result = disambiguate_word_sense(context_to_disambiguate, input_data[:-1])  # Exclude the last context for training\n",
-    "    print(f\"The sense of 'Bass' in the last context is: {result}\")\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "4022ddef",
-   "metadata": {},
-   "source": [
-    "**Input text (`input1.txt`)**\n",
-    "\n",
-    "```txt\n",
-    "Bass, eat, super  Fish\n",
-    "Bass, lunch, excellent Fish\n",
-    "Bass, ate, like\tFish\n",
-    "Bass, play, music music\n",
-    "Bass, interest, play music\n",
-    "Bass, super, excellent, play ?\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "67fe0295",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "The sense of 'Chair' in the given text is: furniture\n",
-      "Sense Scores:\n",
-      "furniture: -176.86226384643197\n",
-      "position: -232.52521725490584\n"
-     ]
-    }
-   ],
-   "source": [
-    "import nltk\n",
-    "import math\n",
-    "from nltk.corpus import wordnet as wn\n",
-    "\n",
-    "# Define the senses and their priors\n",
-    "senses = {\n",
-    "    'furniture': 3/5,\n",
-    "    'position': 2/5\n",
-    "}\n",
-    "\n",
-    "# Read the input text from a file\n",
-    "def read_input_text(filename):\n",
-    "    with open(filename, 'r') as file:\n",
-    "        text = file.read()\n",
-    "    return text\n",
-    "\n",
-    "# Tokenize the input text\n",
-    "def tokenize_text(text):\n",
-    "    return nltk.word_tokenize(text)\n",
-    "\n",
-    "# Calculate the conditional probabilities for each sense\n",
-    "def calculate_conditional_probabilities(word, sense):\n",
-    "    sense_count = len(wn.synsets(sense))\n",
-    "    word_count = sense.count(word) + 1\n",
-    "    v_size = 17  # Assuming V size is 17\n",
-    "\n",
-    "    return math.log(senses[sense]) + math.log(word_count / (sense_count + v_size))\n",
-    "\n",
-    "# Calculate the sense scores\n",
-    "def calculate_sense_scores(tokens):\n",
-    "    scores = {sense: 0 for sense in senses}\n",
-    "\n",
-    "    for token in tokens:\n",
-    "        for sense in senses:\n",
-    "            scores[sense] += calculate_conditional_probabilities(token, sense)\n",
-    "\n",
-    "    return scores\n",
-    "\n",
-    "# Determine the most probable sense\n",
-    "def disambiguate_word_sense(text):\n",
-    "    tokens = tokenize_text(text)\n",
-    "    sense_scores = calculate_sense_scores(tokens)\n",
-    "\n",
-    "    # Find the sense with the highest score\n",
-    "    max_sense = max(sense_scores, key=sense_scores.get)\n",
-    "    return max_sense, sense_scores  # Return both the sense and the scores\n",
-    "\n",
-    "if __name__ == \"__main__\":\n",
-    "    input_filename = 'input.txt'\n",
-    "    input_text = read_input_text(input_filename)\n",
-    "    result, scores = disambiguate_word_sense(input_text)\n",
-    "    \n",
-    "    print(f\"The sense of 'Chair' in the given text is: {result}\")\n",
-    "    print(\"Sense Scores:\")\n",
-    "    for sense, score in scores.items():\n",
-    "        print(f\"{sense}: {score}\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "4c53ed10",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "The sense of 'Bass' in the last context is: Fish\n",
-      "Sense Scores:\n",
-      "Fish: 0.6\n",
-      "music: 0.4\n"
-     ]
-    }
-   ],
-   "source": [
-    "from collections import defaultdict\n",
-    "\n",
-    "# Define the senses and their priors\n",
-    "senses = {\n",
-    "    'Fish': 3/5,\n",
-    "    'music': 2/5\n",
-    "}\n",
-    "\n",
-    "# Laplace smoothing parameter\n",
-    "alpha = 1\n",
-    "\n",
-    "# Read the input file\n",
-    "def read_input_file(filename):\n",
-    "    contexts = []\n",
-    "    with open(filename, 'r') as file:\n",
-    "        for line in file:\n",
-    "            parts = line.strip().split(' ')\n",
-    "            context = parts[0].split(', ')\n",
-    "            sense = parts[1]\n",
-    "            contexts.append((context, sense))\n",
-    "    return contexts\n",
-    "\n",
-    "# Calculate the conditional probabilities with Laplace smoothing\n",
-    "def calculate_conditional_probabilities(word, sense, context_list):\n",
-    "    sense_count = sum(1 for _, s in context_list if s == sense)\n",
-    "    word_count = sum(1 for c, s in context_list if s == sense and word in c) + alpha\n",
-    "    v_size = len(context_list[0][0])  # Assuming V size is equal to the context size\n",
-    "\n",
-    "    return (word_count / (sense_count + v_size * alpha)) * senses[sense]\n",
-    "\n",
-    "# Determine the most probable sense using the Decision Rule\n",
-    "def disambiguate_word_sense(context, context_list):\n",
-    "    sense_scores = {sense: 0 for sense in senses}\n",
-    "    \n",
-    "    for word in context:\n",
-    "        for sense in senses:\n",
-    "            sense_scores[sense] += calculate_conditional_probabilities(word, sense, context_list)\n",
-    "\n",
-    "    # Find the sense with the highest score\n",
-    "    max_sense = max(sense_scores, key=sense_scores.get)\n",
-    "    return max_sense, sense_scores  # Return both the sense and the scores\n",
-    "\n",
-    "if __name__ == \"__main__\":\n",
-    "    input_filename = 'input.txt' \n",
-    "    input_data = read_input_file(input_filename)\n",
-    "    context_to_disambiguate = [word.lower() for word in input_data[-1][0]]  # Use the last context\n",
-    "    \n",
-    "    result, scores = disambiguate_word_sense(context_to_disambiguate, input_data[:-1])  # Exclude the last context for training\n",
-    "    print(f\"The sense of 'Bass' in the last context is: {result}\")\n",
-    "    print(\"Sense Scores:\")\n",
-    "    for sense, score in scores.items():\n",
-    "        print(f\"{sense}: {score}\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "21ab75a6",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "The sense of 'Bass' in the last context is: Fish\n",
-      "Sense Scores:\n",
-      "Fish: 0.6\n",
-      "music: 0.4\n"
-     ]
-    }
-   ],
-   "source": [
-    "from collections import defaultdict\n",
-    "\n",
-    "# Read the input file\n",
-    "def read_input_file(filename):\n",
-    "    contexts = []\n",
-    "    with open(filename, 'r') as file:\n",
-    "        for line in file:\n",
-    "            parts = line.strip().split(' ')\n",
-    "            context = parts[0].split(', ')\n",
-    "            sense = parts[1]\n",
-    "            contexts.append((context, sense))\n",
-    "    return contexts\n",
-    "\n",
-    "# Calculate the conditional probabilities with Laplace smoothing\n",
-    "def calculate_conditional_probabilities(word, sense, context_list, senses, alpha):\n",
-    "    sense_count = sum(1 for _, s in context_list if s == sense)\n",
-    "    word_count = sum(1 for c, s in context_list if s == sense and word in c) + alpha\n",
-    "    v_size = len(context_list[0][0])  # Assuming V size is equal to the context size\n",
-    "\n",
-    "    return (word_count / (sense_count + v_size * alpha)) * senses[sense]\n",
-    "\n",
-    "# Determine the most probable sense using the Decision Rule\n",
-    "def disambiguate_word_sense(context, context_list, senses, alpha):\n",
-    "    sense_scores = {sense: 0 for sense in senses}\n",
-    "    \n",
-    "    for word in context:\n",
-    "        for sense in senses:\n",
-    "            sense_scores[sense] += calculate_conditional_probabilities(word, sense, context_list, senses, alpha)\n",
-    "\n",
-    "    # Find the sense with the highest score\n",
-    "    max_sense = max(sense_scores, key=sense_scores.get)\n",
-    "    return max_sense, sense_scores  # Return both the sense and the scores\n",
-    "\n",
-    "if __name__ == \"__main__\":\n",
-    "    # Input senses and priors\n",
-    "    senses = {\n",
-    "        'Fish': 3/5,\n",
-    "        'music': 2/5\n",
-    "    }\n",
-    "\n",
-    "    # Laplace smoothing parameter\n",
-    "    alpha = 1\n",
-    "\n",
-    "    input_filename = 'input.txt' \n",
-    "    input_data = read_input_file(input_filename)\n",
-    "    context_to_disambiguate = [word.lower() for word in input_data[-1][0]]  # Use the last context\n",
-    "    \n",
-    "    result, scores = disambiguate_word_sense(context_to_disambiguate, input_data[:-1], senses, alpha)  # Exclude the last context for training\n",
-    "    print(f\"The sense of 'Bass' in the last context is: {result}\")\n",
-    "    print(\"Sense Scores:\")\n",
-    "    for sense, score in scores.items():\n",
-    "        print(f\"{sense}: {score}\")\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "id": "432badc4",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "The sense of 'position' in the last context is: furniture\n",
-      "Sense Scores:\n",
-      "furniture: 0.6\n",
-      "position: 0.4\n"
-     ]
-    }
-   ],
-   "source": [
-    "from collections import defaultdict\n",
-    "\n",
-    "# Read the senses and their priors from an input file\n",
-    "def read_senses_from_file(filename):\n",
-    "    senses = {}\n",
-    "    with open(filename, 'r') as file:\n",
-    "        for line in file:\n",
-    "            parts = line.strip().split(' ')\n",
-    "            sense = parts[0]\n",
-    "            prior = float(parts[1])\n",
-    "            senses[sense] = prior\n",
-    "    return senses\n",
-    "\n",
-    "# Laplace smoothing parameter\n",
-    "alpha = 1\n",
-    "\n",
-    "# Read the input file\n",
-    "def read_input_file(filename):\n",
-    "    contexts = []\n",
-    "    with open(filename, 'r') as file:\n",
-    "        for line in file:\n",
-    "            parts = line.strip().split(' ')\n",
-    "            context = parts[0].split(', ')\n",
-    "            sense = parts[1]\n",
-    "            contexts.append((context, sense))\n",
-    "    return contexts\n",
-    "\n",
-    "# Calculate the conditional probabilities with Laplace smoothing\n",
-    "def calculate_conditional_probabilities(word, sense, context_list, senses):\n",
-    "    sense_count = sum(1 for _, s in context_list if s == sense)\n",
-    "    word_count = sum(1 for c, s in context_list if s == sense and word in c) + alpha\n",
-    "    v_size = len(context_list[0][0])  # Assuming V size is equal to the context size\n",
-    "\n",
-    "    return (word_count / (sense_count + v_size * alpha)) * senses[sense]\n",
-    "\n",
-    "# Determine the most probable sense using the Decision Rule\n",
-    "def disambiguate_word_sense(context, context_list, senses):\n",
-    "    sense_scores = {sense: 0 for sense in senses}\n",
-    "    \n",
-    "    for word in context:\n",
-    "        for sense in senses:\n",
-    "            sense_scores[sense] += calculate_conditional_probabilities(word, sense, context_list, senses)\n",
-    "\n",
-    "    # Find the sense with the highest score\n",
-    "    max_sense = max(sense_scores, key=sense_scores.get)\n",
-    "    return max_sense, sense_scores  # Return both the sense and the scores\n",
-    "\n",
-    "if __name__ == \"__main__\":\n",
-    "    input_filename = 'input.txt'  # Replace with the actual input file name\n",
-    "    senses_filename = 'senses_input.txt'  # Replace with the actual senses input file name\n",
-    "    \n",
-    "    senses = read_senses_from_file(senses_filename)\n",
-    "    input_data = read_input_file(input_filename)\n",
-    "    context_to_disambiguate = [word.lower() for word in input_data[-1][0]]  # Use the last context\n",
-    "    \n",
-    "    result, scores = disambiguate_word_sense(context_to_disambiguate, input_data[:-1], senses)  # Exclude the last context for training\n",
-    "    print(f\"The sense of '{sense}' in the last context is: {result}\")\n",
-    "    print(\"Sense Scores:\")\n",
-    "    for sense, score in scores.items():\n",
-    "        print(f\"{sense}: {score}\")\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "05ec022f",
-   "metadata": {},
-   "source": [
-    "**Input (`senses_input.txt`)**\n",
-    "\n",
-    "```txt\n",
-    "furniture 0.6\n",
-    "position 0.4\n",
-    "```"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.8.8"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

noshot/data/ML TS XAI/NLP/NLP 2/Lab06(additional-exercise)/lab6.ipynb

@@ -1,134 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "db74bf44",
-   "metadata": {},
-   "source": [
-    "### Todo\n",
-    "\n",
-    "1. Get text from a file\n",
-    "2. Get all possible bi grams\n",
-    "3. Apply smoothing(add-one,add-delta) for each bigram\n",
-    "4. Given random bi gram as an input\n",
-    "5. Print the probability of the given bi gram via all the three ,methods\n",
-    "\n",
-    "- add-one ---->laplace\n",
-    "- add-delta---->lidstone,jefrey's"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "a0228d7f",
-   "metadata": {},
-   "source": [
-    "Input text\n",
-    "\n",
-    "`This is a sample text for testing the bigram probability calculation using smoothing techniques. The quick brown fox jumps over the lazy dog. The lazy dog barks loudly. Testing is essential for evaluating the performance of natural language processing models.`"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "0ccf8972",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Probability using Laplace (add-one) smoothing: 0.029411764705882353\n",
-      "Probability using Lidstone (add-delta) with Jeffrey's smoothing: 0.029411764705882353\n"
-     ]
-    }
-   ],
-   "source": [
-    "from collections import defaultdict\n",
-    "import math\n",
-    "\n",
-    "# Step 1: Get text from a file\n",
-    "def read_text_from_file(filename):\n",
-    "    with open(filename, 'r', encoding='utf-8') as file:\n",
-    "        text = file.read()\n",
-    "    return text\n",
-    "\n",
-    "# Step 2: Get all possible bigrams\n",
-    "def get_bigrams(text):\n",
-    "    words = text.split()\n",
-    "    bigrams = [(words[i], words[i + 1]) for i in range(len(words) - 1)]\n",
-    "    return bigrams\n",
-    "\n",
-    "# Step 3: Apply Laplace (add-one) smoothing\n",
-    "def laplace_smoothing(bigrams, vocabulary):\n",
-    "    count_bigram = defaultdict(int)\n",
-    "    count_unigram = defaultdict(int)\n",
-    "\n",
-    "    for bigram in bigrams:\n",
-    "        count_bigram[bigram] += 1\n",
-    "        count_unigram[bigram[0]] += 1\n",
-    "\n",
-    "    def laplace_probability(bigram):\n",
-    "        return (count_bigram[bigram] + 1) / (count_unigram[bigram[0]] + vocabulary)\n",
-    "\n",
-    "    return laplace_probability\n",
-    "\n",
-    "# Step 4: Apply Lidstone (add-delta) smoothing with Jeffrey's smoothing\n",
-    "def lidstone_smoothing(bigrams, vocabulary, delta):\n",
-    "    count_bigram = defaultdict(int)\n",
-    "    count_unigram = defaultdict(int)\n",
-    "\n",
-    "    for bigram in bigrams:\n",
-    "        count_bigram[bigram] += 1\n",
-    "        count_unigram[bigram[0]] += 1\n",
-    "\n",
-    "    def lidstone_probability(bigram):\n",
-    "        numerator = count_bigram[bigram] + delta\n",
-    "        denominator = count_unigram[bigram[0]] + (vocabulary * delta)\n",
-    "        return numerator / denominator\n",
-    "\n",
-    "    return lidstone_probability\n",
-    "\n",
-    "# Step 5: Given a random bigram as input, print the probabilities using both smoothing methods\n",
-    "def main():\n",
-    "    filename = 'lab6-file.txt'  # Replace with the actual file path\n",
-    "    text = read_text_from_file(filename)\n",
-    "    bigrams = get_bigrams(text)\n",
-    "    vocabulary = len(set(text.split()))  # Size of the vocabulary\n",
-    "\n",
-    "    delta = 0.5  # Adjust this value for Lidstone smoothing\n",
-    "\n",
-    "    laplace_prob = laplace_smoothing(bigrams, vocabulary)\n",
-    "    lidstone_prob = lidstone_smoothing(bigrams, vocabulary, delta)\n",
-    "\n",
-    "    input_bigram = ('input', 'bigram')  # Replace with your random bigram\n",
-    "\n",
-    "    print(f\"Probability using Laplace (add-one) smoothing: {laplace_prob(input_bigram)}\")\n",
-    "    print(f\"Probability using Lidstone (add-delta) with Jeffrey's smoothing: {lidstone_prob(input_bigram)}\")\n",
-    "\n",
-    "if __name__ == \"__main__\":\n",
-    "    main()\n"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.8.8"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}