Data_Viz_Tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Visualization in Python\n",
    "Take data and turn it into something colorful, graphical and meaningful :) \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Intro\n",
    "Data visualization allows data scientists to graphically represent data to extract and understand trends, outliers, patterns and further insights in the data.\n",
    "\n",
    "Python has many **many** graphing libraries with different features and it can be daunting to know which library to use.  This intro tutorial will focus on a few popular plotting libraries:\n",
    "* **Pandas** - built on Matplotlib and easy to use with Pandas dataframes\n",
    "* **Matplotlib** - massive library with lots of flexibility (stackoverflow will be your friend!)\n",
    "* **Seaborn** - statistical visualization with default themes and beautiful styles\n",
    "\n",
    "For interactive plots and possibly a feature tutorial\n",
    "* Plotly\n",
    "* D3\n",
    "* Bokeh\n",
    "\n",
    "\n",
    "This tutorial compares Matplotlib, Pandas and Seaborn for the following visualizations:\n",
    "* Scatter Plots \n",
    "* Line Charts \n",
    "* Histograms \n",
    "* Bar Charts \n",
    "* Box Plots \n",
    "* Pie Charts \n",
    "* Heatmaps \n",
    "* Faceting\n",
    "* Pairplots\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Setup \n",
    "Personally, I prefer to use a Conda environment and/or Docker container (if you are interested in knowing more about these setups let me know).  The README includes the specific packages you will need for this tutorial.  Please make sure you can run the following line without any errors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Import packages\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from sklearn.datasets import load_wine, load_iris\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Note:\n",
    "You may have to install or update the library `jinja2` for certain highlighting\n",
    "options to work (depending on the bug correction schedules for the `jinja2` or\n",
    "`pandas` development teams)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data \n",
    "Scikit-learn includes out of the box [datasets](https://scikit-learn.org/stable/datasets/index.html#]) which are great for practicing your data visualization skills.  We will use the classic wine and iris datasets - imported above.\n",
    "\n",
    "Since most of the plotting libraries play very nicely with Pandas DataFrames, we will format the *wine* and *iris* dataset with Pandas.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load the wine data set into a Pandas dataframe and view the first 5 rows\n",
    "wine = load_wine()\n",
    "wine_df = pd.DataFrame(data= np.c_[wine.data, wine.target],\n",
    "                 columns= list(wine.feature_names) + ['target'])\n",
    "# Add class label\n",
    "wine_df['class'] = pd.Categorical.from_codes(wine.target, wine.target_names)\n",
    "\n",
    "# Show the top 5 rows of Dataframe\n",
    "wine_df.head(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load the iris data set into a Pandas dataframe and view the first 5 rows\n",
    "iris = load_iris()\n",
    "iris_df =  pd.DataFrame(data= np.c_[iris.data, iris.target],\n",
    "                 columns= list(iris.feature_names) + ['target'])\n",
    "\n",
    "# Add class label\n",
    "iris_df['class'] = pd.Categorical.from_codes(iris.target, iris.target_names)\n",
    "\n",
    "# Show the top 5 rows of Dataframe\n",
    "iris_df.head(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pandas DataFrame Descriptive Statistics\n",
    "Don't forget to understand the statistics of your data!  You can also stylize your dataframe like you might in a csv.  There are ways to add visual impact to quantitative data.\n",
    "\n",
    "If you need a brief statistical refresher especially in the context of Python please see [Python Statistics Fundamentals: How to Describe Your Data](https://realpython.com/python-statistics/)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generate descriptive statistics of your DataFrame\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example using a color gradient to display data values in the DataFrame\n",
    "# For max/min use highlight_max()/highlight_min()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "iris_df.loc[:, 'sepal length (cm)': 'petal width (cm)'].head(10).style.background_gradient(subset=['sepal length (cm)', 'petal length (cm)'], cmap='BuGn').background_gradient(subset=['sepal width (cm)', 'petal width (cm)'], cmap='PuRd').highlight_max(color='yellow')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Scatter Plots\n",
    "The x-y plot or scatter plot represents the pairs of data from two datasets."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matplotlib\n",
    "Use **scatter** or use **plt.subplots** to stylize our plot with title and labels."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create a figure and axis\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "# scatter the sepal_length against the sepal_width\n",
    "\n",
    "# set a title and labels\n",
    "ax.set_title('Iris Dataset')\n",
    "ax.set_xlabel('sepal length (cm)')\n",
    "ax.set_ylabel('sepal width (cm)')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The plot would have more meaning if the data points are colored by class.  In Matplotlib we can create a color dictionary and then assign a color for each class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create color dictionary\n",
    "colors = {'setosa':'r', 'versicolor':'g', 'virginica':'b'}\n",
    "# create a figure and axis\n",
    "fig, ax = plt.subplots()\n",
    "# plot each data-point\n",
    "for c in np.unique(iris_df['class']):\n",
    "    ax.scatter(iris_df['sepal length (cm)'].loc[iris_df['class']==c], \n",
    "               iris_df['sepal width (cm)'].loc[iris_df['class']==c],\n",
    "               s=10*iris_df['petal length (cm)'].loc[iris_df['class']==c],\n",
    "               alpha=0.5,\n",
    "               color=colors[c],\n",
    "               label = c)\n",
    "\n",
    "# set a title and labels\n",
    "ax.set_title('Iris Dataset')\n",
    "ax.set_xlabel('sepal length (cm)')\n",
    "ax.set_ylabel('sepal width (cm)')\n",
    "ax.legend(loc='best')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pandas \n",
    "To create a scatter plot in Pandas we can call **dataset.plot.scatter()**. The axes labels will automatically be created from the DataFrame column names."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create Pandas scatter plot\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add coloring to plot by class \n",
    "# Note here we use the numeric target and not the class names\n",
    "iris_df.plot.scatter(x='sepal length (cm)', \n",
    "                     y='sepal width (cm)', \n",
    "                     title='Iris Dataset', \n",
    "                     c='target',\n",
    "                     colormap='viridis')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Seaborn\n",
    "Seaborn has a **.scatterplot** method to create a scatterplot similar to Pandas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create a seaborn scatter plot\n",
    "\n",
    "plt.title('Iris Dataset')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# add style to scatterplot by coloring by class\n",
    "sns.scatterplot(x='sepal length (cm)', \n",
    "                y='sepal width (cm)',\n",
    "                data=iris_df,\n",
    "                hue = 'class',\n",
    "                size='petal length (cm)')\n",
    "plt.title('Iris Dataset')\n",
    "#plt.legend(loc='upper center', bbox_to_anchor=(1.3, 1.0),\n",
    "#          fancybox=True, shadow=True, ncol=1)\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Line Chart\n",
    "One of the most fundamental plots - a line chart to display a series of data points. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matplotlib\n",
    "Call line-chart with the method **plot**.  Matplotlib will require a loop to plot multiple columns in one graph."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get columns to plot\n",
    "columns = iris_df.columns.drop(['target', 'class'])\n",
    "# create x data\n",
    "\n",
    "# create figure and axis\n",
    "fig, ax = plt.subplots()\n",
    "# plot each column\n",
    "\n",
    "# set title and legend\n",
    "ax.set_title('Iris Dataset')\n",
    "ax.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pandas \n",
    "Create line-chart with **.plot.line()** without any loops :) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# pandas line chart\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Seaborn\n",
    "Line-chart with seaborn calls method sns.lineplot "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# seaborn line chart \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Histograms\n",
    "Histograms are useful for a large number of unique values in a dataset.  The values are sorted into intervals, called bins.  From histograms we can understand the distribution (aka frequency) of the data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matplotlib\n",
    "Use method **hist**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create figure and axis\n",
    "fig, ax = plt.subplots()\n",
    "# plot histogram\n",
    "\n",
    "# set title and labels\n",
    "ax.set_title('Wine Alcohol')\n",
    "ax.set_xlabel('Alcohol')\n",
    "ax.set_ylabel('Frequency')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pandas\n",
    "Create Pandas hist with **plot.hist** - no parameters required."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# histogram using Pandas\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Also easily create mulitple plots \n",
    "iris_df.drop(['target', 'class'], axis=1).plot.hist(subplots=True, layout=(2,2), figsize=(10, 10), bins=20)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Seaborn \n",
    "Seaborn uses method **sns.distplot** with many additional parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# sns histogram\n",
    "\n",
    "plt.ylabel('Frequency')\n",
    "plt.title('Wine Alcohol')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# sns histogram with kernel density estimate\n",
    "\n",
    "plt.ylabel('Distribution')\n",
    "plt.title('Wine Alcohol')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Bar Charts\n",
    "Bar charts illustrate data corresponding to given labels or discrete numeric values (like pies charts).  These charts are good when there is low cardinality (not a lot of categories)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matplotlib\n",
    "Use the **bar** method, with the caveat that you need to manually calculate the frequencies of the categories you are interested in which can be done using **value_counts**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create a figure and axis \n",
    "fig, ax = plt.subplots() \n",
    "# count the occurrence of each class \n",
    "data = wine_df['class'].value_counts() \n",
    "# get x and y data \n",
    "alcohol = data.index \n",
    "frequency = data.values \n",
    "# create bar chart \n",
    "\n",
    "# set title and labels \n",
    "ax.set_title('Wine Classes') \n",
    "ax.set_xlabel('Class') \n",
    "ax.set_ylabel('Count')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pandas\n",
    "Use **plot.bar()** method, but like with matplotlib this method requires that we need to count the occurrences using **value_counts** and sort using **sort_index**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "plt.title('Wine Classes')\n",
    "plt.xlabel('Class')\n",
    "plt.ylabel('Count')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "wine_df['class'].value_counts().sort_index().plot.barh(color=['red', 'blue', 'green'])\n",
    "plt.title('Wine Classes')\n",
    "plt.ylabel('Class')\n",
    "plt.xlabel('Count')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.title('Wine Classes with the Highest Alcohol (on Average)')\n",
    "plt.xlabel('Class')\n",
    "plt.ylabel('Average Alcohol')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Seaborn\n",
    "Use **.countplot** to create a bar-chart, no need to do any data manipulation :) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "plt.title('Wine Class')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Box Plots\n",
    "Box plots (and violin plots) are excellent for visualizing descriptive statistics of a dataset since they show the range, interquartile range, median, mode, outliers and all quartiles."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matplotlib \n",
    "Use the method **boxplot()**.  In order to display multiple columns in one figure we need to construct an array of data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get columns to plot\n",
    "columns = iris_df.columns.drop(['target', 'class'])\n",
    "data = []\n",
    "for column in columns:\n",
    "    data.append(iris_df[column])\n",
    "# create figure and axis\n",
    "fig, ax = plt.subplots()\n",
    "# plot each column\n",
    "\n",
    "\n",
    "# set title and legend\n",
    "ax.set_title('Iris Dataset')\n",
    "ax.set_xticklabels(columns, rotation=45)\n",
    "ax.set_xlabel('Feature')\n",
    "ax.set_ylabel('cm')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pandas\n",
    "Use **.boxplot()** to create boxplot from Pandas dataframe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "plt.title('Iris Dataset')\n",
    "plt.xlabel('Feature')\n",
    "plt.ylabel('cm')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Seaborn\n",
    "Just need **sns.boxplot()** method to create amazing boxplots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "plt.title('Iris Dataset')\n",
    "plt.xlabel('Feature')\n",
    "plt.ylabel('cm')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Boxplots are also useful for viewing the different statistics of a feature broken down by class\n",
    "\n",
    "plt.title('Iris Dataset')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Alternative to box plot is a violin plot showing \n",
    "# the kernel density estimation underlying the distribution\n",
    "sns.violinplot(x=\"class\", y=\"sepal length (cm)\", data=iris_df)\n",
    "plt.title('Iris Dataset')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pie Charts\n",
    "Represent data with a small number of labels and given relative frequencies.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matplotlib\n",
    "Use **plt.pie** method to create a pie chart."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#first create data arrays \n",
    "data = wine_df['class'].value_counts()\n",
    "labels = data.index.tolist()\n",
    "sizes = data.values\n",
    "colors = ['yellowgreen', 'lightcoral', 'lightskyblue']\n",
    "explode = (0.1, 0, 0)  # explode 1st slice\n",
    "\n",
    "\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.axis('equal')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pandas\n",
    "Use the method **.plot.pie** on a dataframe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Seaborn \n",
    "Sorry but seaborn does not have a piechart method :( "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Heatmaps\n",
    "Heatmaps can visually represent a matrix.  The colors represent the numbers or elements of the matrix.  They are used for showing covariance and correlation matrices. Pandas **.corr()** allows you to easily create a correlation matrix or you can use numpy **np.corrcoef** method."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matplotlib\n",
    "Use Pandas correlation **.corr()** to easily get the correlation of features inside a dataframe and results in a correlation matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get correlation matrix\n",
    "corr = iris_df.corr(numeric_only=True)\n",
    "fig, ax = plt.subplots()\n",
    "# create heatmap\n",
    "\n",
    "# set labels\n",
    "ax.set_xticks(np.arange(len(corr.columns)))\n",
    "ax.set_yticks(np.arange(len(corr.columns)))\n",
    "ax.set_xticklabels(corr.columns)\n",
    "ax.set_yticklabels(corr.columns)\n",
    "\n",
    "# Rotate the tick labels and set their alignment.\n",
    "plt.setp(ax.get_xticklabels(), rotation=45, ha=\"right\",\n",
    "         rotation_mode=\"anchor\")\n",
    "\n",
    "# Loop over data dimensions and create text annotations.\n",
    "for i in range(len(corr.columns)):\n",
    "    for j in range(len(corr.columns)):\n",
    "        text = ax.text(j, i, np.around(corr.iloc[i, j], decimals=2),\n",
    "                       ha=\"center\", va=\"center\", color=\"black\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pandas \n",
    "Although Pandas lets you quickly calculate the correlation matrix, you will need Matplotlib or Seaborn to plot the heatmap."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Seaborn\n",
    "The best and easiest way to create a heatmap!! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add a mask so you don't show redundant information\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Faceting \n",
    "Faceting allows you to break the data variables up across multiple subplots and\n",
    "combine into a single feature.  This will allow you to quickly explore and\n",
    "visualize your datasets. Faceting is most easily accomplished in Seaborn."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Seaborn\n",
    "Faceting in Seaborn uses a FacetGrid,  You first define the **FacetGrid** and pass the data and column which you want to use to split your data.   Then use the **map** function on the FacetGrid object to make the multiple subplots with the different slices of data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create FacetGrid\n",
    "\n",
    "# use map function with a histogram"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pairwise Data Compairson\n",
    "Pandas and Seaborn both have methods to plot pairwise relationships in your dataset - which can be extremely useful - just be careful for large datasets. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pandas \n",
    "Pandas has a **scatter_matrix** which makes it easy to "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(figsize=(12,12))\n",
    "# img = pd.plotting.scatter_matrix()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Seaborn \n",
    "Seaborn also has a very useful **pairplot** method that automatically plots a grid of pairwise relationships in the dataset.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "bert",
   "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.12.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}