bitwise_bakeoff.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xp3tZrn1fjyW"
      },
      "source": [
        "# Bitwise Bakeoff (Random Bake Sets)\n",
        "-----\n",
        "\n",
        "This is a logbook outlining our group's efforts and research for the 2nd assignment. To keep the theme on record, it is to create a recipe generator for cookies(desert) using a genetic algorithm approach. We are eager and excited about this and have a couple of ideas we want to test out.\n",
        "\n",
        "\n",
        "First we decided to implement a dataset for our genetic algorithm to be based on sets of recipes starting with each letter of the alphabet (A to Z) and the numbers 1-8. We chose this because it allows for interesting and atypical recipes to be included in the ingredient portfolio in an unbiased way.\n",
        " There were a lot of resources but we found [this](https://github.com/dpapathanasiou/recipes/blob/master/index/c/cookies.md) To be quite extensive for our use case. We then wrote a simple python script to extract all the data from the links in the page to create a dataset\n",
        "\n",
        "\n",
        "_Note: The following script is not optimized and is not meant to be used as a library. It is a one time use script to create a dataset for our use case. It takes around 30 minutes to run. Even more when the data we extract increases._\n",
        "\n",
        "\n",
        "## Inspiring Set\n",
        "\n",
        "\n",
        "For our inspiring set, we have decided to stick to cookies as we have managed to find a really large dataset of cookie recipes. A few examples of the cookie recipes are as follows:\n",
        "- [Chewy Rolo Cookie Bars](http://allrecipes.com/recipe/11305/chewy-rolo-cookie-bars/)\n",
        "- [Rum Cookie Balls](http://allrecipes.com/recipe/26225/rum-cookie-balls/)\n",
        "- [Cookie Pizza\"](http://allrecipes.com/recipe/10591/cookie-pizza/)\n",
        "- [Dutch Cookies](http://www.epicurious.com/recipes/food/views/dutch-cookies-231213)\n",
        "In the initial component of data set creation we retrieve all components of the repository as a json dataset including the implementation of appropriate directory structures\n",
        "Next we set out to extract the url information from the main page. In this section we begin the process of parsing the components of each recipe in the dataset so they can be recombined into novel recipes. This was done with mixed_fraction\n",
        "After this we determined an extraction order of operations where the recipe is retrieved from a url then the name and ingredients are extracted from json. We do this first with the title then the ingredients\n",
        "Next we format the ingredients to deal with capitalization, special characters, extraneous delimiters and any other elements that would be detrimental for the algorithm to function properly\n",
        "Each new ingredient has components 'amount' 'unit' and 'ingredient'\n",
        "The recipe consists of a 'title' name and 'ingredients' derived from the aforementioned components\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "73XPUBYk2tqK"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Dataset created successfully\n"
          ]
        }
      ],
      "source": [
        "# Program to retrieve all assets from the page as a json dataset\n",
        "import json\n",
        "from fractions import Fraction\n",
        "import re\n",
        "import requests as req\n",
        "import os\n",
        "\n",
        "md_file_url = \"https://github.com/dpapathanasiou/recipes/raw/master/index/c/cookies.md\"\n",
        "json_file_url_prefix = \"https://github.com/dpapathanasiou/recipes/raw/master/index\"\n",
        "file_name = \"./data/recipes.json\"\n",
        "\n",
        "response = req.get(md_file_url)\n",
        "content = response.text\n",
        "\n",
        "\n",
        "directory = os.path.dirname(file_name)\n",
        "if not os.path.exists(directory):\n",
        "    os.makedirs(directory)\n",
        "\n",
        "\n",
        "# Extract the url information from the main page\n",
        "json_urls = []\n",
        "pattern = r'\\]\\(([^)]+)\\)'\n",
        "matches = re.findall(pattern, content)\n",
        "cleaned_links = [match.replace(\"../../index/\", \"\") for match in matches]\n",
        "for clean_link in cleaned_links:\n",
        "    json_url = f\"{json_file_url_prefix}/{clean_link}\"\n",
        "    json_urls.append(json_url)\n",
        "\n",
        "def parse_mixed_fraction(mixed_fraction):\n",
        "    if ' ' in mixed_fraction:\n",
        "        # print(mixed_fraction)\n",
        "        whole_part, fraction_part = mixed_fraction.split(' ')\n",
        "        fraction = Fraction(fraction_part)\n",
        "        return str(int(whole_part) + fraction)\n",
        "    else:\n",
        "        return mixed_fraction\n",
        "\n",
        "recipes_data = {\n",
        "    \"recipes\":[]\n",
        "}\n",
        "\n",
        "for url in json_urls:\n",
        "  final_ingrs = []\n",
        "  # get recipe from url\n",
        "  res = req.get(url)\n",
        "  data = res.json()\n",
        "\n",
        "  # get name and ingridients from json\n",
        "  name = data[\"title\"]\n",
        "  ingr = data[\"ingredients\"]\n",
        "\n",
        "  # Reformat the ingridients to required format\n",
        "  for ing in ingr:\n",
        "    # pattern = r'^([\\d/]+)\\s*([a-zA-Z]+)\\s*(?:\\([^)]+\\))?\\s*([^,]*)'\n",
        "    pattern = r'^([\\d\\s/]+)\\s*([a-zA-Z]+)\\s*(?:\\([^)]+\\))?\\s*([^,]*)'\n",
        "    match = re.match(pattern, ing)\n",
        "\n",
        "    if match:\n",
        "        new_ingr = {\n",
        "            \"amount\": parse_mixed_fraction(match.group(1).strip()),\n",
        "            \"unit\": match.group(2),\n",
        "            \"ingridient\":match.group(3).strip()\n",
        "        }\n",
        "        final_ingrs.append(new_ingr)\n",
        "\n",
        "  recipe = {\n",
        "      \"title\":name,\n",
        "      \"ingridients\":final_ingrs\n",
        "  }\n",
        "  recipes_data[\"recipes\"].append(recipe)\n",
        "\n",
        "with open(file_name, \"w\") as outfile:\n",
        "    json.dump(recipes_data, outfile, indent=2)\n",
        "print(\"Dataset created successfully\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "liBLHxfQ3TOU"
      },
      "source": [
        "Now that we have a dataset, we have exhibited an ability to explore genetic algorithms and how they work. Initially it seems relatively straight forward, however, most examples tend to become hyper-technical and focus on solving problems in a binary manner. We decided to try a method where we embrace this binary manner and attempt to encode each ingredient of a recipe as a bit string, giving values to each ingredient on random. The way evaluation, mutation, and crossover will work are:\n",
        "### Evaluation\n",
        "The fitness of the recipe is evaluated on the length of its ingredients. The more the length, the higher the fitness. We decided for a 40% exploitation (i.e 40% of the selected population based on fitness alone), and 60% exploration (i.e adding random samples to the selected population). This could have been improved by looking at the sweetness of the ingredients and the amount of sugar in the recipe, but we decided to keep not implementing this sort of filter in order to increase the variety and novelty of the recipe output. Also, another way to evaluate recipes could be done the opposite way, where we look at the length of the ingredients and the amount of sugar in the recipe and select the shortest recipe with the highest amount of sugar. We decided to go with the first method as it is more intuitive and easier to understand, however this could be an interesting area to iterate on in future potential versions.\n",
        "\n",
        "\n",
        "### Crossover\n",
        "Here we have 2 steps\n",
        "- Assign a random binary notation to the ingredients of 2 randomly chosen recipes from the population.\n",
        "- We then take all the ingredients which are encoded as '1' for each recipe and add them into the new recipe\n",
        "\n",
        "\n",
        "We then add this new recipe to the population and repeat this until we converge at 4 recipes. We are exploring the idea of multiple crossovers in a given generation, but we are not sure how it will affect the results.\n",
        "_Note: We tried multiple crossovers per generation and this created many empty lists and problems with not hitting the stopping criteria_\n",
        "\n",
        "\n",
        "### Mutation\n",
        "For this task, we chose to have 3 situations randomly chosen to occur. The first common step is to assign a binary encoding to the new recipe\n",
        "- Chose a ingredient encoded as '0' at random and delete it\n",
        "- Choose an ingredient encoded as '0' at random, and change the amount with an ingredient encoded as '1' at random\n",
        "- Choose an ingredient encoded as '1' at random, and double the amount in it.\n",
        "- Add an ingredient from the dataset at random\n",
        "\n",
        "We chose the mutation criteria because in a sense they could mimic the real life scenario of not having the exact amount of ingredients on hand to properly create a recipe. It’s likely not hard to recall at least one instance where one was cooking something and had to improvise with ingredients based on what was available. This also ties back into the more fundamental concepts evident in evolutionary / genetic algorithms (ie. necessity is the mother of invention)\n",
        "At the end of this, we select half of the original population at random and half of the selected altered population at random and perform this until we converge at 5 recipes.\n",
        "\n",
        "\n",
        "Through this process we allow recipes with larger ingredients to express participation but not run the selection. Our aim is to create oblique and abnormal recipes and a parsimoniously creative way while allowing the algorithm to chaotically pick between all available options.\n",
        "\n",
        "### Creativity Evaluation\n",
        "\n",
        "In order to evaluate the creativity of our system we would firstly, assess the diversity of outputs and novelty of the creations. This would involve analyzing the range and variety of ingredients, methods, and titles generated by the algorithm. We would anticipate the novelty of titles would likely be a strong point but would also be potentially one of the more difficult points to assess. To do this we would catalog the generated recipes and compare them against a comprehensive database of existing cookie recipes that is sufficiently distinct from the set we used to build our dataset. This comparison would help determine the uniqueness of the algorithm's outputs. Furthermore, the relevance and feasibility of the recipes should be evaluated, for example if certain recipes called for inordinately expensive or rare  ingredients or quantities this could negatively affect feasibility. This means ensuring that the ingredients and methods are practical and make culinary sense, and that the titles accurately reflect the content of the recipes, while also having an element of artistic spark. Additionally, the consistency and coherence of the recipes and their titles are crucial. The algorithm should consistently generate coherent recipes that adhere to basic culinary principles, and the titles should be meaningful and appropriately connected to their recipes.\n",
        "\n",
        "For the second phase we could focus on the complexity and depth of the algorithm's output, along with comparisons to human-created recipes. This would include analysis of  whether the algorithm is capable of producing recipes with a level of complexity and depth comparable to those created by skilled human chefs. Even though the link between complexity and creativity is a complicated and controversial one, it could be argued that a robust algorithm would at least at times create outputs of complexity that would surpass that of human generated recipes. This can involve examining the sophistication of flavor combinations, cooking techniques, and the creativity embodied in the recipe titles. When comparing these aspects with recipes crafted by human chefs to gauge the algorithm's performance we would intend to use some form of Natural Language Processing like a Term Frequency-Inverse Document Frequency algorithm. Some form of Sentiment Analysis could also be of use. These comparative techniques would not only serve as benchmarks for the algorithm’s creativity but also highlight areas for improvement. Through these steps, we could effectively evaluate and enhance the creativity of our genetic algorithm and then tweak parameters for optimization.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[{'title': 'Block Party Fruit Cookies', 'ingridients': [{'amount': '1', 'unit': 'sugar', 'ingridient': 'cookies'}], 'fitness': 1}, {'title': 'lucid_shannon Cookies', 'ingridients': [{'amount': '3/2', 'unit': 'cups', 'ingridient': 'packed brown sugar'}, {'amount': '3/4', 'unit': 'cup', 'ingridient': 'white sugar'}, {'amount': '3', 'unit': 'eggs', 'ingridient': ''}, {'amount': '2', 'unit': 'teaspoons', 'ingridient': 'baking powder'}, {'amount': '1', 'unit': 'cup', 'ingridient': 'chopped walnuts'}, {'amount': '2', 'unit': 'cups', 'ingridient': 'semisweet chocolate chips'}, {'amount': '1', 'unit': 'cup', 'ingridient': 'chopped walnuts'}, {'amount': '1/2', 'unit': 'cup', 'ingridient': 'Crisco® Baking Sticks All-Vegetable Shortening'}, {'amount': '3/4', 'unit': 'cup', 'ingridient': 'all-purpose flour'}, {'amount': '2', 'unit': 'teaspoon', 'ingridient': 'kosher salt'}, {'amount': '1', 'unit': 'tablespoons', 'ingridient': 'granulated sugar'}, {'amount': '6', 'unit': 'tablespoons', 'ingridient': 'honey'}, {'amount': '16', 'unit': 'ounces', 'ingridient': 'bittersweet chocolate'}, {'amount': '24', 'unit': 'marshmallows', 'ingridient': ''}, {'amount': '1/2', 'unit': 'cup', 'ingridient': 'chopped walnuts'}, {'amount': '1/2', 'unit': 'teaspoon', 'ingridient': 'baking soda'}], 'fitness': 16}, {'title': 'Soft Oatmeal Cookies', 'ingridients': [{'amount': '1/4', 'unit': 'cup', 'ingridient': 'golden raisins'}, {'amount': '1/4', 'unit': 'cup', 'ingridient': 'dark sultanas or golden raisins'}, {'amount': '1/4', 'unit': 'cup', 'ingridient': 'dried currants'}, {'amount': '5/4', 'unit': 'sticks', 'ingridient': 'unsalted butter'}, {'amount': '1', 'unit': 'cup', 'ingridient': 'packed light brown sugar'}, {'amount': '2', 'unit': 'large', 'ingridient': 'eggs'}, {'amount': '1', 'unit': 'cup', 'ingridient': 'all-purpose flour'}, {'amount': '1/2', 'unit': 'teaspoon', 'ingridient': 'baking soda'}, {'amount': '1/2', 'unit': 'teaspoon', 'ingridient': 'ground cinnamon'}, {'amount': '2', 'unit': 'teaspoons', 'ingridient': 'vanilla extract'}, {'amount': '2', 'unit': 'cups', 'ingridient': 'rolled oats'}, {'amount': '3/4', 'unit': 'egg', 'ingridient': 'white'}, {'amount': '1/2', 'unit': 'pound', 'ingridient': 'butter'}, {'amount': '1', 'unit': 'cup', 'ingridient': 'dried apricots'}], 'fitness': 14}, {'title': 'jovial_torvalds Cookies', 'ingridients': [{'amount': '1', 'unit': 'sugar', 'ingridient': 'cookies'}, {'amount': '3/2', 'unit': 'cups', 'ingridient': 'packed brown sugar'}, {'amount': '3/4', 'unit': 'cup', 'ingridient': 'white sugar'}, {'amount': '2', 'unit': 'teaspoons', 'ingridient': 'baking powder'}, {'amount': '1', 'unit': 'cup', 'ingridient': 'chopped walnuts'}, {'amount': '1', 'unit': 'cup', 'ingridient': 'chopped walnuts'}, {'amount': '1/2', 'unit': 'cup', 'ingridient': 'Crisco® Baking Sticks All-Vegetable Shortening'}, {'amount': '6', 'unit': 'tablespoons', 'ingridient': 'honey'}, {'amount': '1/2', 'unit': 'teaspoon', 'ingridient': 'baking soda'}]}]\n"
          ]
        }
      ],
      "source": [
        "import os\n",
        "import random\n",
        "import namesgenerator\n",
        "import json\n",
        "from fractions import Fraction\n",
        "\n",
        "dataset_file = \"./data/recipes.json\"\n",
        "generation_setter = 0.6\n",
        "exploration_setter = 0.6\n",
        "exploitation_setter = 0.4\n",
        "mutation_rate = 0.2\n",
        "\n",
        "if not os.path.exists(dataset_file):\n",
        "    print(\"Dataset file not found\")\n",
        "    exit()\n",
        "\n",
        "with open(dataset_file) as json_file:\n",
        "    data = json.load(json_file)\n",
        "\n",
        "recipes = data[\"recipes\"]\n",
        "# Remove recipes with no ingridients\n",
        "for recipe in recipes:\n",
        "    if len(recipe[\"ingridients\"]) == 0:\n",
        "        recipes.remove(recipe)\n",
        "\n",
        "def mutation_delete_ingridient(recipe):\n",
        "    # Select a random ingridient from the recipe\n",
        "    if len(recipe[\"ingridients\"]) == 0:\n",
        "        return None\n",
        "    random_ingridient = random.choice(recipe[\"ingridients\"])\n",
        "    # Delete the ingridient from the recipe\n",
        "    recipe[\"ingridients\"].remove(random_ingridient)\n",
        "    return recipe\n",
        "\n",
        "def mutation_double_amount(recipe):\n",
        "    # Select a random ingridient from the recipe\n",
        "    if len(recipe[\"ingridients\"]) == 0:\n",
        "        return None\n",
        "    random_ingridient = random.choice(recipe[\"ingridients\"])\n",
        "    # Check if the \"amount\" attribute is present\n",
        "    if \"amount\" in random_ingridient:\n",
        "        try:\n",
        "            # Attempt to parse the \"amount\" as a fraction\n",
        "            amount_fraction = Fraction(random_ingridient[\"amount\"])\n",
        "            # Double the amount as a fraction\n",
        "            new_amount_fraction = amount_fraction * 2\n",
        "            # Update the \"amount\" attribute\n",
        "            random_ingridient[\"amount\"] = str(new_amount_fraction)\n",
        "        except ValueError:\n",
        "            # Handle the case where the \"amount\" cannot be parsed as a fraction\n",
        "            print(f\"Warning: Unable to parse '{random_ingridient['amount']}' as a fraction.\")\n",
        "\n",
        "    return recipe\n",
        "\n",
        "def mutation_change_amount(recipe):\n",
        "    # Select a random ingridient from the recipe\n",
        "    if len(recipe[\"ingridients\"]) == 0:\n",
        "        return None\n",
        "    random_ingridient = random.choice(recipe[\"ingridients\"])\n",
        "    # Change the amount of the ingridient to one of a random ingriedient from the ingridient list\n",
        "    random_ingridient[\"amount\"] = random.choice(random.choice(recipes)[\"ingridients\"])[\"amount\"]\n",
        "\n",
        "    return recipe\n",
        "\n",
        "def mutation_add_ingridient(recipe):\n",
        "    # Select a random ingridient from the dataset\n",
        "    random_recipe = random.choice(recipes)\n",
        "    random_recipe_ingridient = random.choice(random_recipe[\"ingridients\"])\n",
        "    # add random ingridient to the recipe\n",
        "    recipe[\"ingridients\"].append(random_recipe_ingridient)\n",
        "    return recipe\n",
        "\n",
        "\n",
        "def mutation(recipe):\n",
        "    probabilities = [0.2,0.3,0.3,0.2]\n",
        "    probabilities = [p / sum(probabilities) for p in probabilities]\n",
        "    selected_mutation = random.choices([mutation_delete_ingridient, mutation_double_amount, mutation_change_amount,mutation_add_ingridient], weights=probabilities)[0]\n",
        "    return selected_mutation(recipe)\n",
        "\n",
        "def crossover(recipes):\n",
        "    new_recipes = {\n",
        "        \"title\": namesgenerator.get_random_name() + \" Cookies\",\n",
        "        \"ingridients\": []\n",
        "    }\n",
        "    # Select two random recipes\n",
        "    recipe1 = random.choice(recipes)\n",
        "    recipe2 = random.choice(recipes)\n",
        "    while recipe1[\"title\"] == recipe2[\"title\"]:\n",
        "        recipe2 = random.choice(recipes)\n",
        "\n",
        "    # 1. Select the ingridients from the recipe\n",
        "    recipe1_ingridients = recipe1[\"ingridients\"]\n",
        "    recipe2_ingridients = recipe2[\"ingridients\"]\n",
        "\n",
        "    # 2. Create a binary encoding scheme for the ingridients\n",
        "    recipe1_ingridients_binary = []\n",
        "    recipe2_ingridients_binary = []\n",
        "    for ingridient in recipe1_ingridients:\n",
        "        recipe1_ingridients_binary.append(random.randint(0, 1))\n",
        "    for ingridient in recipe2_ingridients:\n",
        "        recipe2_ingridients_binary.append(random.randint(0, 1))\n",
        "    \n",
        "    # Add ingridients marked as 1 from both recipes to the new recipe in  \"ingredients\" key\n",
        "    for i in range(len(recipe1_ingridients_binary)):\n",
        "        if recipe1_ingridients_binary[i] == 1:\n",
        "            new_recipes[\"ingridients\"].append(recipe1_ingridients[i])\n",
        "    for i in range(len(recipe2_ingridients_binary)):\n",
        "        if recipe2_ingridients_binary[i] == 1:\n",
        "            new_recipes[\"ingridients\"].append(recipe2_ingridients[i])\n",
        "    if(new_recipes[\"ingridients\"] == []):\n",
        "        return recipes\n",
        "    \n",
        "    recipes.append(new_recipes)\n",
        "\n",
        "    return recipes\n",
        "\n",
        "\n",
        "def get_ingridient_list(recipes):\n",
        "    ingredients = []\n",
        "    unique_ingredients = set()\n",
        "    i = 1\n",
        "    for recipe in recipes:\n",
        "        for ingredient in recipe[\"ingridients\"]:\n",
        "            if ingredient[\"ingridient\"] not in unique_ingredients:\n",
        "                unique_ingredients.add(ingredient[\"ingridient\"])\n",
        "                ingredients.append({\"id\": i, \"ingridient\": ingredient[\"ingridient\"]})\n",
        "                i += 1\n",
        "    return ingredients\n",
        "\n",
        "\n",
        "def get_fitness(recipe):\n",
        "    if \"ingridients\" in recipe:\n",
        "        return len(recipe[\"ingridients\"])\n",
        "    else:\n",
        "        return recipe[\"fitness\"]\n",
        "\n",
        "def get_sorted_fitness(recipes):\n",
        "    fitnesses = []\n",
        "    for recipe in recipes:\n",
        "        recipe[\"fitness\"] = get_fitness(recipe)\n",
        "\n",
        "    return sorted(recipes, key=lambda x: x[\"fitness\"])\n",
        "\n",
        "def select_population(recipes):\n",
        "    selected_recipes = []\n",
        "    sorted_fitnesses = get_sorted_fitness(recipes)\n",
        "    fitness_midpoint = len(sorted_fitnesses) // 2\n",
        "\n",
        "    total_length = generation_setter * len(sorted_fitnesses)\n",
        "    upper_length = exploitation_setter * total_length\n",
        "    lower_length = exploration_setter * total_length\n",
        "\n",
        "    # Select 40% of recipes from upper half\n",
        "    for i in range(int(upper_length)):\n",
        "        if get_fitness(sorted_fitnesses[i]) != 0:\n",
        "            selected_recipes.append(sorted_fitnesses[i])\n",
        "\n",
        "    # Select 60% of recipes from lower half randomly\n",
        "    for i in range(int(lower_length)):\n",
        "        recipe = sorted_fitnesses[random.randint(fitness_midpoint, len(sorted_fitnesses) - 1)]\n",
        "        if get_fitness(sorted_fitnesses[random.randint(fitness_midpoint, len(sorted_fitnesses) - 1)]) != 0:\n",
        "            selected_recipes.append(recipe)\n",
        "\n",
        "    return selected_recipes\n",
        "\n",
        "def generate_random_recipes(recipes):\n",
        "    new_recipes = []\n",
        "    sel_rec = recipes\n",
        "    while len(sel_rec) > 6:\n",
        "        # Selection\n",
        "        sel_rec = select_population(sel_rec)\n",
        "\n",
        "        # Crossover\n",
        "        new_recipes = crossover(sel_rec)\n",
        "\n",
        "        # Mutation based on a random probability\n",
        "        for recipe in new_recipes:\n",
        "            if random.random() < mutation_rate:\n",
        "                temp = recipe\n",
        "                recipe = mutation(recipe)\n",
        "                if recipe == None:\n",
        "                    new_recipes.remove(temp)\n",
        "\n",
        "        sel_rec = new_recipes\n",
        "    \n",
        "    print(sel_rec)\n",
        "\n",
        "if __name__ == \"__main__\":\n",
        "    generate_random_recipes(recipes)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": []
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "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": 0
}