VDSML_Mentoring_Program.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total 56\n",
      "-rw-rw-r-- 1 david david 37020 Jul 11 11:08 'Mentor_Mentee Tracker (4_20_23) - Sheet1.csv'\n",
      "-rw-rw-r-- 1 david david 13458 Jul 12 09:40  VDSML_Mentoring_Program.ipynb\n"
     ]
    }
   ],
   "source": [
    "!ls -l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import operator\n",
    "import networkx as nx\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>preferred name</th>\n",
       "      <th>submitted on</th>\n",
       "      <th>Mentor action</th>\n",
       "      <th>Mentee action</th>\n",
       "      <th>Mentor assigned</th>\n",
       "      <th>When was last manual contact made?</th>\n",
       "      <th>Who made last contact?</th>\n",
       "      <th>linkedin profile address</th>\n",
       "      <th>email</th>\n",
       "      <th>phone</th>\n",
       "      <th>...</th>\n",
       "      <th>How many years of Data Science and Machine Learning education do you have</th>\n",
       "      <th>Technical education years?</th>\n",
       "      <th>How many years of Data Science and Machine Learning work experience do you have</th>\n",
       "      <th>Technical employment years?</th>\n",
       "      <th>what are you looking for in a mentor</th>\n",
       "      <th>what industries are you most interested in</th>\n",
       "      <th>what use cases are you most interested in</th>\n",
       "      <th>Was there something more specific missing from the above categories</th>\n",
       "      <th>Have you looked at Veterati for data science and machine learning mentoring</th>\n",
       "      <th>Admin Notes</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>field_0 field_1</td>\n",
       "      <td>4/24/2023</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>field_2</td>\n",
       "      <td>field_3@gmail.com</td>\n",
       "      <td>(444) 444-4444</td>\n",
       "      <td>...</td>\n",
       "      <td>field_8</td>\n",
       "      <td>NaN</td>\n",
       "      <td>field_9</td>\n",
       "      <td>NaN</td>\n",
       "      <td>field_10</td>\n",
       "      <td>Business/Administration</td>\n",
       "      <td>Analytics/Statistics</td>\n",
       "      <td>field_13</td>\n",
       "      <td>I’m not on Veterati yet, but I will sign up.</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>1 rows × 24 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "    preferred name submitted on Mentor action Mentee action Mentor assigned  \\\n",
       "0  field_0 field_1    4/24/2023           NaN           NaN             NaN   \n",
       "\n",
       "  When was last manual contact made? Who made last contact?  \\\n",
       "0                                NaN                    NaN   \n",
       "\n",
       "  linkedin profile address              email           phone  ...  \\\n",
       "0                  field_2  field_3@gmail.com  (444) 444-4444  ...   \n",
       "\n",
       "  How many years of Data Science and Machine Learning education do you have  \\\n",
       "0                                            field_8                          \n",
       "\n",
       "  Technical education years?  \\\n",
       "0                        NaN   \n",
       "\n",
       "   How many years of Data Science and Machine Learning work experience do you have  \\\n",
       "0                                            field_9                                 \n",
       "\n",
       "  Technical employment years? what are you looking for in a mentor  \\\n",
       "0                         NaN                             field_10   \n",
       "\n",
       "   what industries are you most interested in  \\\n",
       "0                     Business/Administration   \n",
       "\n",
       "  what use cases are you most interested in  \\\n",
       "0                      Analytics/Statistics   \n",
       "\n",
       "   Was there something more specific missing from the above categories  \\\n",
       "0                                           field_13                     \n",
       "\n",
       "  Have you looked at Veterati for data science and machine learning mentoring  \\\n",
       "0       I’m not on Veterati yet, but I will sign up.                            \n",
       "\n",
       "  Admin Notes  \n",
       "0         NaN  \n",
       "\n",
       "[1 rows x 24 columns]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Load data, \n",
    "mentors = pd.read_csv('Mentor_Mentee Tracker (4_20_23) - Sheet1.csv')\n",
    "mentors.head(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Name',\n",
       " 'Date_Joined',\n",
       " 'Mentor_Action',\n",
       " 'Mentee_Action',\n",
       " 'Mentor_Assigned',\n",
       " 'Date_Last_Contact',\n",
       " 'VDSML_Coordinator',\n",
       " 'LinkedIn',\n",
       " 'Email',\n",
       " 'Phone',\n",
       " 'Service',\n",
       " 'Journey',\n",
       " 'Level',\n",
       " 'Why',\n",
       " 'Education',\n",
       " 'Education_Years',\n",
       " 'Employment',\n",
       " 'Employment_Years',\n",
       " 'Mentor_Wants',\n",
       " 'Industries',\n",
       " 'Use_Cases',\n",
       " 'Missing',\n",
       " 'Veterati',\n",
       " 'Notes']"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Rename columns\n",
    "mentors = mentors.rename(columns={\n",
    "    'preferred name': 'Name',\n",
    "    'submitted on': 'Date_Joined',\n",
    "    'Mentor action': 'Mentor_Action',\n",
    "    'Mentee action': 'Mentee_Action',\n",
    "    'Mentor assigned': 'Mentor_Assigned',\n",
    "    'When was last manual contact made?':'Date_Last_Contact',\n",
    "    'Who made last contact?':'VDSML_Coordinator',\n",
    "    'linkedin profile address':'LinkedIn',\n",
    "    'email':'Email',\n",
    "    'phone':'Phone',\n",
    "    'how did you serve': 'Service',\n",
    "    'Where are you in your Data Science and Machine Learning journey':'Journey',\n",
    "    'Journey Level': 'Level',\n",
    "    'why did you decide to pursue data science and machine learning':'Why',\n",
    "    'How many years of Data Science and Machine Learning education do you have':'Education',\n",
    "    'Technical education years?': 'Education_Years',\n",
    "    'How many years of Data Science and Machine Learning work experience do you have':'Employment',\n",
    "    'Technical employment years?': 'Employment_Years',\n",
    "    'what are you looking for in a mentor':'Mentor_Wants',\n",
    "    'what industries are you most interested in': 'Industries',\n",
    "    'what use cases are you most interested in': 'Use_Cases',\n",
    "    'Was there something more specific missing from the above categories':'Missing',\n",
    "    'Have you looked at Veterati for data science and machine learning mentoring': 'Veterati',\n",
    "    'Admin Notes':'Notes',\n",
    "    })\n",
    "list(mentors.columns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Name</th>\n",
       "      <th>Date_Joined</th>\n",
       "      <th>Mentor_Action</th>\n",
       "      <th>Mentee_Action</th>\n",
       "      <th>Mentor_Assigned</th>\n",
       "      <th>Service</th>\n",
       "      <th>Level</th>\n",
       "      <th>Education_Years</th>\n",
       "      <th>Employment_Years</th>\n",
       "      <th>Industries</th>\n",
       "      <th>Use_Cases</th>\n",
       "      <th>Veterati</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>David Ramirez</td>\n",
       "      <td>4/20/2023</td>\n",
       "      <td>Paired with mentees; Available for additional ...</td>\n",
       "      <td>Awaiting mentor</td>\n",
       "      <td>NaN</td>\n",
       "      <td>Marine Corps</td>\n",
       "      <td>3.0</td>\n",
       "      <td>8.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>Defense/Military,Aerospace/Telemetry/Sensors,G...</td>\n",
       "      <td>Data Capture/Serving,Pattern Detection,Modelin...</td>\n",
       "      <td>Yes, I signed up for both!</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            Name Date_Joined  \\\n",
       "1  David Ramirez   4/20/2023   \n",
       "\n",
       "                                       Mentor_Action    Mentee_Action  \\\n",
       "1  Paired with mentees; Available for additional ...  Awaiting mentor   \n",
       "\n",
       "  Mentor_Assigned       Service  Level  Education_Years  Employment_Years  \\\n",
       "1             NaN  Marine Corps    3.0              8.0              11.0   \n",
       "\n",
       "                                          Industries  \\\n",
       "1  Defense/Military,Aerospace/Telemetry/Sensors,G...   \n",
       "\n",
       "                                           Use_Cases  \\\n",
       "1  Data Capture/Serving,Pattern Detection,Modelin...   \n",
       "\n",
       "                     Veterati  \n",
       "1  Yes, I signed up for both!  "
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# One time data clean up - drop private or unnecessary data \n",
    "mentors = mentors.drop(0) # drop first row of test data\n",
    "mentors = mentors.drop(axis='columns',\n",
    "    labels=['Date_Last_Contact',\n",
    "            'VDSML_Coordinator',\n",
    "            'LinkedIn',\n",
    "            'Email',\n",
    "            'Phone',\n",
    "            'Journey',\n",
    "            'Why',\n",
    "            'Education',\n",
    "            'Employment',\n",
    "            'Mentor_Wants',\n",
    "            'Missing',\n",
    "            'Notes'\n",
    "            ])\n",
    "\n",
    "mentors.head(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convert multi-select data to one-hot encoded columns for new dataframe\n",
    "service_1hot = mentors['Service'].str.get_dummies(sep = ',')\n",
    "industries_1hot = mentors['Industries'].str.get_dummies(sep = ',')\n",
    "usecases_1hot = mentors['Use_Cases'].str.get_dummies(sep = ',')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Parse Veterati question for status\n",
    "veterati_status = mentors['Veterati'].str.extract(\"(Yes|not)\")[0]\n",
    "veterati_status[veterati_status == 'Yes'] = True\n",
    "veterati_status[veterati_status == 'not'] = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Name</th>\n",
       "      <th>Date_Joined</th>\n",
       "      <th>Mentor_Action</th>\n",
       "      <th>Mentee_Action</th>\n",
       "      <th>Mentor_Assigned</th>\n",
       "      <th>Level</th>\n",
       "      <th>Education_Years</th>\n",
       "      <th>Employment_Years</th>\n",
       "      <th>Veterati</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>David Ramirez</td>\n",
       "      <td>4/20/2023</td>\n",
       "      <td>Paired with mentees; Available for additional ...</td>\n",
       "      <td>Awaiting mentor</td>\n",
       "      <td>NaN</td>\n",
       "      <td>3.0</td>\n",
       "      <td>8.0</td>\n",
       "      <td>11.0</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            Name Date_Joined  \\\n",
       "1  David Ramirez   4/20/2023   \n",
       "\n",
       "                                       Mentor_Action    Mentee_Action  \\\n",
       "1  Paired with mentees; Available for additional ...  Awaiting mentor   \n",
       "\n",
       "  Mentor_Assigned  Level  Education_Years  Employment_Years Veterati  \n",
       "1             NaN    3.0              8.0              11.0     True  "
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Update original dataframe\n",
    "mentors['Veterati'] = veterati_status\n",
    "mentors = mentors.drop(axis='columns',\n",
    "                            labels=['Service',\n",
    "                                    'Industries',\n",
    "                                    'Use_Cases',\n",
    "                                    ])\n",
    "mentors.head(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create new dataframe with interests of mentors\n",
    "interests = pd.merge(service_1hot,industries_1hot, left_index=True, right_index=True)\n",
    "interests = pd.merge(interests,usecases_1hot, left_index=True, right_index=True)\n",
    "interests.set_index(mentors['Name'], inplace=True)\n",
    "interests = interests.drop(axis='columns', labels=['Undecided/Unknown'])\n",
    "interests.head(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define function for calculating percentage match between mentor and mentee\n",
    "def calc_percent_match(mentor,mentee,interests):\n",
    "    assert isinstance(mentor, str)\n",
    "    assert isinstance(mentee, str)\n",
    "\n",
    "    compare = interests.loc[mentor] + interests.loc[mentee]\n",
    "    match_count = (compare == 2).astype(int).sum()\n",
    "    mentor_percent = int(round(match_count / interests.loc[mentor].sum(), 2)*100)\n",
    "    mentee_percent = int(round(match_count / interests.loc[mentee].sum(), 2)*100)\n",
    "    match_percent = max(mentor_percent, mentee_percent)\n",
    "    return match_percent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get paired mentors and mentees\n",
    "paired_mentors = mentors.loc[mentors['Mentor_Assigned'].notna(), 'Mentor_Assigned']\n",
    "paired_mentees = mentors.loc[mentors['Mentor_Assigned'].notna(), 'Name']\n",
    "edges = pd.DataFrame(\n",
    "    {'Mentor': paired_mentors,\n",
    "     'Mentee': paired_mentees,\n",
    "    })\n",
    "edges.drop(edges[edges['Mentor'] == 'NaN'].index, inplace=True)\n",
    "edges['weight'] = edges.apply(lambda x: calc_percent_match(x['Mentor'], x['Mentee'], interests), axis=1)\n",
    "edges"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initilize mentor to mentee directional graph\n",
    "Paired_Mentors = nx.from_pandas_edgelist(edges, 'Mentor', \"Mentee\", \"weight\", create_using=nx.DiGraph)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define function for plotting directional acyclic graph\n",
    "def plot_graph(G):\n",
    "    for layer, nodes in enumerate(nx.topological_generations(G)):\n",
    "        for node in nodes:\n",
    "            G.nodes[node][\"layer\"] = layer\n",
    "    pos = nx.multipartite_layout(G, subset_key=\"layer\")\n",
    "    fig, ax = plt.subplots()\n",
    "    nx.draw_networkx(G, pos=pos, ax=ax)\n",
    "    ax.set_title(\"VDSML Mentoring in topological order\")\n",
    "    fig.tight_layout()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_graph(Paired_Mentors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Find available MENTORS\n",
    "mentors['Mentor_Action'] = mentors['Mentor_Action'].fillna('')\n",
    "already_mentor = mentors['Mentor_Action'].str.contains(\"Paired with mentee\", case=False)\n",
    "wont_mentor = mentors['Mentor_Action'].str.contains(\"Won't\", case=False) # JERKS!\n",
    "too_junior = mentors['Mentor_Action'].str.contains(\"Too junior\", case=False)\n",
    "mentor_more = mentors['Mentor_Action'].str.contains(\"Available for additional mentee\", case=False) # MOTO!\n",
    "# Combine unavailable mentors, invert to find available mentors, and combine with mentors taking more mentees\n",
    "available_mentors = mentors[(~(already_mentor | wont_mentor | too_junior)) | mentor_more]\n",
    "available_mentors = available_mentors.drop(axis='columns', labels=['Date_Joined', 'Mentee_Action', 'Mentor_Assigned'])\n",
    "\n",
    "# Put temp pairs in here for testing\n",
    "#pending_mentors = ['John', 'Jane']\n",
    "#for name in pending_mentors:\n",
    "#    available_mentors = available_mentors[available_mentors['Name'] != name]\n",
    "\n",
    "available_mentors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Find unpaired MENTEES\n",
    "got_mentor = mentors['Mentee_Action'].str.contains(\"Paired with mentor\", case=False)\n",
    "not_mentee = mentors['Mentee_Action'].str.contains(\"Not looking for mentor\", case=False)\n",
    "# Combine already paired mentees with those not looking for a mentor, and invert to find unpaired mentees\n",
    "unpaired_mentees = mentors[~(got_mentor | not_mentee)]\n",
    "unpaired_mentees = unpaired_mentees.drop(axis='columns', labels=['Mentor_Action'])\n",
    "\n",
    "# Put temp pairs in here for testing\n",
    "#pending_mentees = ['John', 'Jane']\n",
    "#for name in pending_mentees:\n",
    "#    unpaired_mentees = unpaired_mentees[unpaired_mentees['Name'] != name]\n",
    "\n",
    "unpaired_mentees"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Search for an available mentor for each unpaired mentee\n",
    "\n",
    "# Initialize new array for tracking best matches \n",
    "new_edges = pd.DataFrame()\n",
    "\n",
    "for mentee_index, mentee_row in unpaired_mentees.iterrows():\n",
    "    # Get a next row from unpaired_mentees\n",
    "\n",
    "    # Initialize new temp dictionary for tracking potential match scores\n",
    "    matches = {}\n",
    "\n",
    "    for mentor_index, mentor_row in available_mentors.iterrows():\n",
    "        # Get next row from available mentors\n",
    "\n",
    "        # Ensure potential mentor and mentee not the same person\n",
    "        if mentor_row['Name'] is not mentee_row['Name']:\n",
    "\n",
    "            # Ensure mentor is higher level than mentee\n",
    "            if mentor_row['Level'] >= mentee_row['Level']:\n",
    "\n",
    "                #mentor_row = mentor_row.squeeze() # Is this necessary?\n",
    "\n",
    "                # Add one-hot encoded interests together (0 or 1), resulting values will be 0, 1, or 2\n",
    "                compare = interests.loc[mentor_row['Name']] + interests.loc[mentee_row['Name']]\n",
    "                # For each interest of value 2, this identifies an overlapping interest\n",
    "                match_count = (compare == 2).astype(int).sum()\n",
    "                # Find the fraction of matches over all interests for both MENTOR and MENTEE\n",
    "                mentor_percent = int(round(match_count / interests.loc[mentor_row['Name']].sum(), 2)*100)\n",
    "                mentee_percent = int(round(match_count / interests.loc[mentee_row['Name']].sum(), 2)*100)\n",
    "                # Score is the lower of these values, to account to overeager people\n",
    "                match_percent = max(mentor_percent, mentee_percent)\n",
    "                #match_percent = mentee_percent\n",
    "\n",
    "                matches[mentor_row['Name']] = match_percent\n",
    "\n",
    "    # Create new entry in edges based on greatest match\n",
    "    mentee_name = mentee_row['Name']\n",
    "    print('Mentee: '+mentee_name)\n",
    "    if len(matches) != 0:\n",
    "        # Find index in matches array with greatest match\n",
    "        best_mentor_name = max(matches, key=matches.get)\n",
    "        # Get percent match from dictionary key\n",
    "        percent_match = matches[best_mentor_name]\n",
    "        # Create new graph edge linking mentor to mentee\n",
    "        new_edge = pd.DataFrame({\"Mentor\": [best_mentor_name],\n",
    "                                \"Mentee\": [mentee_name],\n",
    "                                \"weight\": [percent_match],})\n",
    "        # Insert new graph edge into edges dataframe\n",
    "        new_edges = pd.concat([new_edges,new_edge], ignore_index = True)\n",
    "        print('  Best Mentor: '+best_mentor_name)\n",
    "        print('  Match Percent: '+str(percent_match))\n",
    "    print('')\n",
    "\n",
    "new_edges.reset_index()\n",
    "Potential_Pairs = nx.from_pandas_edgelist(new_edges, 'Mentor', \"Mentee\", \"weight\", create_using=nx.DiGraph)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "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.9.10"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}