examples/use_FIDDLE.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tutorial"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating and Extending Erdos-Renyi and Barabasi-Albert Networks\n",
    "We will begin by importing the necessary packages and scripts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import sys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add src/ and dependencies/ folders to environmental path\n",
    "sys.path.insert(0, os.path.abspath(os.path.join(os.getcwd(), os.pardir, 'src')))\n",
    "sys.path.insert(0, os.path.abspath(os.path.join(os.getcwd(), os.pardir, 'dependencies')))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from FIDDLE import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Next we must set key parameters to describe the network we wish to create"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Specifying key variables for network creation:\n",
    "\n",
    "#     Attribute of your network\n",
    "network_type = 5\n",
    "nodes = 10 \n",
    "positive_probability = 0.5\n",
    "\n",
    "# #     Additional but unnecessary attributes for your network\n",
    "# edge_probability=0.5 #Only affects network_type = 2 or 4\n",
    "# attaching_edges=2 #Only affects network_type = 5\n",
    "\n",
    "#     Directory to save the output\n",
    "# To keep root folder intact, save outputs in directory 'examples/output/' and group by output_base\n",
    "out_dir = 'output'\n",
    "output_base = '1_Sample_Network'\n",
    "\n",
    "isExist = os.path.exists(os.path.join(out_dir, output_base))\n",
    "if not isExist:\n",
    "    os.makedirs(os.path.join(out_dir, output_base))\n",
    "\n",
    "#     Variables to save the network\n",
    "network_description_file = os.path.join(out_dir, output_base, 'network_description.txt')\n",
    "network_figure_file = os.path.join(out_dir, output_base, 'network_figure.png')\n",
    "network_model_file = os.path.join(out_dir, output_base, 'network_full.xlsx')\n",
    "\n",
    "#Variables to run a simulation\n",
    "network_trace_file = os.path.join(out_dir, output_base, 'network_trace.txt')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating the network itself"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "------------------ Specified Network Characteristics ------------------\n",
      "Network Type: 5\n",
      "Specified Nodes: 10\n",
      "Specified Probability of Positive Edges: 0.5\n",
      "Specified 'edge_probability' (only affects Type 2 and 4): 0.5\n",
      "Specified 'attaching_edges' (only affects Type 5): 2\n",
      "\n",
      "-------------------- Actual Network Characteristics -------------------\n",
      "Number of Actual Nodes: 10\n",
      "Number of Directed Edges: 16\n",
      "Number of Positive Edges: 10\n",
      "Number of Negative Edges: 6\n",
      "Actual Probability of Positive Edges: 0.625\n",
      "\n",
      "----------------- Descriptive Network Characteristics -----------------\n",
      "Network Density: 0.17777777777777778\n",
      "Undirected Edges: 32\n",
      "Network Average Degree: 3.2\n",
      "Undirected Model Diameter: 3\n",
      "Undirected Model Clustering: 0.32666666666666666\n",
      "\n",
      "---------------------------- List of Edges ---------------------------\n",
      "['0', '1', '-']\n",
      "['0', '2', '-']\n",
      "['0', '3', '+']\n",
      "['0', '4', '+']\n",
      "['0', '8', '+']\n",
      "['1', '3', '-']\n",
      "['1', '5', '+']\n",
      "['1', '7', '+']\n",
      "['3', '4', '+']\n",
      "['3', '6', '+']\n",
      "['3', '9', '-']\n",
      "['4', '5', '-']\n",
      "['4', '8', '+']\n",
      "['5', '6', '+']\n",
      "['5', '7', '-']\n",
      "['5', '9', '+']\n"
     ]
    }
   ],
   "source": [
    "#Create the network\n",
    "G = graph_maker(network_type, nodes, positive_probability)\n",
    "# print(type(G))\n",
    "\n",
    "# See the edges in G\n",
    "edge_list = get_model_edges(G)\n",
    "# print(edge_list)\n",
    "\n",
    "# See the Characteristics of the created network\n",
    "# return_model_stats(G, network_type, nodes, positive_probability)\n",
    "return_model_stats(G, network_type, nodes, positive_probability, save = True, filename = network_description_file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualizing the Network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 500x500 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 500x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# See the network itself\n",
    "#Saving the figure\n",
    "plot_network(G, save = True, filename = network_figure_file)\n",
    "\n",
    "#Displaying the figure (not saving)\n",
    "plot_network(G)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Saving the network to a file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Saving the network to an excel file\n",
    "# network_to_excel(G)\n",
    "network_to_excel(G, filename = network_model_file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initializing the network and getting it ready for simulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'0': 1, '1': 1, '2': 1, '3': 1, '4': 1, '8': 1, '5': 1, '7': 1, '6': 1, '9': 1}\n"
     ]
    }
   ],
   "source": [
    "#Create an initialization scheme for the network\n",
    "initial_vals = create_initial_values(G, initial=1)\n",
    "# initial_vals = create_initial_values_random(G, lower_bound = 0, upper_bound = 2)\n",
    "# initial_vals = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}\n",
    "# initial_vals = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '10':10}\n",
    "# initial_vals = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9, '10':10}\n",
    "print(initial_vals)\n",
    "\n",
    "#Add initial values to the network file\n",
    "update_network_file(filename = network_model_file, update_column = 6, update_values = initial_vals)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Simulating the Network based on the initial values and network structure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Simulate the network\n",
    "\n",
    "#Initialization of key parameters:\n",
    "simulation_runs = 10 #simRun\n",
    "simulation_length = 100 #simLen\n",
    "\n",
    "#Simulate the network\n",
    "simulate_network(network_model_file, simulation_runs, simulation_length, network_trace_file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Saving the simulation end values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Identify the simulation end state and values\n",
    "end_vals = get_simulation_end_values(network_trace_file, simulation_runs)\n",
    "\n",
    "#Update the network file to include the end values for each node\n",
    "update_network_file(filename = network_model_file, update_column = 7, update_values = end_vals)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating extendable models from the base network we just created"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 500x500 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 500x500 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Definingh key Variables\n",
    "output_base2 = '2_Sample_Removal'\n",
    "output_directory = os.path.join(out_dir, output_base2)\n",
    "removal_probabilities = [0.1, 0.25]\n",
    "\n",
    "#Wrapper function to create extenable models from base G\n",
    "create_extendable_models(G, output_directory, removal_probabilities, end_vals, model_name = 'network', positive_probability = 0.5)\n",
    "\n",
    "# #Copy in relevant full network files such that we can see the removal process\n",
    "# os.system(\"cp \"+network_description_file+\" \"+output_directory+str(network_description_file.split(\"/\")[-1]))\n",
    "# os.system(\"cp \"+network_figure_file+\" \"+output_directory+str(network_figure_file.split(\"/\")[-1]))\n",
    "# os.system(\"cp \"+network_model_file+\" \"+output_directory+str(network_model_file.split(\"/\")[-1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Extending models "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Getting the directory ready \n",
    "# Creating the directory to store this example\n",
    "extension_base = '3_Extension'\n",
    "extension_directory = os.path.join(out_dir, extension_base)\n",
    "os.makedirs(extension_directory, exist_ok=True)\n",
    "\n",
    "# Copying in the relevant Files\n",
    "#    Network to be extended\n",
    "file_to_copy = os.path.join(out_dir, output_base2, 'Missing_25_percent','network_missing_25_percent.xlsx')\n",
    "new_filename = \"network_to_extend.xlsx\"\n",
    "network_file_location = os.path.join(extension_directory, new_filename)\n",
    "os.system(\"cp \" + file_to_copy + \" \" + network_file_location)\n",
    "\n",
    "#    Real Extensions (those that were actually in the initial baseline model)\n",
    "file_to_copy = os.path.join(out_dir, output_base2, 'Missing_25_percent','network_missing_25_percent_grouped_real_ext')\n",
    "new_filename = \"extensions_real\"\n",
    "extensions_real_location = os.path.join(extension_directory, new_filename)\n",
    "os.system(\"cp \" + file_to_copy + \" \" + extensions_real_location)\n",
    "\n",
    "#    Fake Extensions (those that were never in the initial baseline model)\n",
    "file_to_copy = os.path.join(out_dir, output_base2, 'Missing_25_percent','network_missing_25_percent_grouped_fake_ext')\n",
    "new_filename = \"extensions_fake\"\n",
    "extensions_fake_location = os.path.join(extension_directory, new_filename)\n",
    "os.system(\"cp \" + file_to_copy + \" \" + extensions_fake_location)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# In reality, you won't know which extensions are real or fake. Let's combine the files now to mimic real life. \n",
    "with open(extensions_real_location,'rb') as extensions: extensions_real = pickle.load(extensions)\n",
    "with open(extensions_fake_location,'rb') as extensions: extensions_fake = pickle.load(extensions)\n",
    "\n",
    "#Initialize list for all extensions\n",
    "total_extensions = []\n",
    "\n",
    "#Seed the random generator \n",
    "random.seed()\n",
    "\n",
    "#While not perfect, this ensure the extensions are added in a semi-mixed format with real/fake extensions not being lumped in the front or back \n",
    "for real, fake in zip(extensions_real, extensions_fake):\n",
    "\n",
    "    #Pick a random number\n",
    "    prob = random.random()\n",
    "\n",
    "    #Add real first\n",
    "    if prob > 0.5: \n",
    "        total_extensions.append(real)\n",
    "        total_extensions.append(fake)\n",
    "\n",
    "    #Add fake first\n",
    "    else: \n",
    "        total_extensions.append(fake)\n",
    "        total_extensions.append(real)\n",
    "\n",
    "#Saving the total extensions now\n",
    "with open(os.path.join(extension_directory,'all_extensions'),'wb') as extensions: pickle.dump(total_extensions, extensions)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Extending the model via BFA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Set the directory to extend the model in a BFA manner\n",
    "output_directory = os.path.join(extension_directory, 'BFA')\n",
    "\n",
    "start_model = os.path.join(extension_directory, 'network_to_extend.xlsx')\n",
    "extensions_file = os.path.join(extension_directory, 'all_extensions')\n",
    "with open(extensions_file,'rb') as extensions: possible_extensions = pickle.load(extensions)\n",
    "\n",
    "#Parameterizing key variables for the extension process\n",
    "# Many of these variables were set above during the network creation phase. \n",
    "# They are being re-set here for clarity and convenience.\n",
    "# weight = 1                          #Don't worry about this, this is for future work \n",
    "# num_Scen = 1                        #Don't worry about this, this is for future work \n",
    "simulation_runs = 10\n",
    "simulation_length = 100\n",
    "\n",
    "#Unsupported for no\n",
    "#Set multiprocessing capabilities\n",
    "# numCores = 1\n",
    "# numCores = multiprocessing.cpu_count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial difference between the correct and current model: 9.700000000000001\n",
      "Extension: [16, ['9', '7', '+']] has a score of: 0.8\n",
      "Extension: [0, ['0', '1', '-']] has a score of: 8.7\n",
      "Extension: [1, ['0', '2', '-']] has a score of: 3.0999999999999996\n",
      "Extension: [17, ['9', '8', '+']] has a score of: 0.4000000000000002\n",
      "Extension: [2, ['3', '9', '-']] has a score of: 0.7999999999999998\n",
      "Extension: [18, ['4', '3', '-']] has a score of: 1.3999999999999997\n",
      "Extension: [19, ['7', '1', '-']] has a score of: 8.1\n",
      "Extension: [3, ['0', '4', '+']] has a score of: 6.8\n",
      "Extension: [20, ['7', '8', '-']] has a score of: 3.0999999999999996\n",
      "Extension: [4, ['3', '6', '+']] has a score of: 1.6\n",
      "Extension: [5, ['4', '8', '+']] has a score of: 1.0\n",
      "Extension: [21, ['2', '9', '+']] has a score of: 2.8\n",
      "Minimum found of: 0.4000000000000002 with extension 17\n",
      "Minimum was less than previous score, saving best extension.\n",
      "Extension: [16, ['9', '7', '+']] has a score of: 2.2\n",
      "Extension: [0, ['0', '1', '-']] has a score of: 8.999999999999998\n",
      "Extension: [1, ['0', '2', '-']] has a score of: 2.3000000000000003\n",
      "Extension: [2, ['3', '9', '-']] has a score of: 1.7\n",
      "Extension: [18, ['4', '3', '-']] has a score of: 2.0999999999999996\n",
      "Extension: [19, ['7', '1', '-']] has a score of: 7.8999999999999995\n",
      "Extension: [3, ['0', '4', '+']] has a score of: 5.999999999999999\n",
      "Extension: [20, ['7', '8', '-']] has a score of: 3.9000000000000004\n",
      "Extension: [4, ['3', '6', '+']] has a score of: 1.4000000000000001\n",
      "Extension: [5, ['4', '8', '+']] has a score of: 1.6\n",
      "Extension: [21, ['2', '9', '+']] has a score of: 2.0999999999999996\n",
      "Minimum found of: 1.4000000000000001 with extension 4\n",
      "Minimum was NOT less than previous score, saving best extension.\n",
      "Diff Trend:  [9.700000000000001, 0.4000000000000002]\n",
      "Start time: 2023-02-27 18:01:22.240381\n",
      "  End time: 2023-02-27 18:01:23.791279\n",
      "Total time: 0:00:01.550898\n"
     ]
    }
   ],
   "source": [
    "BFA(start_model, possible_extensions, simulation_runs, simulation_length, output_directory)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Extending the model via DFA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Set the directory to extend the model in a BFA manner\n",
    "output_directory = os.path.join(extension_directory, 'DFA')\n",
    "\n",
    "start_model = os.path.join(extension_directory, 'network_to_extend.xlsx')\n",
    "extensions_file = os.path.join(extension_directory, 'all_extensions')\n",
    "with open(extensions_file,'rb') as extensions: possible_extensions = pickle.load(extensions)\n",
    "\n",
    "#Parameterizing key variables for the extension process\n",
    "# Many of these variables were set above during the network creation phase. \n",
    "# They are being re-set here for clarity and convenience.\n",
    "# weight = 1                          #Don't worry about this, this is for future work \n",
    "# num_Scen = 1                        #Don't worry about this, this is for future work \n",
    "simulation_runs = 10\n",
    "simulation_length = 100\n",
    "\n",
    "#Unsupported for no\n",
    "#Set multiprocessing capabilities\n",
    "# numCores = 1\n",
    "# numCores = multiprocessing.cpu_count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial difference between the correct and current model: 10.399999999999999\n",
      "Starting extending the current best model with extension: 16\n",
      "Extension: [16, ['9', '7', '+']] has a score of: 2.3\n",
      "Extension: [16, ['9', '7', '+']] is an improvement.\n",
      "Starting extending the current best model with extension: 0\n",
      "Extension: [0, ['0', '1', '-']] has a score of: 9.7\n",
      "Starting extending the current best model with extension: 1\n",
      "Extension: [1, ['0', '2', '-']] has a score of: 5.2\n",
      "Starting extending the current best model with extension: 17\n",
      "Extension: [17, ['9', '8', '+']] has a score of: 1.5999999999999999\n",
      "Extension: [17, ['9', '8', '+']] is an improvement.\n",
      "Starting extending the current best model with extension: 0\n",
      "Extension: [0, ['0', '1', '-']] has a score of: 10.0\n",
      "Starting extending the current best model with extension: 1\n",
      "Extension: [1, ['0', '2', '-']] has a score of: 3.6999999999999997\n",
      "Starting extending the current best model with extension: 2\n",
      "Extension: [2, ['3', '9', '-']] has a score of: 1.4000000000000001\n",
      "Extension: [2, ['3', '9', '-']] is an improvement.\n",
      "Starting extending the current best model with extension: 0\n",
      "Extension: [0, ['0', '1', '-']] has a score of: 10.3\n",
      "Starting extending the current best model with extension: 1\n",
      "Extension: [1, ['0', '2', '-']] has a score of: 4.8\n",
      "Starting extending the current best model with extension: 18\n",
      "Extension: [18, ['4', '3', '-']] has a score of: 1.8999999999999997\n",
      "Starting extending the current best model with extension: 19\n",
      "Extension: [19, ['7', '1', '-']] has a score of: 9.5\n",
      "Starting extending the current best model with extension: 3\n",
      "Extension: [3, ['0', '4', '+']] has a score of: 7.3\n",
      "Starting extending the current best model with extension: 20\n",
      "Extension: [20, ['7', '8', '-']] has a score of: 3.3\n",
      "Starting extending the current best model with extension: 4\n",
      "Extension: [4, ['3', '6', '+']] has a score of: 2.3\n",
      "Starting extending the current best model with extension: 5\n",
      "Extension: [5, ['4', '8', '+']] has a score of: 1.4999999999999996\n",
      "Starting extending the current best model with extension: 21\n",
      "Extension: [21, ['2', '9', '+']] has a score of: 1.0999999999999999\n",
      "Extension: [21, ['2', '9', '+']] is an improvement.\n",
      "Starting extending the current best model with extension: 0\n",
      "Extension: [0, ['0', '1', '-']] has a score of: 10.1\n",
      "Starting extending the current best model with extension: 1\n",
      "Extension: [1, ['0', '2', '-']] has a score of: 3.0999999999999996\n",
      "Starting extending the current best model with extension: 18\n",
      "Extension: [18, ['4', '3', '-']] has a score of: 2.4000000000000004\n",
      "Starting extending the current best model with extension: 19\n",
      "Extension: [19, ['7', '1', '-']] has a score of: 9.4\n",
      "Starting extending the current best model with extension: 3\n",
      "Extension: [3, ['0', '4', '+']] has a score of: 6.699999999999999\n",
      "Starting extending the current best model with extension: 20\n",
      "Extension: [20, ['7', '8', '-']] has a score of: 2.4\n",
      "Starting extending the current best model with extension: 4\n",
      "Extension: [4, ['3', '6', '+']] has a score of: 2.6999999999999997\n",
      "Starting extending the current best model with extension: 5\n",
      "Extension: [5, ['4', '8', '+']] has a score of: 1.6999999999999997\n",
      "No more extensions have been found that improve the model.\n",
      "Diff Trend:  [10.399999999999999, 2.3, 1.5999999999999999, 1.4000000000000001, 1.0999999999999999]\n",
      "Start time: 2023-02-27 18:01:23.848670\n",
      "  End time: 2023-02-27 18:01:25.745353\n",
      "Total time: 0:00:01.896683\n",
      "No more extensions have been found that improve the model.\n",
      "Diff Trend:  [10.399999999999999, 2.3, 1.5999999999999999, 1.4000000000000001, 1.0999999999999999]\n",
      "Start time: 2023-02-27 18:01:23.848670\n",
      "  End time: 2023-02-27 18:01:25.745549\n",
      "Total time: 0:00:01.896879\n",
      "No more extensions have been found that improve the model.\n",
      "Diff Trend:  [10.399999999999999, 2.3, 1.5999999999999999, 1.4000000000000001, 1.0999999999999999]\n",
      "Start time: 2023-02-27 18:01:23.848670\n",
      "  End time: 2023-02-27 18:01:25.745601\n",
      "Total time: 0:00:01.896931\n",
      "No more extensions have been found that improve the model.\n",
      "Diff Trend:  [10.399999999999999, 2.3, 1.5999999999999999, 1.4000000000000001, 1.0999999999999999]\n",
      "Start time: 2023-02-27 18:01:23.848670\n",
      "  End time: 2023-02-27 18:01:25.745647\n",
      "Total time: 0:00:01.896977\n"
     ]
    }
   ],
   "source": [
    "DFA(start_model, possible_extensions, simulation_runs, simulation_length, output_directory)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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.8.5"
  },
  "vscode": {
   "interpreter": {
    "hash": "ba2f6b0c1036f354de8120ecead7068d7e6d58d31d056ede0714df4277ff447d"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}