human_based_scenario/interpolation_based_scenario.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ead2cc25",
   "metadata": {},
   "source": [
    "# Human-based (interpretation) modeling\n",
    "this notebook is a use case application to model a simplifed geological configuration using a human based interpretation (interpolation-based appraoch)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca21a774",
   "metadata": {},
   "source": [
    "## Methods\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2922e920-a4a8-4bd5-b8a3-5f0481cdf177",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import os\n",
    "import pandas as pd\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "from scipy.interpolate import Rbf\n",
    "import matplotlib.pyplot as plt\n",
    "import pykrige.kriging_tools as kt\n",
    "from pykrige.ok import OrdinaryKriging\n",
    "\n",
    "\n",
    "\n",
    "def read_csv_and_extract_arrays(csv_file_path, column_names, encoding = 'utf-8' , sep = ';'):\n",
    "    \"\"\"\n",
    "    Read a CSV file into a DataFrame and extract specified columns as NumPy arrays.\n",
    "\n",
    "    Parameters:\n",
    "    - csv_file_path (str): Path to the CSV file.\n",
    "    - column_names (list): List of column names to extract.\n",
    "\n",
    "    Returns:\n",
    "    - tuple of NumPy arrays: Tuple containing NumPy arrays for each specified column.\n",
    "\n",
    "    Raises:\n",
    "    - ValueError: If a specified column is missing or has an incorrect length.\n",
    "    \"\"\"\n",
    "\n",
    "    # Read CSV file into a DataFrame\n",
    "    df = pd.read_csv(csv_file_path, encoding= encoding, sep = sep)\n",
    "\n",
    "    # Extract columns as NumPy arrays\n",
    "    arrays = tuple(df[column_name].values for column_name in column_names)\n",
    "\n",
    "    return arrays\n",
    "def render_points(x, y, z, show_legend=False, save_path = None, **kwargs):\n",
    "    # Plotting\n",
    "    fig = plt.figure()\n",
    "    ax = fig.add_subplot(111, projection='3d')\n",
    "\n",
    "    # Plot original data points\n",
    "    ax.scatter(x, y, z, color='black', label='Original Data')\n",
    "\n",
    "    ax.set_xlabel('X-axis')\n",
    "    ax.set_ylabel('Y-axis')\n",
    "    ax.set_zlabel('Z-axis')\n",
    "    \n",
    "    # Set view angles\n",
    "    ax.view_init(elev=kwargs.get('elev', 0), azim=kwargs.get('azim', -90))\n",
    "\n",
    "    ax.xaxis.pane.fill = False\n",
    "    ax.yaxis.pane.fill = False\n",
    "    ax.zaxis.pane.fill = False\n",
    "\n",
    "    ax.set_xticks(np.arange(kwargs.get('x_t_min', 0), kwargs.get('x_t_max', 220), kwargs.get('x_ar_lag', 100)))\n",
    "    ax.set_yticks(np.arange(kwargs.get('y_t_min', 0), kwargs.get('y_t_max', 60), kwargs.get('y_ar_lag', 50)))\n",
    "    ax.set_zticks(np.arange(kwargs.get('z_t_min', -60), kwargs.get('z_t_max', -20), kwargs.get('z_ar_lag', 20)))\n",
    "\n",
    "    if show_legend:\n",
    "        ax.legend()\n",
    "\n",
    "   \n",
    "    if save_path is not None:\n",
    "        plt.savefig(os.path.join(save_path, '{}.png'.format(kwargs.get('name_of_fig', 'figure'))), dpi=kwargs.get('dpi', 300), transparent=kwargs.get('transparent', True))\n",
    "   \n",
    "    plt.show()\n",
    "\n",
    "def calculate_rbf(x, y, z, dip, dip_dir, function='linear', smooth=0):\n",
    "    \"\"\"\n",
    "    Calculate interpolation using radial basis functions (RBF) \n",
    "    Parameters:\n",
    "    - x, y, z (arrays): Coordinates of the original 3D point data.\n",
    "    - dip, dip_dir (arrays): Dip and dip direction values.\n",
    "    - function (str): Type of RBF function to use for interpolation (default is 'linear').\n",
    "    - smooth (float): Smoothing parameter for RBF interpolation (default is 0).\n",
    "\n",
    "    Returns:\n",
    "    - rbf: Rbf object for interpolation.\n",
    "    \"\"\"\n",
    "    dz_dip = np.sin(dip)\n",
    "    dz_dip_dir = np.cos(dip) * np.sin(dip_dir)\n",
    "    dz_dip_dir /= np.cos(dip)  # Normalize by cosine of dip to avoid vertical exaggeration\n",
    "\n",
    "    # Interpolate using Rbf with dip and dip direction as gradients\n",
    "    rbf = Rbf(x, y, z + dz_dip + dz_dip_dir, function=function, smooth=smooth)\n",
    "    return rbf\n",
    "\n",
    "\n",
    "def render_3d_plot_rbf(x, y, z, rbf, grid_size=500,  \n",
    "                       cmap='viridis', c='green', alpha=1, points_color = 'black',\n",
    "                       points_size = 5,\n",
    "                       set_box_size = True,\n",
    "                           show_axis = False,\n",
    "                           show_grid = False, \n",
    "                           hide_ticks = True,\n",
    "                       show_legend=False, label='Interpolated Surface',\n",
    "                       save_path = None, **kwargs):\n",
    "    \"\"\"\n",
    "    Render a 3D plot with original data points and the interpolated surface.\n",
    "\n",
    "    Parameters:\n",
    "    - x, y, z (arrays): Coordinates of the original 3D point data.\n",
    "    - rbf: Rbf object for interpolation.\n",
    "    - grid_size (int): Number of points in the grid for visualization (default is 100).\n",
    "    - cmap (str): Colormap for the interpolated surface (default is 'viridis').\n",
    "    - alpha (float): Transparency of the interpolated surface (default is 0.5).\n",
    "    - **kwargs: Additional keyword arguments for customization.\n",
    "    \"\"\"\n",
    "    # Create a meshgrid for visualization\n",
    "    x_grid, y_grid = np.meshgrid(np.linspace(x.min(), x.max(), grid_size), np.linspace(y.min(), y.max(), grid_size))\n",
    "    z_grid = rbf(x_grid.flatten(), y_grid.flatten())\n",
    "\n",
    "    # Reshape z_grid to match the shape of x_grid and y_grid\n",
    "    z_grid = z_grid.reshape(x_grid.shape)\n",
    "\n",
    "    # Plotting\n",
    "    fig = plt.figure(figsize=(8, 8))\n",
    "    ax = fig.add_subplot(111, projection='3d')\n",
    "\n",
    "    # Plot original data points\n",
    "    ax.scatter(x, y, z, s= points_size,  color=points_color, label='Original Data', alpha= 1)\n",
    "\n",
    "    # Plot interpolated surface\n",
    "    if cmap is not None:\n",
    "        # Plot the surface\n",
    "        ax.plot_surface(x_grid, y_grid, z_grid, cmap=cmap, alpha=alpha, label=label)\n",
    "    else:\n",
    "        ax.plot_surface(x_grid, y_grid, z_grid, color=c, alpha=alpha, label=label)\n",
    "\n",
    "    \n",
    "    \n",
    "    # Set view angles\n",
    "    ax.view_init(elev=kwargs.get('elev', 0), azim=kwargs.get('azim', -90))\n",
    "\n",
    "    if show_axis == False: \n",
    "        ax.set_axis_off()\n",
    "    if show_grid == False: \n",
    "        ax.grid(False)\n",
    "\n",
    "    # Set labels for axes\n",
    "    if 'set_axis_labels' in kwargs:\n",
    "        ax.set_xlabel('X-axis')\n",
    "        ax.set_ylabel('Y-axis')\n",
    "\n",
    "    ax.xaxis.pane.fill = False\n",
    "    ax.yaxis.pane.fill = False\n",
    "    ax.zaxis.pane.fill = False\n",
    "    \n",
    "    if set_box_size == True:\n",
    "           ax.set_xlim([kwargs.get('x_t_min', 0), kwargs.get('x_t_max', 230)])\n",
    "           ax.set_ylim([kwargs.get('y_t_min', 0), kwargs.get('y_t_max', 60)])\n",
    "           ax.set_zlim([kwargs.get('z_t_min', -60), kwargs.get('z_t_max', -20)])\n",
    "\n",
    "    # Hide the ticks on the axis\n",
    "    if hide_ticks == True:\n",
    "        ax.set_xticks([])\n",
    "        ax.set_yticks([])\n",
    "        ax.set_zticks([])\n",
    "\n",
    "        # Hide the tick labels\n",
    "        ax.set_xticklabels([])\n",
    "        ax.set_yticklabels([])\n",
    "        ax.set_zticklabels([])\n",
    "    \n",
    "    elif 'set_ticks' in kwargs : \n",
    "        ax.set_xticks(np.arange(kwargs.get('x_t_min', 0), kwargs.get('x_t_max', 220), kwargs.get('x_ar_lag', 100)))\n",
    "        ax.set_yticks(np.arange(kwargs.get('y_t_min', 0), kwargs.get('y_t_max', 60), kwargs.get('y_ar_lag', 50)))\n",
    "        ax.set_zticks(np.arange(kwargs.get('z_t_min', -60), kwargs.get('z_t_max', -20), kwargs.get('z_ar_lag', 20)))\n",
    "    \n",
    "    if show_legend:\n",
    "        ax.legend()\n",
    "    if save_path is not None:\n",
    "        plt.savefig(os.path.join(save_path, '{}.png'.format(kwargs.get('name_of_fig', 'figure'))), dpi=kwargs.get('dpi', 300), transparent=kwargs.get('transparent', True))\n",
    "   \n",
    "    plt.show()\n",
    "\n",
    "\n",
    "def perform_kriging(x, y, z, variogram_model='gaussian', nlags=10, verbose = True\n",
    "                   , min_gridx = -10, max_gridx = 220,\n",
    "                   min_gridy = -10, max_gridy = 60, arr_fact = 3):\n",
    "    \"\"\"\n",
    "    Perform Ordinary Kriging on 3D point data.\n",
    "\n",
    "    Parameters:\n",
    "    - x, y, z (arrays): Coordinates of the 3D point data.\n",
    "    - variogram_model (str): Type of variogram model to use (default is 'gaussian').\n",
    "    - nlags (int): Number of lags to consider for the variogram model (default is 10).\n",
    "\n",
    "    Returns:\n",
    "    - OK: OrdinaryKriging object.\n",
    "    - gridx, gridy (arrays): Coordinates of the grid for interpolation.\n",
    "    - zstar, ss: Kriging results and variance.\n",
    "    \"\"\"\n",
    "    OK = OrdinaryKriging(x, y, z, variogram_model=variogram_model, nlags=nlags, verbose = verbose)\n",
    "    \n",
    "    gridx = np.arange(min_gridx, max_gridx, arr_fact, dtype='float64')\n",
    "    gridy = np.arange(min_gridy, max_gridy, arr_fact, dtype='float64')\n",
    "    \n",
    "    zstar, ss = OK.execute(\"grid\", gridx, gridy)\n",
    "\n",
    "    return OK, gridx, gridy, zstar, ss\n",
    "\n",
    "def render_kriging_3d_plot(x, y, z, OK, gridx, gridy, \n",
    "                           zstar, cmap='viridis', c='blue', \n",
    "                           points_color = 'black',\n",
    "                           show_axis = False,\n",
    "                           show_grid = False, \n",
    "                           show_legend=False, save_path = None, **kwargs):\n",
    "    \"\"\"\n",
    "    Render a 3D plot of kriging results.\n",
    "\n",
    "    Parameters:\n",
    "    - OK: OrdinaryKriging object.\n",
    "    - gridx, gridy (arrays): Coordinates of the grid for interpolation.\n",
    "    - zstar: Kriging results.\n",
    "    - cmap (str): Colormap for the surface plot (default is 'viridis').\n",
    "    - **kwargs: Additional keyword arguments for customization.\n",
    "    \"\"\"\n",
    "    # Create a 3D plot\n",
    "    fig = plt.figure()\n",
    "    ax = fig.add_subplot(111, projection='3d')\n",
    "\n",
    "    # Create meshgrid for 3D plot\n",
    "    X, Y = np.meshgrid(gridx, gridy)\n",
    "\n",
    "    if cmap is not None:\n",
    "        # Plot the surface\n",
    "        surf = ax.plot_surface(X, Y, zstar, cmap=cmap)\n",
    "    else:\n",
    "        surf = ax.plot_surface(X, Y, zstar, color=c)\n",
    "\n",
    "    ax.scatter(x, y, z, color=points_color, label='Original Data', alpha= 1)\n",
    "    if show_axis == False: \n",
    "        ax.set_axis_off()\n",
    "    if show_grid == False: \n",
    "        ax.grid(False)\n",
    "\n",
    "    # Set labels for axes\n",
    "    if 'set_axis_labels' in kwargs:\n",
    "        ax.set_xlabel('X-axis')\n",
    "        ax.set_ylabel('Y-axis')\n",
    "\n",
    "    ax.xaxis.pane.fill = False\n",
    "    ax.yaxis.pane.fill = False\n",
    "    ax.zaxis.pane.fill = False\n",
    "    \n",
    "    if 'set_ticks' in kwargs : \n",
    "        ax.set_xticks(np.arange(kwargs.get('x_t_min', 0), kwargs.get('x_t_max', 220), kwargs.get('x_ar_lag', 100)))\n",
    "        ax.set_yticks(np.arange(kwargs.get('y_t_min', 0), kwargs.get('y_t_max', 60), kwargs.get('y_ar_lag', 50)))\n",
    "        ax.set_zticks(np.arange(kwargs.get('z_t_min', -60), kwargs.get('z_t_max', -20), kwargs.get('z_ar_lag', 20)))\n",
    "\n",
    "    # Set viewing angles\n",
    "    ax.view_init(elev=kwargs.get('elev', 0), azim=kwargs.get('azim', -90))\n",
    "\n",
    "    if show_legend:\n",
    "        ax.legend()\n",
    "        plt.title('3D Kriging Plot')\n",
    "\n",
    "\n",
    "    if save_path is not None:\n",
    "        plt.savefig(os.path.join(save_path, '{}.png'.format(kwargs.get('name_of_fig', 'figure'))), dpi=kwargs.get('dpi', 300), transparent=kwargs.get('transparent', True))\n",
    "   \n",
    "    # Show the plot\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "\n",
    "def render_kriging_map(OK, gridx, gridy, zstar, x, y, cmap='viridis'\n",
    "                       , show_legend = False, name_of_fig = 'figure', save = False,dpi = 300, transparent = True ):\n",
    "    \"\"\"\n",
    "    Render a kriging map with scatter plot of input data.\n",
    "\n",
    "    Parameters:\n",
    "    - OK: OrdinaryKriging object.\n",
    "    - gridx, gridy (arrays): Coordinates of the grid for interpolation.\n",
    "    - zstar, ss: Kriging results and variance.\n",
    "    - x, y (arrays): Coordinates of the input data.\n",
    "    - cmap (str): Colormap for the interpolation map (default is 'viridis').\n",
    "    \"\"\"\n",
    "    # Plot interpolation map\n",
    "    cax = plt.imshow(zstar, extent=(gridx.min(), gridx.max(), gridy.min(), gridy.max()), origin='lower', cmap=cmap)\n",
    "\n",
    "    # Scatter plot of input data\n",
    "    plt.scatter(x, y, c='k', marker='.')\n",
    "\n",
    "    # Add colorbar\n",
    "    cbar = plt.colorbar(cax)\n",
    "    cbar.set_label('Kriging Value')\n",
    "\n",
    "    # Set title\n",
    "    if show_legend :\n",
    "        ax.legend()\n",
    "        plt.title('Interpolation Map')\n",
    "    if save == True : plt.savefig('{}.png'.format(name_of_fig), dpi=dpi, transparent=transparent)\n",
    "    # Show the plot\n",
    "    plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa306bf9",
   "metadata": {},
   "source": [
    "## Tests"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "395c2a3c",
   "metadata": {},
   "source": [
    "### Inputs querrying"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "55d92117",
   "metadata": {},
   "outputs": [],
   "source": [
    "path = 'D:\\ownCloud\\GeologicalInterpretor_Proof\\inputs\\sparse_data.csv'\n",
    "path1 = 'D:\\ownCloud\\GeologicalInterpretor_Proof\\inputs\\sparse_data1.csv'\n",
    "path2 = 'D:\\ownCloud\\GeologicalInterpretor_Proof\\inputs\\sparse_data2.csv'\n",
    "\n",
    "# Example usage:\n",
    "try:\n",
    "    x, y, z, dip, dip_dir = read_csv_and_extract_arrays(path, ['x', 'y', 'z', 'dip', 'dip_dir'])\n",
    "except ValueError as e:\n",
    "    print(f\"Error: {e}\")\n",
    "df = pd.DataFrame({\n",
    "    'x': x,\n",
    "    'y': y,\n",
    "    'z': z,\n",
    "    'dip': dip,\n",
    "    'dip_dir': dip_dir,\n",
    "})\n",
    "\n",
    "\n",
    "# Example usage:\n",
    "try:\n",
    "    x1, y1, z1, dip1, dip_dir1 = read_csv_and_extract_arrays(path1, ['x', 'y', 'z', 'dip', 'dip_dir'])\n",
    "except ValueError as e:\n",
    "    print(f\"Error: {e}\")\n",
    "df1 = pd.DataFrame({\n",
    "    'x1': x1,\n",
    "    'y1': y1,\n",
    "    'z1': z1,\n",
    "    'dip1': dip1,\n",
    "    'dip_dir1': dip_dir1,\n",
    "})\n",
    "\n",
    "\n",
    "\n",
    "# Example usage:\n",
    "\n",
    "try:\n",
    "    x2, y2, z2, dip2, dip_dir2 = read_csv_and_extract_arrays(path2, ['x', 'y', 'z', 'dip', 'dip_dir'])\n",
    "except ValueError as e:\n",
    "    print(f\"Error: {e}\")\n",
    "df2 = pd.DataFrame({\n",
    "    'x2': x2,\n",
    "    'y2': y2,\n",
    "    'z2': z2,\n",
    "    'dip2': dip2,\n",
    "    'dip_dir2': dip_dir2,\n",
    "})\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a2d52b0",
   "metadata": {},
   "source": [
    "### kriging-based"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "80a75004-c9c0-4461-827d-77ea1447e614",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "OK_example, gridx_example, gridy_example, zstar_example, ss_example = perform_kriging(x, y, z, \n",
    "                                                min_gridx = -10, max_gridx = 220,\n",
    "                                                       min_gridy = 0, max_gridy = 40, arr_fact = 3 )\n",
    "render_kriging_3d_plot(x, y, z,OK_example, gridx_example, gridy_example, zstar_example, cmap = None, \n",
    "                       save_path = saving_path, name_of_fig = 'OK_example', **yy_view)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1faeb146-1355-4a2f-be93-d7c48f12dec5",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "OK_example1, gridx_example1, gridy_example1, zstar_example1, ss_example1 = perform_kriging(x1, y1, z1)\n",
    "render_kriging_3d_plot( x1, y1, z1,OK_example1, gridx_example1, gridy_example1, zstar_example1, cmap = None, \n",
    "                       save_path = saving_path, name_of_fig = 'OK_example1', **top_view)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e9b5b2b0",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "OK_example2, gridx_example2, gridy_example2, zstar_example2, ss_example2 = perform_kriging(x2, y2, z2)\n",
    "render_kriging_3d_plot(x2, y2, z2,OK_example2, gridx_example2, gridy_example2, zstar_example2, cmap = None, \n",
    "                       save_path = saving_path, name_of_fig = 'OK_example2',**inclinde_view)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c62509e0",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "9cceed93",
   "metadata": {},
   "source": [
    "### views\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fbee204f",
   "metadata": {},
   "outputs": [],
   "source": [
    "  \n",
    "inclinde_view = {'elev': 45, 'azim':-75}\n",
    "yy_view = {'elev': 0, 'azim':-90}\n",
    "top_view = {'elev': 90, 'azim':0}\n",
    "\n",
    "saving_path = 'D:\\ownCloud\\GeologicalInterpretor_Proof\\human_based_scenario\\outputs'\n",
    "#saving_path = None\n",
    "\n",
    "view = yy_view\n",
    "suffix = 'yy_view'\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8dadcd39",
   "metadata": {},
   "source": [
    "### RBF-based\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "168081f5",
   "metadata": {},
   "source": [
    "render_points(x, y,z, save_path = saving_path, x_ar_lag =25, z_ar_lag = 5,  **view)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3b8fbee9",
   "metadata": {},
   "outputs": [],
   "source": [
    "rbf_example = calculate_rbf(x, y, z, dip, dip_dir)\n",
    "render_3d_plot_rbf(x, y, z, rbf_example, cmap = None, set_box_size = True,\n",
    "                   points_size= 20, show_axis= True, set_ticks = True, hide_ticks= False, show_grid = True,\n",
    "                       save_path = saving_path, \n",
    "                       name_of_fig = 'rbf_example{}'.format(suffix), \n",
    "                       **view)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4ce374e9",
   "metadata": {},
   "outputs": [],
   "source": [
    "rbf_example1 = calculate_rbf(x1, y1, z1, dip1, dip_dir1)\n",
    "render_3d_plot_rbf(x1, y1, z1, rbf_example1 ,  cmap = None, points_size= 20, show_axis= True, \n",
    "                    points_color = 'cyan', set_ticks = True, hide_ticks= False, show_grid = True,\n",
    "                       save_path = saving_path, name_of_fig = 'rbf_example1{}'.format(suffix), **view)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6f853593-d000-4315-a719-b283112922f7",
   "metadata": {},
   "outputs": [],
   "source": [
    "rbf_example2 = calculate_rbf(x2, y2, z2, dip2, dip_dir2)\n",
    "render_3d_plot_rbf(x2, y2, z2, rbf_example2,  cmap = None,  points_size= 20, show_axis= True, \n",
    "                    points_color = 'red', set_ticks = True, hide_ticks= False, show_grid = True,\n",
    "                       save_path = saving_path, name_of_fig = 'rbf_example2{}'.format(suffix), **view)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d93df186-412a-45c9-9718-96ba15e6b6e7",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "\n",
    "# Create a sample 3D plot\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(111, projection='3d')\n",
    "ax.plot([1, 2, 3], [4, 5, 6], [7, 8, 9])\n",
    "\n",
    "plt.show()\n"
   ]
  }
 ],
 "metadata": {
  "language_info": {
   "name": "python",
   "pygments_lexer": "ipython3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}