Forecasting_ChicagoBus/Snowpark_Forecasting_Bus_FeatureStore.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "5f02f3fc",
   "metadata": {},
   "source": [
    "# Snowflake ML Intro Notebook - ML Forecasting\n",
    "This notebook introduces several key features of Snowflake ML in the process of training a machine learning model for forecasting Chicago bus ridership.\n",
    "\n",
    "\n",
    "* Establish secure connection to Snowflake\n",
    "* Load features and target from Snowflake table into Snowpark DataFrame\n",
    "* Add features into a feature store\n",
    "* Prepare features for model training\n",
    "* Train ML model using Snowpark ML distributed processing\n",
    "* Save the model to the Snowflake Model Registry\n",
    "* Run model predictions inside Snowflake\n",
    "* Deploy model to Snowflake Container Services\n",
    "\n",
    "This notebook is intended to highlight Snowflake functionality and should not be taken as a best practice for time series forecasting. \n",
    "\n",
    "[Get Notebook](https://github.com/rajshah4/snowflake-notebooks/blob/main/Forecasting_ChicagoBus/Snowpark_Forecasting_Bus_FeatureStore.ipynb)  \n",
    "\n",
    "[Go to folder with dataset](https://github.com/rajshah4/snowflake-notebooks/blob/main/Forecasting_ChicagoBus/)  \n",
    "\n",
    "[See more snowflake notebooks from raj](https://github.com/rajshah4/snowflake-notebooks/)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "6e2e1c4a",
   "metadata": {},
   "source": [
    "## 1. Setup Environment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "persistent-reasoning",
   "metadata": {
    "papermill": {
     "duration": 0.872363,
     "end_time": "2021-05-15T09:33:41.413139",
     "exception": false,
     "start_time": "2021-05-15T09:33:40.540776",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.11.7 (main, Dec 15 2023, 12:09:56) [Clang 14.0.6 ]\n"
     ]
    }
   ],
   "source": [
    "# Snowflake connector\n",
    "from snowflake import connector\n",
    "#from snowflake.ml.utils import connection_params\n",
    "\n",
    "# Snowpark for Python\n",
    "from snowflake.snowpark.session import Session\n",
    "from snowflake.snowpark.types import Variant\n",
    "from snowflake.snowpark.version import VERSION\n",
    "from snowflake.snowpark import functions as F\n",
    "from snowflake.snowpark.types import *\n",
    "\n",
    "# Snowpark ML\n",
    "from snowflake.ml.modeling.compose import ColumnTransformer\n",
    "from snowflake.ml.modeling.pipeline import Pipeline\n",
    "from snowflake.ml.modeling.preprocessing import StandardScaler, OrdinalEncoder\n",
    "from snowflake.ml.modeling.impute import SimpleImputer\n",
    "from snowflake.ml.modeling.model_selection import GridSearchCV\n",
    "from snowflake.ml.modeling.xgboost import XGBRegressor\n",
    "from snowflake.ml import version\n",
    "mlversion = version.VERSION\n",
    "\n",
    "#Feature Store\n",
    "from snowflake.ml.feature_store import FeatureStore, CreationMode, Entity, FeatureView\n",
    "\n",
    "# Misc\n",
    "import pandas as pd\n",
    "import json\n",
    "import logging \n",
    "logger = logging.getLogger(\"snowflake.snowpark.session\")\n",
    "logger.setLevel(logging.ERROR)\n",
    "\n",
    "import sys\n",
    "print(sys.version) ##Last run used Python 3.11\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "b855e80e",
   "metadata": {},
   "source": [
    "## Establish Secure Connection to Snowflake\n",
    "\n",
    "Using the Snowpark Python API, it’s quick and easy to establish a secure connection between Snowflake and Notebook. I prefer using a `toml` configuration file [as documented here](https://docs.snowflake.com/en/developer-guide/snowflake-python-api/snowflake-python-connecting-snowflake).\n",
    " *Note: Other connection options include Username/Password, MFA, OAuth, Okta, SSO*\n",
    "\n",
    "I recently moved to using [private / public key pair](https://docs.snowflake.com/en/user-guide/key-pair-auth) for authentication. This is more secure than using a password. I also don't have to log into MFA everytime I run the notebook.\n",
    "\n",
    "The creds.json should look like this:\n",
    "```\n",
    "{\n",
    "    \"account\": \"awb99999\",\n",
    "    \"user\": \"your_user_name\",\n",
    "    \"password\": \"your_password\",\n",
    "    \"warehouse\": \"your_warehouse\"\n",
    "  }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "953f6906",
   "metadata": {},
   "outputs": [],
   "source": [
    "from snowflake.snowpark import Session\n",
    "from cryptography.hazmat.primitives import serialization\n",
    "from cryptography.hazmat.backends import default_backend\n",
    "\n",
    "with open('../../creds.json') as f:\n",
    "    data = json.load(f)\n",
    "    USERNAME = data['user']\n",
    "    SF_ACCOUNT = data['account']\n",
    "    SF_WH = data['warehouse']\n",
    "    passphrase = data['passphrase']\n",
    "\n",
    "# Read the private key from the .p8 file\n",
    "with open('../../rsa_key.p8', 'rb') as key_file:\n",
    "    private_key = key_file.read()\n",
    "\n",
    "# If the private key is encrypted, load it with a passphrase\n",
    "# Replace 'your_key_passphrase' with your actual passphrase if needed\n",
    "private_key_obj = serialization.load_pem_private_key(\n",
    "    private_key,\n",
    "    password=passphrase.encode() if passphrase else None,\n",
    "    backend=default_backend()\n",
    ")\n",
    "\n",
    "# Define connection parameters including the private key\n",
    "CONNECTION_PARAMETERS = {\n",
    "    'user': USERNAME,\n",
    "    'account': SF_ACCOUNT,\n",
    "    'private_key': private_key_obj,\n",
    "    'warehouse': SF_WH,\n",
    "}\n",
    "\n",
    "# Create a session with the specified connection parameters\n",
    "session = Session.builder.configs(CONNECTION_PARAMETERS).create()\n",
    "\n",
    "from snowflake.core.warehouse import Warehouse\n",
    "from snowflake.core import Root\n",
    "root = Root(session)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c333eb49",
   "metadata": {},
   "source": [
    "Verify everything is connected. I like to do this to remind people to make sure they are using the latest versions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "4fb1f7af",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "User                        : RSHAH\n",
      "Role                        : \"RAJIV\"\n",
      "Database                    : \"RAJIV\"\n",
      "Schema                      : \"PUBLIC\"\n",
      "Warehouse                   : \"RAJIV\"\n",
      "Snowflake version           : 8.39.2\n",
      "Snowpark for Python version : 1.20.0\n",
      "Snowflake ML version        : 1.6.3\n"
     ]
    }
   ],
   "source": [
    "snowflake_environment = session.sql('select current_user(), current_version()').collect()\n",
    "snowpark_version = VERSION\n",
    "\n",
    "# Current Environment Details\n",
    "print('User                        : {}'.format(snowflake_environment[0][0]))\n",
    "print('Role                        : {}'.format(session.get_current_role()))\n",
    "print('Database                    : {}'.format(session.get_current_database()))\n",
    "print('Schema                      : {}'.format(session.get_current_schema()))\n",
    "print('Warehouse                   : {}'.format(session.get_current_warehouse()))\n",
    "print('Snowflake version           : {}'.format(snowflake_environment[0][1]))\n",
    "print('Snowpark for Python version : {}.{}.{}'.format(snowpark_version[0],snowpark_version[1],snowpark_version[2]))\n",
    "print('Snowflake ML version        : {}.{}.{}'.format(mlversion[0],mlversion[2],mlversion[4]))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11c437e4",
   "metadata": {},
   "source": [
    "Throughout this notebook, I will change warehouse sizes. For this notebook warehouse size really doesn't matter much, but I want people to understand how easily and quickly you can change the warehouse size. This is one of my favorite features of Snowflake, just how its always ready for me."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "e11789e5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Row(status='Statement executed successfully.')]"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "session.sql(\"CREATE OR REPLACE SCHEMA ML_DEMO\").collect()\n",
    "session.sql(\"USE SCHEMA ML_DEMO\").collect()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "997a5f96",
   "metadata": {},
   "source": [
    "Create a feature store"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "8105f33c",
   "metadata": {},
   "outputs": [],
   "source": [
    "fs = FeatureStore(\n",
    "    session=session,\n",
    "    database=\"RAJIV\",\n",
    "    name=\"FEATURE_STORE_MLDEMO\",\n",
    "    default_warehouse=\"RAJIV\",\n",
    "    creation_mode=CreationMode.CREATE_IF_NOT_EXIST,\n",
    ")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "2817d70c",
   "metadata": {},
   "source": [
    "## 2. Load Data in Snowflake "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df957705",
   "metadata": {},
   "source": [
    "Let's get the data (900k rows) and also make the column names all upper cases. It's easier to work with columns names that aren't case sensitive."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "8dfb28da",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(893603, 4)\n",
      "ROUTE      object\n",
      "DATE       object\n",
      "DAYTYPE    object\n",
      "RIDES       int64\n",
      "dtype: object\n"
     ]
    },
    {
     "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>ROUTE</th>\n",
       "      <th>DATE</th>\n",
       "      <th>DAYTYPE</th>\n",
       "      <th>RIDES</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>3</td>\n",
       "      <td>01/01/2001</td>\n",
       "      <td>U</td>\n",
       "      <td>7354</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4</td>\n",
       "      <td>01/01/2001</td>\n",
       "      <td>U</td>\n",
       "      <td>9288</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>6</td>\n",
       "      <td>01/01/2001</td>\n",
       "      <td>U</td>\n",
       "      <td>6048</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>8</td>\n",
       "      <td>01/01/2001</td>\n",
       "      <td>U</td>\n",
       "      <td>6309</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>9</td>\n",
       "      <td>01/01/2001</td>\n",
       "      <td>U</td>\n",
       "      <td>11207</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  ROUTE        DATE DAYTYPE  RIDES\n",
       "0     3  01/01/2001       U   7354\n",
       "1     4  01/01/2001       U   9288\n",
       "2     6  01/01/2001       U   6048\n",
       "3     8  01/01/2001       U   6309\n",
       "4     9  01/01/2001       U  11207"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_clean = pd.read_csv('CTA_Daily_Totals_by_Route.csv')\n",
    "df_clean.columns = df_clean.columns.str.upper()\n",
    "print (df_clean.shape)\n",
    "print (df_clean.dtypes)\n",
    "df_clean.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3c72b14",
   "metadata": {},
   "source": [
    "Let's create a Snowpark dataframe and split the data for test/train. This operation is done inside Snowflake and not in your local environment. We will also save this as a table so we don't ever have to manually upload this dataset again.\n",
    "\n",
    "PRO TIP -- Snowpark will inherit the schema of a pandas dataframe into Snowflake. Either change your schema before importing or after it has landed in snowflake. People that put models into production are very careful about data types."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "77038199",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "StructType([StructField('ROUTE', StringType(16777216), nullable=True), StructField('DATE', StringType(16777216), nullable=True), StructField('DAYTYPE', StringType(16777216), nullable=True), StructField('RIDES', LongType(), nullable=True)])\n"
     ]
    }
   ],
   "source": [
    "input_df = session.create_dataframe(df_clean)\n",
    "schema = input_df.schema\n",
    "print(schema)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "9a6209bd",
   "metadata": {},
   "outputs": [],
   "source": [
    "input_df.write.mode('overwrite').save_as_table('RAJIV.FEATURE_STORE_MLDEMO.CHICAGO_BUS_RIDES')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da3ac037",
   "metadata": {},
   "source": [
    "Let's read from the table, since that is generally what you will be doing in production. We have 893,000 rows of ridership data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "b2b86720",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "893603\n",
      "----------------------------------------------\n",
      "|\"ROUTE\"  |\"DATE\"      |\"DAYTYPE\"  |\"RIDES\"  |\n",
      "----------------------------------------------\n",
      "|3        |01/01/2001  |U          |7354     |\n",
      "|4        |01/01/2001  |U          |9288     |\n",
      "|6        |01/01/2001  |U          |6048     |\n",
      "|8        |01/01/2001  |U          |6309     |\n",
      "|9        |01/01/2001  |U          |11207    |\n",
      "|10       |01/01/2001  |U          |385      |\n",
      "|11       |01/01/2001  |U          |610      |\n",
      "|12       |01/01/2001  |U          |3678     |\n",
      "|18       |01/01/2001  |U          |375      |\n",
      "|20       |01/01/2001  |U          |7096     |\n",
      "----------------------------------------------\n",
      "\n"
     ]
    }
   ],
   "source": [
    "df = session.read.table('CHICAGO_BUS_RIDES')\n",
    "print (df.count())\n",
    "df.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2bf2a672",
   "metadata": {},
   "source": [
    "An entity is an abstraction over a set of primary keys used for looking up feature data. An Entity represents a real-world \"thing\" that has data associated with it. Below cell registers an entity called \"route\" in Feature Store."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "d93ed5e9",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/rajishah/anaconda3/envs/working311/lib/python3.11/site-packages/snowflake/ml/feature_store/feature_store.py:197: UserWarning: Entity ROUTE already exists. Skip registration.\n",
      "  return f(self, *args, **kargs)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-----------------------------------------------------------------------------------\n",
      "|\"NAME\"  |\"JOIN_KEYS\"  |\"DESC\"                                          |\"OWNER\"  |\n",
      "-----------------------------------------------------------------------------------\n",
      "|ROUTE   |[\"DATE\"]     |Starting and ending stations for the bike ride  |RAJIV    |\n",
      "-----------------------------------------------------------------------------------\n",
      "\n"
     ]
    }
   ],
   "source": [
    "entity = Entity(\n",
    "    name=\"route\",\n",
    "    join_keys=[\"DATE\"],\n",
    ")\n",
    "fs.register_entity(entity)\n",
    "\n",
    "#Show the entities\n",
    "fs.list_entities().show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4cdb214c",
   "metadata": {},
   "source": [
    "## 3. Distributed Feature Engineering\n",
    "\n",
    "Let's do some feature engineering and then move that logic to the feature store. The feature engineering includes: adding a day of the week and aggregation the data by day and then later joining in weather data.\n",
    "\n",
    "These operations are done inside the Snowpark warehouse which provides improved performance and scalability with distributed execution for these scikit-learn preprocessing functions. This dataset uses SMALL, but you can always move up to larger ones including Snowpark Optimized warehouses (16x memory per node than a standard warehouse), e.g., `session.sql(\"create or replace warehouse snowpark_opt_wh with warehouse_size = 'MEDIUM' warehouse_type = 'SNOWPARK-OPTIMIZED'\").collect()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "4d375636",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Row(status='Warehouse SNOWPARK_OPT_WH successfully created.')]"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "session.sql(\"create or replace warehouse snowpark_opt_wh with warehouse_size = 'MEDIUM' warehouse_type = 'SNOWPARK-OPTIMIZED'\").collect()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea566df4",
   "metadata": {},
   "source": [
    "Simple feature engineering"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "50e5d5e9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-----------------------------------------------------------------------\n",
      "|\"ROUTE\"  |\"DAYTYPE\"  |\"RIDES\"  |\"DATE\"               |\"DAY_OF_WEEK\"  |\n",
      "-----------------------------------------------------------------------\n",
      "|3        |U          |7354     |2001-01-01 00:00:00  |1              |\n",
      "|4        |U          |9288     |2001-01-01 00:00:00  |1              |\n",
      "|6        |U          |6048     |2001-01-01 00:00:00  |1              |\n",
      "|8        |U          |6309     |2001-01-01 00:00:00  |1              |\n",
      "|9        |U          |11207    |2001-01-01 00:00:00  |1              |\n",
      "|10       |U          |385      |2001-01-01 00:00:00  |1              |\n",
      "|11       |U          |610      |2001-01-01 00:00:00  |1              |\n",
      "|12       |U          |3678     |2001-01-01 00:00:00  |1              |\n",
      "|18       |U          |375      |2001-01-01 00:00:00  |1              |\n",
      "|20       |U          |7096     |2001-01-01 00:00:00  |1              |\n",
      "-----------------------------------------------------------------------\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from snowflake.snowpark.functions import col, to_timestamp, dayofweek, month,sum, listagg, lag\n",
    "from snowflake.snowpark import Window\n",
    "\n",
    "df = df.with_column('DATE', to_timestamp(col('DATE'), 'MM/DD/YYYY'))\n",
    "\n",
    "# Add a new column for the day of the week\n",
    "# The day of week is represented as an integer, with 0 = Sunday, 1 = Monday, ..., 6 = Saturday\n",
    "df = df.with_column('DAY_OF_WEEK', dayofweek(col('DATE')))\n",
    "\n",
    "df.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6f61feb",
   "metadata": {},
   "source": [
    "A bit more feature engineering, but again, this is very familiar syntax."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "0022d07b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7364\n",
      "--------------------------------------------------------------------------------------------------\n",
      "|\"DATE\"               |\"DAY_OF_WEEK\"  |\"MONTH\"  |\"DAYTYPE\"  |\"TOTAL_RIDERS\"  |\"PREV_DAY_RIDERS\"  |\n",
      "--------------------------------------------------------------------------------------------------\n",
      "|2001-01-01 00:00:00  |1              |1        |U          |295439          |NULL               |\n",
      "|2001-01-02 00:00:00  |2              |1        |W          |776862          |295439             |\n",
      "|2001-01-03 00:00:00  |3              |1        |W          |820048          |776862             |\n",
      "|2001-01-04 00:00:00  |4              |1        |W          |867675          |820048             |\n",
      "|2001-01-05 00:00:00  |5              |1        |W          |887519          |867675             |\n",
      "|2001-01-06 00:00:00  |6              |1        |A          |575407          |887519             |\n",
      "|2001-01-07 00:00:00  |0              |1        |U          |374435          |575407             |\n",
      "|2001-01-08 00:00:00  |1              |1        |W          |980660          |374435             |\n",
      "|2001-01-09 00:00:00  |2              |1        |W          |974858          |980660             |\n",
      "|2001-01-10 00:00:00  |3              |1        |W          |980656          |974858             |\n",
      "--------------------------------------------------------------------------------------------------\n",
      "\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "# Add a new column for the month\n",
    "df = df.with_column('MONTH', month(col('DATE')))\n",
    "\n",
    "# Group by DATE, DAY_OF_WEEK, and MONTH, then aggregate\n",
    "total_riders = df.group_by('DATE','DAY_OF_WEEK','MONTH').agg(\n",
    "    F.listagg('DAYTYPE', is_distinct=True).alias('DAYTYPE'),\n",
    "    F.sum('RIDES').alias('TOTAL_RIDERS')\n",
    ").order_by('DATE')\n",
    "\n",
    "#Define a window specification\n",
    "window_spec = Window.order_by('DATE')\n",
    "\n",
    "# Add a lagged column for total ridership of the previous day\n",
    "total_riders = total_riders.with_column('PREV_DAY_RIDERS', lag(col('TOTAL_RIDERS'), 1).over(window_spec))\n",
    "\n",
    "# Show the resulting dataframe\n",
    "print (total_riders.count())\n",
    "print (total_riders.show())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a03d95b",
   "metadata": {},
   "source": [
    "### Also, you can use ChatGPT to generate the code for you.\n",
    "\n",
    " <img src=\"fe_forecasting.png\" alt=\"Forecasting Visualization\" width=\"600\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "054382db",
   "metadata": {},
   "source": [
    "\n",
    "**Feature Views**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "5d74f03b",
   "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>VERSION</th>\n",
       "      <th>DATABASE_NAME</th>\n",
       "      <th>SCHEMA_NAME</th>\n",
       "      <th>CREATED_ON</th>\n",
       "      <th>OWNER</th>\n",
       "      <th>DESC</th>\n",
       "      <th>ENTITIES</th>\n",
       "      <th>REFRESH_FREQ</th>\n",
       "      <th>REFRESH_MODE</th>\n",
       "      <th>SCHEDULING_STATE</th>\n",
       "      <th>WAREHOUSE</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>WEATHER</td>\n",
       "      <td>1</td>\n",
       "      <td>RAJIV</td>\n",
       "      <td>FEATURE_STORE_MLDEMO</td>\n",
       "      <td>2024-10-14 13:31:37.376</td>\n",
       "      <td>RAJIV</td>\n",
       "      <td></td>\n",
       "      <td>[\\n  \"ROUTE\"\\n]</td>\n",
       "      <td>1 day</td>\n",
       "      <td>INCREMENTAL</td>\n",
       "      <td>ACTIVE</td>\n",
       "      <td>RAJIV</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>AGGBUSDATA</td>\n",
       "      <td>1</td>\n",
       "      <td>RAJIV</td>\n",
       "      <td>FEATURE_STORE_MLDEMO</td>\n",
       "      <td>2024-10-16 09:22:56.565</td>\n",
       "      <td>RAJIV</td>\n",
       "      <td></td>\n",
       "      <td>[\\n  \"ROUTE\"\\n]</td>\n",
       "      <td>None</td>\n",
       "      <td>None</td>\n",
       "      <td>None</td>\n",
       "      <td>None</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         NAME VERSION DATABASE_NAME           SCHEMA_NAME  \\\n",
       "0     WEATHER       1         RAJIV  FEATURE_STORE_MLDEMO   \n",
       "1  AGGBUSDATA       1         RAJIV  FEATURE_STORE_MLDEMO   \n",
       "\n",
       "               CREATED_ON  OWNER DESC         ENTITIES REFRESH_FREQ  \\\n",
       "0 2024-10-14 13:31:37.376  RAJIV       [\\n  \"ROUTE\"\\n]        1 day   \n",
       "1 2024-10-16 09:22:56.565  RAJIV       [\\n  \"ROUTE\"\\n]         None   \n",
       "\n",
       "  REFRESH_MODE SCHEDULING_STATE WAREHOUSE  \n",
       "0  INCREMENTAL           ACTIVE     RAJIV  \n",
       "1         None             None      None  "
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "agg_fv = FeatureView(\n",
    "    name=\"AggBusData\",\n",
    "    entities=[entity],\n",
    "    feature_df=total_riders,\n",
    "    timestamp_col=\"DATE\",\n",
    ")\n",
    "\n",
    "agg_fv = fs.register_feature_view(agg_fv, version=\"1\", overwrite=True)\n",
    "\n",
    "# Show our newly created Feature View and display as Pandas DataFrame\n",
    "fs.list_feature_views().to_pandas()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5cfdc5df",
   "metadata": {},
   "source": [
    "### High level view of the Feature Store\n",
    "\n",
    " <img src=\"featurestore.png\" alt=\"Forecasting Visualization\" width=\"600\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e52f46a",
   "metadata": {},
   "source": [
    "## Join in the Weather Data from the Snowflake Marketplace\n",
    "\n",
    "Instead of downloading data and building pipelines, Snowflake has a lot of useful data, including weather data in it's Marketplace. This means the data is only a SQL query away. \n",
    "\n",
    " [Cybersyn Weather](https://app.snowflake.com/marketplace/listing/GZTSZAS2KIM/cybersyn-inc-weather-environmental-essentials?search=weather)\n",
    "\n",
    "SQL QUERY: \n",
    "```\n",
    "SELECT\n",
    "  ts.noaa_weather_station_id,\n",
    "  ts.DATE,\n",
    "  COALESCE(MAX(CASE WHEN ts.variable = 'minimum_temperature' THEN ts.Value ELSE NULL END), 0) AS minimum_temperature,\n",
    "  COALESCE(MAX(CASE WHEN ts.variable = 'precipitation' THEN ts.Value ELSE NULL END), 0) AS precipitation,\n",
    "  COALESCE(MAX(CASE WHEN ts.variable = 'maximum_temperature' THEN ts.Value ELSE NULL END), 0) AS maximum_temperature\n",
    "FROM\n",
    "  cybersyn.noaa_weather_metrics_timeseries AS ts\n",
    "JOIN\n",
    "  cybersyn.noaa_weather_station_index AS idx\n",
    "ON\n",
    "  (ts.noaa_weather_station_id = idx.noaa_weather_station_id)\n",
    "WHERE\n",
    "  idx.NOAA_WEATHER_STATION_ID = 'USW00014819'\n",
    "  AND (ts.VARIABLE = 'minimum_temperature' OR ts.VARIABLE = 'precipitation' OR ts.VARIABLE = 'maximum_temperature')\n",
    "GROUP BY\n",
    "  ts.noaa_weather_station_id,\n",
    "  ts.DATE\n",
    "LIMIT 1000;\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "id": "b56ea3fe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "------------------------------------------------------------------------------------------------------------\n",
      "|\"NOAA_WEATHER_STATION_ID\"  |\"DATE\"      |\"MINIMUM_TEMPERATURE\"  |\"MAXIMUM_TEMPERATURE\"  |\"PRECIPITATION\"  |\n",
      "------------------------------------------------------------------------------------------------------------\n",
      "|USW00014819                |2020-05-21  |13.3                   |20.0                   |0.0              |\n",
      "|USW00014819                |2021-11-09  |6.1                    |13.9                   |0.0              |\n",
      "|USW00014819                |2016-05-09  |10.6                   |15.6                   |9.1              |\n",
      "|USW00014819                |2013-09-14  |10.6                   |22.2                   |0.0              |\n",
      "|USW00014819                |2015-04-12  |8.3                    |21.7                   |0.0              |\n",
      "|USW00014819                |2019-04-19  |5.0                    |9.4                    |0.0              |\n",
      "|USW00014819                |2012-09-28  |11.1                   |19.4                   |0.0              |\n",
      "|USW00014819                |2008-02-19  |-15.5                  |-8.8                   |0.0              |\n",
      "|USW00014819                |2021-02-24  |0.0                    |7.2                    |0.0              |\n",
      "|USW00014819                |2004-04-23  |5.6                    |16.7                   |0.0              |\n",
      "------------------------------------------------------------------------------------------------------------\n",
      "\n"
     ]
    }
   ],
   "source": [
    "weather = session.read.table('RAJIV.FEATURE_STORE_MLDEMO.CHICAGO_WEATHER')\n",
    "\n",
    "from snowflake.snowpark.types import DoubleType\n",
    "weather = weather.withColumn('MINIMUM_TEMPERATURE', weather['MINIMUM_TEMPERATURE'].cast(DoubleType()))\n",
    "weather = weather.withColumn('MAXIMUM_TEMPERATURE', weather['MAXIMUM_TEMPERATURE'].cast(DoubleType()))\n",
    "weather = weather.withColumn('PRECIPITATION', weather['PRECIPITATION'].cast(DoubleType()))\n",
    "\n",
    "weather.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46886f75",
   "metadata": {},
   "source": [
    "Creating a feature view here for the weather data. This feature view will refresh every 24 hours. This is essential data that is constantly changing and Snowflake uses a dynamic table to manage the process. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "id": "52797017",
   "metadata": {},
   "outputs": [],
   "source": [
    "weather_fv = FeatureView(\n",
    "    name=\"weather\",\n",
    "    entities=[entity],\n",
    "    feature_df=weather,\n",
    "    timestamp_col=\"DATE\",\n",
    "    refresh_freq=\"1 day\", \n",
    ")\n",
    "\n",
    "weather_fv = fs.register_feature_view(weather_fv, version=\"1\", overwrite=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0317010",
   "metadata": {},
   "source": [
    "## Generate Training Dataset\n",
    "\n",
    "Our feature store is filled with data, but we don't need to use it all. Here we select a subset of the feature store for training. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "ef07814d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a date range between 2017 and 2019\n",
    "date_range = pd.date_range(start='01/01/2013', end='12/31/2019')\n",
    "date_column = date_range.strftime('%m/%d/%Y')\n",
    "df = pd.DataFrame(date_column, columns=['DATE'])\n",
    "spine_df = session.create_dataframe(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa9ba4b1",
   "metadata": {},
   "source": [
    "Generate a training dataset "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "8e3aa61d",
   "metadata": {},
   "outputs": [],
   "source": [
    "training_set = fs.generate_training_set(\n",
    "    spine_df=spine_df,\n",
    "    features=[agg_fv,weather_fv])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "0fda2486",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
      "|\"DATE\"      |\"DAY_OF_WEEK\"  |\"MONTH\"  |\"DAYTYPE\"  |\"TOTAL_RIDERS\"  |\"PREV_DAY_RIDERS\"  |\"NOAA_WEATHER_STATION_ID\"  |\"MINIMUM_TEMPERATURE\"  |\"MAXIMUM_TEMPERATURE\"  |\"PRECIPITATION\"  |\n",
      "---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
      "|02/01/2017  |3              |2        |W          |880680          |824937             |USW00014819                |-4.9                   |3.9                    |0.0              |\n",
      "|07/23/2019  |2              |7        |W          |751862          |729088             |USW00014819                |16.7                   |27.2                   |0.0              |\n",
      "|10/31/2017  |2              |10       |W          |840949          |834138             |USW00014819                |1.7                    |5.0                    |0.0              |\n",
      "|10/27/2013  |0              |10       |U          |411995          |576135             |USW00014819                |0.0                    |12.8                   |0.0              |\n",
      "|07/05/2018  |4              |7        |W          |650224          |382972             |USW00014819                |22.2                   |35.0                   |13.2             |\n",
      "|06/01/2016  |3              |6        |W          |869160          |797370             |USW00014819                |18.3                   |27.2                   |7.6              |\n",
      "|12/25/2016  |0              |12       |U          |198503          |390507             |USW00014819                |0.6                    |5.6                    |1.0              |\n",
      "|06/05/2019  |3              |6        |W          |814691          |794543             |USW00014819                |15.6                   |30.0                   |9.7              |\n",
      "|05/08/2019  |3              |5        |W          |820018          |802783             |USW00014819                |8.3                    |24.4                   |9.7              |\n",
      "|12/22/2014  |1              |12       |W          |700198          |392314             |USW00014819                |-0.5                   |6.7                    |7.1              |\n",
      "---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
      "\n"
     ]
    }
   ],
   "source": [
    "training_set.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "c5237c42",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Dropping any null values\n",
    "from snowflake.snowpark.functions import col, is_null, to_date\n",
    "\n",
    "# Create a filter condition for non-finite values across all columns\n",
    "non_finite_filter = None\n",
    "\n",
    "# Iterate over all columns and update the filter condition\n",
    "for column in training_set.columns:\n",
    "    current_filter = is_null(col(column))\n",
    "    non_finite_filter = current_filter if non_finite_filter is None else (non_finite_filter | current_filter)\n",
    "\n",
    "# Apply the filter to the DataFrame to exclude rows with any non-finite values\n",
    "df_filtered = training_set.filter(~non_finite_filter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "96a10c75",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Split the data into training and test sets\n",
    "df_filtered = df_filtered.withColumn(\"DATE\", to_date(col(\"DATE\"), 'MM/dd/yyyy'))\n",
    "train = df_filtered.filter(col('DATE') < '01/01/2019')\n",
    "test = df_filtered.filter(col('DATE') >= '01/01/2019')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "db5114b0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2190\n",
      "365\n"
     ]
    }
   ],
   "source": [
    "print (train.count())\n",
    "print (test.count())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "774e0c4f",
   "metadata": {},
   "source": [
    "## 4. Distributed Feature Engineering in a Pipeline\n",
    "\n",
    "Feature engineering + XGBoost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "dc637e73",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Row(status='Statement executed successfully.')]"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "session.sql(\"create or replace warehouse snowpark_opt_wh with warehouse_size = 'MEDIUM' warehouse_type = 'SNOWPARK-OPTIMIZED'\").collect()\n",
    "session.sql(\"alter warehouse snowpark_opt_wh set max_concurrency_level = 1\").collect()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "ad265fe5",
   "metadata": {},
   "outputs": [],
   "source": [
    " ## Distributed Preprocessing - 25X to 50X faster\n",
    "numeric_features = ['DAY_OF_WEEK','MONTH','PREV_DAY_RIDERS','MINIMUM_TEMPERATURE','MAXIMUM_TEMPERATURE','PRECIPITATION']\n",
    "numeric_transformer = Pipeline(steps=[('scaler', StandardScaler())])\n",
    "\n",
    "categorical_cols = ['DAYTYPE']\n",
    "categorical_transformer = Pipeline(steps=[\n",
    "    ('imputer', SimpleImputer(strategy='most_frequent')),\n",
    "    ('onehot', OrdinalEncoder(handle_unknown='use_encoded_value',unknown_value=-99999))\n",
    "])\n",
    "\n",
    "preprocessor = ColumnTransformer(\n",
    "    transformers=[\n",
    "        ('num', numeric_transformer, numeric_features),\n",
    "        ('cat', categorical_transformer, categorical_cols)\n",
    "        ])\n",
    "\n",
    "pipeline = Pipeline(steps=[('preprocessor', preprocessor),('model', XGBRegressor())])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "35dca763",
   "metadata": {},
   "source": [
    "## 5. Distributed Training\n",
    "\n",
    "These operations are done inside the Snowpark warehouse which provides improved performance and scalability with distributed execution for these scikit-learn preprocessing functions, hyperparameter tuning (grid and random) and XGBoost training (and many other types of models)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "id": "a1c973e3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<snowflake.ml.modeling.model_selection.grid_search_cv.GridSearchCV at 0x157db1b50>"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " ## Distributed HyperParameter Optimization\n",
    "hyper_param = dict(\n",
    "        model__max_depth=[2,4],\n",
    "        model__learning_rate=[0.1,0.3],\n",
    "    )\n",
    "\n",
    "xg_model = GridSearchCV(\n",
    "    estimator=pipeline,\n",
    "    param_grid=hyper_param,\n",
    "    #cv=5,\n",
    "    input_cols=numeric_features + categorical_cols,\n",
    "    label_cols=['TOTAL_RIDERS'],\n",
    "    output_cols=[\"TOTAL_RIDERS_FORECAST\"],\n",
    ")\n",
    "\n",
    "# Fit and Score\n",
    "xg_model.fit(train)\n",
    "##Takes 25 seconds"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1788805",
   "metadata": {},
   "source": [
    "## 6. Model Evaluation\n",
    "Look at the results of the mode. cv_results is a dictionary, where each key is a string describing one of the metrics or parameters, and the corresponding value is an array with one entry per combination of parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "5d0e9845",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Row(status='Warehouse SNOWPARK_OPT_WH successfully created.')]"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "session.sql(\"create or replace warehouse snowpark_opt_wh with warehouse_size = 'SMALL'\").collect()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "id": "70d680fd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Parameters: {'model__learning_rate': 0.1, 'model__max_depth': 2}\n",
      "Mean Test Score: 0.9327377990922088\n",
      "\n",
      "Parameters: {'model__learning_rate': 0.1, 'model__max_depth': 4}\n",
      "Mean Test Score: 0.9472755366304341\n",
      "\n",
      "Parameters: {'model__learning_rate': 0.3, 'model__max_depth': 2}\n",
      "Mean Test Score: 0.9404794021499189\n",
      "\n",
      "Parameters: {'model__learning_rate': 0.3, 'model__max_depth': 4}\n",
      "Mean Test Score: 0.9440702127165757\n",
      "\n"
     ]
    }
   ],
   "source": [
    "cv_results = xg_model.to_sklearn().cv_results_\n",
    "\n",
    "for i in range(len(cv_results['params'])):\n",
    "    print(f\"Parameters: {cv_results['params'][i]}\")\n",
    "    print(f\"Mean Test Score: {cv_results['mean_test_score'][i]}\")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38c34113",
   "metadata": {},
   "source": [
    "Look at the accuracy of the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "id": "73c36d50",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MSE: 34076.139726027395\n",
      "---------------------------------------------------------\n",
      "|\"DATE\"      |\"TOTAL_RIDERS\"  |\"TOTAL_RIDERS_FORECAST\"  |\n",
      "---------------------------------------------------------\n",
      "|2019-11-14  |759650          |764088.875               |\n",
      "|2019-01-10  |743075          |757489.125               |\n",
      "|2019-07-20  |461664          |487479.4375              |\n",
      "|2019-07-23  |751862          |808461.8125              |\n",
      "|2019-05-23  |799367          |813655.3125              |\n",
      "|2019-06-05  |814691          |800290.375               |\n",
      "|2019-08-31  |480224          |493761.8125              |\n",
      "|2019-11-16  |463941          |469098.75                |\n",
      "|2019-12-09  |780897          |763410.25                |\n",
      "|2019-05-08  |820018          |801978.625               |\n",
      "---------------------------------------------------------\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from snowflake.ml.modeling.metrics import mean_absolute_error\n",
    "testpreds = xg_model.predict(test)\n",
    "print('MSE:', mean_absolute_error(df=testpreds, y_true_col_names='TOTAL_RIDERS', y_pred_col_names='\"TOTAL_RIDERS_FORECAST\"'))\n",
    "testpreds.select(\"DATE\", \"TOTAL_RIDERS\", \"TOTAL_RIDERS_FORECAST\").show(10)         "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a93fa47b",
   "metadata": {},
   "source": [
    "Materialize the results to a table"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "id": "d9489eb7",
   "metadata": {},
   "outputs": [],
   "source": [
    "testpreds.write.save_as_table(table_name='RAJIV.FEATURE_STORE_MLDEMO.CHICAGO_BUS_RIDES_FORECAST', mode='overwrite')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d39e5be6",
   "metadata": {},
   "source": [
    "Using metrics from snowpark so calculation is done inside snowflake"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a39a775d",
   "metadata": {},
   "source": [
    "## 7. Save to the Model Registry and use for Predictions (Python & SQL)\n",
    "\n",
    "Connect to the registry"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "id": "c97f06d1",
   "metadata": {},
   "outputs": [],
   "source": [
    "from snowflake.ml.registry import Registry\n",
    "reg = Registry(session=session, database_name=\"RAJIV\", schema_name=\"FEATURE_STORE_MLDEMO\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "id": "99012d7d",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/rajishah/anaconda3/envs/working311/lib/python3.11/site-packages/snowflake/ml/model/_model_composer/model_composer.py:129: UserWarning: `relax_version` is not set and therefore defaulted to True. Dependency version constraints relaxed from ==x.y.z to >=x.y, <(x+1). To use specific dependency versions for compatibility, reproducibility, etc., set `options={'relax_version': False}` when logging the model.\n",
      "  self.manifest.save(\n"
     ]
    }
   ],
   "source": [
    "model_ref = reg.log_model(\n",
    "    model_name=\"Forecasting_Bus_Ridership\",\n",
    "    version_name=\"v14\",    \n",
    "    model=xg_model,\n",
    "    conda_dependencies=[\"scikit-learn\",\"xgboost\"],\n",
    "    sample_input_data=train,\n",
    "    comment=\"XGBoost model, Oct 9\"\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46750d4e",
   "metadata": {},
   "source": [
    "Let's retrieve the model from the registry"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "id": "16f2b93f",
   "metadata": {},
   "outputs": [],
   "source": [
    "reg_model = reg.get_model(\"Forecasting_Bus_Ridership\").version(\"v14\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2ad7e11",
   "metadata": {},
   "source": [
    "Here is an example of exporting from the model registry"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "id": "b893a350",
   "metadata": {},
   "outputs": [],
   "source": [
    "#reg_model.export(\"/Users/rajishah/Code/snowflake-notebooks/Forecasting_ChicagoBus/model\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68bc70af",
   "metadata": {},
   "source": [
    "Let's do predictions inside the warehouse for some evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "id": "3a40b53f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
      "|\"DAY_OF_WEEK\"  |\"MONTH\"  |\"DAYTYPE\"  |\"TOTAL_RIDERS\"  |\"PREV_DAY_RIDERS\"  |\"NOAA_WEATHER_STATION_ID\"  |\"MINIMUM_TEMPERATURE\"  |\"MAXIMUM_TEMPERATURE\"  |\"PRECIPITATION\"  |\"DATE\"      |\n",
      "---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
      "|2              |7        |W          |751862          |729088             |USW00014819                |16.7                   |27.2                   |0.0              |2019-07-23  |\n",
      "|3              |6        |W          |814691          |794543             |USW00014819                |15.6                   |30.0                   |9.7              |2019-06-05  |\n",
      "|3              |5        |W          |820018          |802783             |USW00014819                |8.3                    |24.4                   |9.7              |2019-05-08  |\n",
      "|1              |12       |W          |780897          |341326             |USW00014819                |-3.8                   |9.4                    |0.5              |2019-12-09  |\n",
      "|4              |5        |W          |799367          |805534             |USW00014819                |17.8                   |24.4                   |0.5              |2019-05-23  |\n",
      "|6              |7        |A          |461664          |697540             |USW00014819                |24.4                   |36.1                   |0.3              |2019-07-20  |\n",
      "|4              |1        |W          |743075          |743021             |USW00014819                |-9.3                   |-3.8                   |0.0              |2019-01-10  |\n",
      "|6              |8        |A          |480224          |756923             |USW00014819                |17.8                   |24.4                   |2.8              |2019-08-31  |\n",
      "|4              |11       |W          |759650          |758425             |USW00014819                |-3.8                   |0.6                    |0.0              |2019-11-14  |\n",
      "|6              |11       |A          |463941          |785975             |USW00014819                |-1.6                   |5.6                    |0.0              |2019-11-16  |\n",
      "---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
      "\n"
     ]
    }
   ],
   "source": [
    "test.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "id": "bf7f3388",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "---------------------------------------------------------\n",
      "|\"DATE\"      |\"TOTAL_RIDERS\"  |\"TOTAL_RIDERS_FORECAST\"  |\n",
      "---------------------------------------------------------\n",
      "|2019-01-01  |247279          |311394.375               |\n",
      "|2019-01-02  |585996          |602599.0625              |\n",
      "|2019-01-03  |660631          |732633.6875              |\n",
      "|2019-01-04  |662011          |718364.0625              |\n",
      "|2019-01-05  |440848          |464067.8125              |\n",
      "|2019-01-06  |316844          |336178.4375              |\n",
      "|2019-01-07  |717818          |800692.25                |\n",
      "|2019-01-08  |779946          |808019.3125              |\n",
      "|2019-01-09  |743021          |791728.1875              |\n",
      "|2019-01-10  |743075          |757489.125               |\n",
      "---------------------------------------------------------\n",
      "\n"
     ]
    }
   ],
   "source": [
    "remote_prediction = reg_model.run(test, function_name='predict')\n",
    "remote_prediction.sort(\"DATE\").select(\"DATE\",\"TOTAL_RIDERS\",\"TOTAL_RIDERS_FORECAST\").show(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7bcb63f4",
   "metadata": {},
   "source": [
    "save evaluation metrics in the model registry"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "id": "0dc0c703",
   "metadata": {},
   "outputs": [],
   "source": [
    "from snowflake.ml.modeling.metrics import mean_absolute_error\n",
    "mae = mean_absolute_error(df=remote_prediction, y_true_col_names='TOTAL_RIDERS', y_pred_col_names='\"TOTAL_RIDERS_FORECAST\"')\n",
    "reg_model.set_metric(\"MAE\", value=mae)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "id": "d7874770",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'MAE': 34076.139726027395}"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reg_model.show_metrics()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c615b1b",
   "metadata": {},
   "source": [
    "If you look in the activity view, you can find the SQL which will run a bit faster.  This SQL command is showing the result in a snowflake dataframe. You could use `collect` to pull the info out into your local session.\n",
    "\n",
    "Modify the SQL with by adding in your specific model with this line: `MODEL_VERSION_ALIAS AS MODEL RAJIV.FEATURE_STORE_MLDEMO.FORECASTING_BUS_RIDERSHIP VERSION V1` and updating the location of your target predictions which is located here: `SNOWPARK_ML_MODEL_INFERENCE_INPUT`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "id": "2276417d",
   "metadata": {},
   "outputs": [],
   "source": [
    "sqlquery = \"\"\"SELECT \"DATE\", \"TOTAL_RIDERS\",  CAST (\"TMP_RESULT\"['TOTAL_RIDERS_FORECAST'] AS DOUBLE) AS \"TOTAL_RIDERS_FORECAST\" FROM (WITH SNOWPARK_ML_MODEL_INFERENCE_INPUT AS (SELECT  *  FROM ( SELECT \"DAY_OF_WEEK\", \"MONTH\", \"DAYTYPE\", \"TOTAL_RIDERS\", \"PREV_DAY_RIDERS\", \"NOAA_WEATHER_STATION_ID\", \"MINIMUM_TEMPERATURE\", \"MAXIMUM_TEMPERATURE\", \"PRECIPITATION\", to_date(\"DATE\", 'MM/dd/yyyy') AS \"DATE\" FROM (\n",
    "                    SELECT\n",
    "                        l_1.*,\n",
    "                        r_1.* EXCLUDE (DATE)\n",
    "                    FROM (\n",
    "                    SELECT\n",
    "                        l_0.*,\n",
    "                        r_0.* EXCLUDE (DATE)\n",
    "                    FROM (SELECT  *  FROM (\"RAJIV\".\"PUBLIC\".\"SNOWPARK_TEMP_TABLE_MDXB71DXXU\")) l_0\n",
    "                    LEFT JOIN (\n",
    "                        SELECT DATE, DAY_OF_WEEK, MONTH, DAYTYPE, TOTAL_RIDERS, PREV_DAY_RIDERS\n",
    "                        FROM RAJIV.FEATURE_STORE_MLDEMO.AGGBUSDATA$1\n",
    "                    ) r_0\n",
    "                    ON l_0.DATE = r_0.DATE\n",
    "                ) l_1\n",
    "                    LEFT JOIN (\n",
    "                        SELECT DATE, NOAA_WEATHER_STATION_ID, MINIMUM_TEMPERATURE, MAXIMUM_TEMPERATURE, PRECIPITATION\n",
    "                        FROM RAJIV.FEATURE_STORE_MLDEMO.WEATHER$1\n",
    "                    ) r_1\n",
    "                    ON l_1.DATE = r_1.DATE\n",
    "                ) WHERE NOT (((((((((\"DATE\" IS NULL OR \"DAY_OF_WEEK\" IS NULL) OR \"MONTH\" IS NULL) OR \"DAYTYPE\" IS NULL) OR \"TOTAL_RIDERS\" IS NULL) OR \"PREV_DAY_RIDERS\" IS NULL) OR \"NOAA_WEATHER_STATION_ID\" IS NULL) OR \"MINIMUM_TEMPERATURE\" IS NULL) OR \"MAXIMUM_TEMPERATURE\" IS NULL) OR \"PRECIPITATION\" IS NULL)) WHERE (\"DATE\" >= '01/01/2019')),MODEL_VERSION_ALIAS AS MODEL RAJIV.FEATURE_STORE_MLDEMO.FORECASTING_BUS_RIDERSHIP VERSION V1\n",
    "                SELECT *,\n",
    "                    MODEL_VERSION_ALIAS!PREDICT(DAY_OF_WEEK, MONTH, PREV_DAY_RIDERS, MINIMUM_TEMPERATURE, MAXIMUM_TEMPERATURE, PRECIPITATION, DAYTYPE) AS TMP_RESULT\n",
    "                FROM SNOWPARK_ML_MODEL_INFERENCE_INPUT) ORDER BY \"DATE\" ASC NULLS FIRST LIMIT 10\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "id": "6d60a60b",
   "metadata": {},
   "outputs": [],
   "source": [
    "#results = session.sql(sqlquery).show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "161896fa",
   "metadata": {},
   "source": [
    "## 8. Get Shap Explanations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "id": "8b13405e",
   "metadata": {},
   "outputs": [],
   "source": [
    "#explanations = reg_model.run(test, function_name=\"explain\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce73f451",
   "metadata": {},
   "source": [
    "## 9. Show lineage"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "id": "a81a6455",
   "metadata": {},
   "outputs": [],
   "source": [
    "TABLE_NAME = \"RAJIV.FEATURE_STORE_MLDEMO.CHICAGO_BUS_RIDES_FORECAST\"\n",
    "df = session.lineage.trace(f\"RAJIV.FEATURE_STORE_MLDEMO.CHICAGO_BUS_RIDES\", \"TABLE\", direction=\"downstream\", distance=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "id": "88d03194",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--------------------------------------------------------------------------------------------------------------------------------------\n",
      "|\"SOURCE_OBJECT\"                                     |\"TARGET_OBJECT\"                                     |\"DIRECTION\"  |\"DISTANCE\"  |\n",
      "--------------------------------------------------------------------------------------------------------------------------------------\n",
      "|{                                                   |{                                                   |Downstream   |1           |\n",
      "|  \"createdOn\": \"2024-10-16T16:22:47Z\",              |  \"createdOn\": \"2024-09-30T16:48:58Z\",              |             |            |\n",
      "|  \"domain\": \"TABLE\",                                |  \"domain\": \"FEATURE_VIEW\",                         |             |            |\n",
      "|  \"name\": \"RAJIV.FEATURE_STORE_MLDEMO.CHICAGO_B...  |  \"name\": \"RAJIV.FEATURE_STORE_MLDEMO.AGGBUSDATA\",  |             |            |\n",
      "|  \"status\": \"ACTIVE\"                                |  \"status\": \"DELETED\",                              |             |            |\n",
      "|}                                                   |  \"version\": \"1\"                                    |             |            |\n",
      "|                                                    |}                                                   |             |            |\n",
      "|{                                                   |{                                                   |Downstream   |1           |\n",
      "|  \"createdOn\": \"2024-10-16T16:22:47Z\",              |  \"createdOn\": \"2024-10-08T21:01:31Z\",              |             |            |\n",
      "|  \"domain\": \"TABLE\",                                |  \"domain\": \"FEATURE_VIEW\",                         |             |            |\n",
      "|  \"name\": \"RAJIV.FEATURE_STORE_MLDEMO.CHICAGO_B...  |  \"name\": \"RAJIV.FEATURE_STORE_MLDEMO.AGGBUSDATA\",  |             |            |\n",
      "|  \"status\": \"ACTIVE\"                                |  \"status\": \"DELETED\",                              |             |            |\n",
      "|}                                                   |  \"version\": \"1\"                                    |             |            |\n",
      "|                                                    |}                                                   |             |            |\n",
      "|{                                                   |{                                                   |Downstream   |1           |\n",
      "|  \"createdOn\": \"2024-10-16T16:22:47Z\",              |  \"createdOn\": \"2024-10-09T02:13:57Z\",              |             |            |\n",
      "|  \"domain\": \"TABLE\",                                |  \"domain\": \"FEATURE_VIEW\",                         |             |            |\n",
      "|  \"name\": \"RAJIV.FEATURE_STORE_MLDEMO.CHICAGO_B...  |  \"name\": \"RAJIV.FEATURE_STORE_MLDEMO.AGGBUSDATA\",  |             |            |\n",
      "|  \"status\": \"ACTIVE\"                                |  \"status\": \"DELETED\",                              |             |            |\n",
      "|}                                                   |  \"version\": \"1\"                                    |             |            |\n",
      "|                                                    |}                                                   |             |            |\n",
      "|{                                                   |{                                                   |Downstream   |1           |\n",
      "|  \"createdOn\": \"2024-10-16T16:22:47Z\",              |  \"createdOn\": \"2024-10-08T20:45:30Z\",              |             |            |\n",
      "|  \"domain\": \"TABLE\",                                |  \"domain\": \"FEATURE_VIEW\",                         |             |            |\n",
      "|  \"name\": \"RAJIV.FEATURE_STORE_MLDEMO.CHICAGO_B...  |  \"name\": \"RAJIV.FEATURE_STORE_MLDEMO.AGGBUSDATA\",  |             |            |\n",
      "|  \"status\": \"ACTIVE\"                                |  \"status\": \"DELETED\",                              |             |            |\n",
      "|}                                                   |  \"version\": \"1\"                                    |             |            |\n",
      "|                                                    |}                                                   |             |            |\n",
      "|{                                                   |{                                                   |Downstream   |1           |\n",
      "|  \"createdOn\": \"2024-10-16T16:22:47Z\",              |  \"createdOn\": \"2024-10-08T20:54:06Z\",              |             |            |\n",
      "|  \"domain\": \"TABLE\",                                |  \"domain\": \"FEATURE_VIEW\",                         |             |            |\n",
      "|  \"name\": \"RAJIV.FEATURE_STORE_MLDEMO.CHICAGO_B...  |  \"name\": \"RAJIV.FEATURE_STORE_MLDEMO.AGGBUSDATA\",  |             |            |\n",
      "|  \"status\": \"ACTIVE\"                                |  \"status\": \"DELETED\",                              |             |            |\n",
      "|}                                                   |  \"version\": \"1\"                                    |             |            |\n",
      "|                                                    |}                                                   |             |            |\n",
      "|{                                                   |{                                                   |Downstream   |1           |\n",
      "|  \"createdOn\": \"2024-10-16T16:22:47Z\",              |  \"createdOn\": \"2024-10-08T20:40:21Z\",              |             |            |\n",
      "|  \"domain\": \"TABLE\",                                |  \"domain\": \"FEATURE_VIEW\",                         |             |            |\n",
      "|  \"name\": \"RAJIV.FEATURE_STORE_MLDEMO.CHICAGO_B...  |  \"name\": \"RAJIV.FEATURE_STORE_MLDEMO.AGGBUSDATA\",  |             |            |\n",
      "|  \"status\": \"ACTIVE\"                                |  \"status\": \"DELETED\",                              |             |            |\n",
      "|}                                                   |  \"version\": \"1\"                                    |             |            |\n",
      "|                                                    |}                                                   |             |            |\n",
      "|{                                                   |{                                                   |Downstream   |1           |\n",
      "|  \"createdOn\": \"2024-10-16T16:22:47Z\",              |  \"createdOn\": \"2024-10-09T15:29:22Z\",              |             |            |\n",
      "|  \"domain\": \"TABLE\",                                |  \"domain\": \"FEATURE_VIEW\",                         |             |            |\n",
      "|  \"name\": \"RAJIV.FEATURE_STORE_MLDEMO.CHICAGO_B...  |  \"name\": \"RAJIV.FEATURE_STORE_MLDEMO.AGGBUSDATA\",  |             |            |\n",
      "|  \"status\": \"ACTIVE\"                                |  \"status\": \"DELETED\",                              |             |            |\n",
      "|}                                                   |  \"version\": \"1\"                                    |             |            |\n",
      "|                                                    |}                                                   |             |            |\n",
      "|{                                                   |{                                                   |Downstream   |1           |\n",
      "|  \"createdOn\": \"2024-10-16T16:22:47Z\",              |  \"createdOn\": \"2024-10-14T12:51:33Z\",              |             |            |\n",
      "|  \"domain\": \"TABLE\",                                |  \"domain\": \"FEATURE_VIEW\",                         |             |            |\n",
      "|  \"name\": \"RAJIV.FEATURE_STORE_MLDEMO.CHICAGO_B...  |  \"name\": \"RAJIV.FEATURE_STORE_MLDEMO.AGGBUSDATA\",  |             |            |\n",
      "|  \"status\": \"ACTIVE\"                                |  \"status\": \"DELETED\",                              |             |            |\n",
      "|}                                                   |  \"version\": \"1\"                                    |             |            |\n",
      "|                                                    |}                                                   |             |            |\n",
      "|{                                                   |{                                                   |Downstream   |1           |\n",
      "|  \"createdOn\": \"2024-10-16T16:22:47Z\",              |  \"createdOn\": \"2024-10-13T20:22:57Z\",              |             |            |\n",
      "|  \"domain\": \"TABLE\",                                |  \"domain\": \"FEATURE_VIEW\",                         |             |            |\n",
      "|  \"name\": \"RAJIV.FEATURE_STORE_MLDEMO.CHICAGO_B...  |  \"name\": \"RAJIV.FEATURE_STORE_MLDEMO.AGGBUSDATA\",  |             |            |\n",
      "|  \"status\": \"ACTIVE\"                                |  \"status\": \"DELETED\",                              |             |            |\n",
      "|}                                                   |  \"version\": \"1\"                                    |             |            |\n",
      "|                                                    |}                                                   |             |            |\n",
      "|{                                                   |{                                                   |Downstream   |1           |\n",
      "|  \"createdOn\": \"2024-10-16T16:22:47Z\",              |  \"createdOn\": \"2024-10-13T12:18:02Z\",              |             |            |\n",
      "|  \"domain\": \"TABLE\",                                |  \"domain\": \"FEATURE_VIEW\",                         |             |            |\n",
      "|  \"name\": \"RAJIV.FEATURE_STORE_MLDEMO.CHICAGO_B...  |  \"name\": \"RAJIV.FEATURE_STORE_MLDEMO.AGGBUSDATA\",  |             |            |\n",
      "|  \"status\": \"ACTIVE\"                                |  \"status\": \"DELETED\",                              |             |            |\n",
      "|}                                                   |  \"version\": \"1\"                                    |             |            |\n",
      "|                                                    |}                                                   |             |            |\n",
      "--------------------------------------------------------------------------------------------------------------------------------------\n",
      "\n"
     ]
    }
   ],
   "source": [
    "df.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "id": "00315bbd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Row(status='Warehouse SNOWPARK_OPT_WH successfully created.')]"
      ]
     },
     "execution_count": 163,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "session.sql(\"create or replace warehouse snowpark_opt_wh with warehouse_size = 'SMALL'\").collect()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d56c2fa4",
   "metadata": {},
   "source": [
    "## 10. Deploy the model to SPCS for Inference\n",
    "\n",
    "It's now possible to deploy and run a model in Snowpark Container Services (SPCS), thus making Snowflake Model Registry more universal and useful by supporting large models that need distributed clusters or GPUs for execution, or that have pip dependencies on OSS or user’s own libraries and frameworks. All of these benefits can be realized without mastering knowledge of docker containers, kubernetes, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1b7e8588",
   "metadata": {},
   "outputs": [],
   "source": [
    "reg_model.create_service(service_name=\"ChicagoBusForecastv14\",\n",
    "                  service_compute_pool=\"NOTEBOOK_CPU_S\",\n",
    "                  image_repo=\"rajiv.public.images\",\n",
    "                  build_external_access_integration=\"RAJ_OPEN_ACCESS_INTEGRATION\",\n",
    "                  ingress_enabled=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a64fed35",
   "metadata": {},
   "outputs": [],
   "source": [
    "spcs_prediction = reg_model.run(test, function_name='predict', service_name=\"CHICAGOBUSFORECASTV13\")\n",
    "spcs_prediction.sort(\"DATE\").select(\"DATE\",\"TOTAL_RIDERS\",\"TOTAL_RIDERS_FORECAST\").show(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "id": "650506a2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Row(name='inference', port=5000, port=5000, port_range=None, protocol='HTTP', is_public='true', ingress_url='nvb4q47i-sfsenorthamerica-demo412.snowflakecomputing.app')]"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "session.sql(\"SHOW ENDPOINTS IN SERVICE RAJIV.FEATURE_STORE_MLDEMO.CHICAGOBUSFORECASTV13\").collect()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6b4690f2",
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import timedelta, timezone, datetime\n",
    "from cryptography.hazmat.primitives.serialization import load_pem_private_key\n",
    "from cryptography.hazmat.primitives.serialization import Encoding\n",
    "from cryptography.hazmat.primitives.serialization import PublicFormat\n",
    "from cryptography.hazmat.backends import default_backend\n",
    "import jwt\n",
    "\n",
    "import base64\n",
    "from getpass import getpass\n",
    "import hashlib\n",
    "\n",
    "# Get the raw bytes of the public key.\n",
    "public_key_raw = private_key_obj.public_key().public_bytes(Encoding.DER, PublicFormat.SubjectPublicKeyInfo)\n",
    "\n",
    "# Get the sha256 hash of the raw bytes.\n",
    "sha256hash = hashlib.sha256()\n",
    "sha256hash.update(public_key_raw)\n",
    "\n",
    "# Base64-encode the value and prepend the prefix 'SHA256:'.\n",
    "public_key_fp = 'SHA256:' + base64.b64encode(sha256hash.digest()).decode('utf-8')\n",
    "\n",
    "account = SF_ACCOUNT\n",
    "\n",
    "# Get the account identifier without the region, cloud provider, or subdomain.\n",
    "if not '.global' in account:\n",
    "    idx = account.find('.')\n",
    "    if idx > 0:\n",
    "        account = account[0:idx]\n",
    "    else:\n",
    "        # Handle the replication case.\n",
    "        idx = account.find('-')\n",
    "        if idx > 0:\n",
    "            account = account[0:idx]\n",
    "\n",
    "# Use uppercase for the account identifier and user name.\n",
    "user = USERNAME\n",
    "account = account.upper()\n",
    "user = user.upper()\n",
    "qualified_username = account + \".\" + user\n",
    "\n",
    "# Get the current time in order to specify the time when the JWT was issued and the expiration time of the JWT.\n",
    "now = datetime.now(timezone.utc)\n",
    "\n",
    "# Specify the length of time during which the JWT will be valid. You can specify at most 1 hour.\n",
    "lifetime = timedelta(minutes=59)\n",
    "\n",
    "# Create the payload for the token.\n",
    "payload = {\n",
    "\n",
    "    # Set the issuer to the fully qualified username concatenated with the public key fingerprint (calculated in the  previous step).\n",
    "    \"iss\": qualified_username + '.' + public_key_fp,\n",
    "\n",
    "    # Set the subject to the fully qualified username.\n",
    "    \"sub\": qualified_username,\n",
    "\n",
    "    # Set the issue time to now.\n",
    "    \"iat\": now,\n",
    "\n",
    "    # Set the expiration time, based on the lifetime specified for this object.\n",
    "    \"exp\": now + lifetime\n",
    "}\n",
    "\n",
    "# Generate the JWT. private_key is the private key that you read from the private key file in the previous step when you generated the public key fingerprint.\n",
    "encoding_algorithm=\"RS256\"\n",
    "token = jwt.encode(payload, key=private_key_obj, algorithm=encoding_algorithm)\n",
    "\n",
    "# If you are using a version of PyJWT prior to 2.0, jwt.encode returns a byte string, rather than a string.\n",
    "# If the token is a byte string, convert it to a string.\n",
    "if isinstance(token, bytes):\n",
    "  token = token.decode('utf-8')\n",
    "decoded_token = jwt.decode(token, key=private_key_obj.public_key(), algorithms=[encoding_algorithm])\n",
    "print(\"Generated a JWT with the following payload:\\n{}\".format(decoded_token))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "56172617",
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "from pprint import pprint\n",
    "import requests\n",
    "\n",
    "# Generate headers using the active connection\n",
    "def get_headers(existing_snowflake_conn):\n",
    "    token = existing_snowflake_conn._rest._token_request('ISSUE')\n",
    "    headers = {'Authorization': f'Snowflake Token=\"{token[\"data\"][\"sessionToken\"]}\\\"'}\n",
    "    return headers\n",
    "\n",
    "def get_headers(existing_snowflake_conn):\n",
    "    # Assuming the connection provides a JWT-like token, modify this to use JWT\n",
    "    token = existing_snowflake_conn._rest._token_request('ISSUE')\n",
    "    \n",
    "    # This assumes the token returned from Snowflake is a valid JWT (adjust if necessary)\n",
    "    jwt_token = token['data']['sessionToken']\n",
    "    \n",
    "    # Modify the Authorization header to include 'Bearer <JWT_TOKEN>'\n",
    "    headers = {'Authorization': f'Bearer {token}'}\n",
    "    return headers\n",
    "\n",
    "# Put the endpoint URL and your data here\n",
    "URL = 'https://bvb4q47i-sfsenorthamerica-demo412.snowflakecomputing.app/predict'\n",
    "\n",
    "def prepare_data(test):\n",
    "    # Ensure 'test' is defined before this point\n",
    "    # Assuming 'test' is a Snowpark DataFrame object\n",
    "    df = test.toPandas()\n",
    "    df['DATE'] = 0\n",
    "    df = df.to_dict(orient='records')\n",
    "    data = {\n",
    "        'data': []\n",
    "        }\n",
    "    for idx, x in enumerate(df):\n",
    "        data['data'].append([idx, list(x.values())])\n",
    "            \n",
    "    return data\n",
    "\n",
    "# Send the request to the endpoint\n",
    "def send_request(data: dict, headers: dict):\n",
    "    output = requests.post(URL, json=data, headers=headers)\n",
    "    assert (output.status_code == 200), f\"Failed to get response from the service. Status code: {output.status_code}\"\n",
    "    return output.content\n",
    "\n",
    "# Testing the flow using your active session\n",
    "# Assuming `existing_snowflake_conn` is your current session's connection object\n",
    "headers = get_headers(session._conn._conn)\n",
    "print (headers)\n",
    "data = prepare_data(test)  # Convert the DataFrame to the right format\n",
    "print (data)\n",
    "\n",
    "# Send the request and get the results\n",
    "results = send_request(data=data, headers=headers)\n",
    "pprint(json.loads(results))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "2f8d37c0",
   "metadata": {},
   "outputs": [],
   "source": [
    "#reg_model.delete_service(\"ChicagoBusForecastv11\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "id": "0d7b969a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Row(status='CHICAGOBUSFORECASTV14 successfully dropped.')]"
      ]
     },
     "execution_count": 166,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "session.sql(\"DROP SERVICE RAJIV.FEATURE_STORE_MLDEMO.CHICAGOBUSFORECASTV14\").collect()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "6b233260",
   "metadata": {},
   "outputs": [],
   "source": [
    "#session.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53420f78",
   "metadata": {},
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.8.13 ('snowpark')",
   "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.11.7"
  },
  "papermill": {
   "default_parameters": {},
   "duration": 41.012855,
   "end_time": "2021-05-15T09:34:14.646782",
   "environment_variables": {},
   "exception": null,
   "input_path": "__notebook__.ipynb",
   "output_path": "__notebook__.ipynb",
   "parameters": {},
   "start_time": "2021-05-15T09:33:33.633927",
   "version": "2.3.3"
  },
  "vscode": {
   "interpreter": {
    "hash": "4fb0a37530c0004d75c43dbcefc0b8b6ea2fdc6f87c96f7fd6f8cf43b3f551c7"
   }
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {
     "03486abb248b48dcae43183c9ffb112a": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "DescriptionStyleModel",
      "state": {
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "DescriptionStyleModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "StyleView",
       "description_width": ""
      }
     },
     "0539c58479b749dd99898d49f43ebcef": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "FloatProgressModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "FloatProgressModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "ProgressView",
       "bar_style": "success",
       "description": "",
       "description_tooltip": null,
       "layout": "IPY_MODEL_d097f3c35ec644bfa231be2d2fd50129",
       "max": 1,
       "min": 0,
       "orientation": "horizontal",
       "style": "IPY_MODEL_0be3e122c58347b79c67cbdfc6939065",
       "value": 1
      }
     },
     "0be3e122c58347b79c67cbdfc6939065": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ProgressStyleModel",
      "state": {
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "ProgressStyleModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "StyleView",
       "bar_color": null,
       "description_width": ""
      }
     },
     "0debf43d9ebe494fa0871bc085432a31": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "HBoxModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "HBoxModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "HBoxView",
       "box_style": "",
       "children": [
        "IPY_MODEL_7ea526b1e9bd43cdb270777b5f62a95e",
        "IPY_MODEL_0539c58479b749dd99898d49f43ebcef",
        "IPY_MODEL_5f80a955ced34cef86bc307a7a17ad50"
       ],
       "layout": "IPY_MODEL_4cea8ab8f6094c87a13a8b690c87c778"
      }
     },
     "106409d46bfe43f19cfedaa975ba2cc8": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "HBoxModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "HBoxModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "HBoxView",
       "box_style": "",
       "children": [
        "IPY_MODEL_79579de4686940fb87277980fb3b9033",
        "IPY_MODEL_1ee9a30ab6f14e9f890b0bc1aabad3db",
        "IPY_MODEL_60a533bb74804344b7e871fbf50d7630"
       ],
       "layout": "IPY_MODEL_b810367f103a4e4e9c5be322df67d4c9"
      }
     },
     "137e5d876fda44a481e04a46ce3d52c5": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "1ee9a30ab6f14e9f890b0bc1aabad3db": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "FloatProgressModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "FloatProgressModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "ProgressView",
       "bar_style": "success",
       "description": "",
       "description_tooltip": null,
       "layout": "IPY_MODEL_896278c20baf49bc9483c86dbe28e6db",
       "max": 1,
       "min": 0,
       "orientation": "horizontal",
       "style": "IPY_MODEL_214ce6435877469e8aec9b089f0a5b2b",
       "value": 1
      }
     },
     "214ce6435877469e8aec9b089f0a5b2b": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ProgressStyleModel",
      "state": {
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "ProgressStyleModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "StyleView",
       "bar_color": null,
       "description_width": ""
      }
     },
     "22828e38a6f84e388c66ed37fd49e1a3": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "2476936f36354c0582cf209811858769": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ProgressStyleModel",
      "state": {
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "ProgressStyleModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "StyleView",
       "bar_color": null,
       "description_width": ""
      }
     },
     "3047235624bd4df4b992d459afbad807": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "3c0e879486d5463db0fa09977f4f5e7b": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "421538af4b344eb285a1049283fceb43": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "4cea8ab8f6094c87a13a8b690c87c778": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "59f46be901ef49cea5e361a23bc258f0": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "5f80a955ced34cef86bc307a7a17ad50": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "HTMLModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "HTMLModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "HTMLView",
       "description": "",
       "description_tooltip": null,
       "layout": "IPY_MODEL_c800f4d86d7f4cb595f97bdd36d14c8f",
       "placeholder": "​",
       "style": "IPY_MODEL_ebd7ac3b623a410a88be5c4d72e48986",
       "value": " 1/1 [00:00&lt;00:00,  1.66it/s]"
      }
     },
     "5faebb75f07148fca515e5e4d72a9e26": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "60a533bb74804344b7e871fbf50d7630": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "HTMLModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "HTMLModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "HTMLView",
       "description": "",
       "description_tooltip": null,
       "layout": "IPY_MODEL_3c0e879486d5463db0fa09977f4f5e7b",
       "placeholder": "​",
       "style": "IPY_MODEL_98f6f531ccd643d09a69140d13b76379",
       "value": " 1/1 [00:02&lt;00:00,  2.40s/it]"
      }
     },
     "6379beb1c16740269e13f8731b3b5f8b": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "HBoxModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "HBoxModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "HBoxView",
       "box_style": "",
       "children": [
        "IPY_MODEL_837225552aef4717b0ab001ff292f72d",
        "IPY_MODEL_997750a67ac645548adf9d6cc5a2c1dd",
        "IPY_MODEL_bd972d756dfe46978be7bb973f690392"
       ],
       "layout": "IPY_MODEL_ab6133b8ef4f45cfa84344f070d4447f"
      }
     },
     "731d09ee1159493095283eac20e86c4d": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "FloatProgressModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "FloatProgressModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "ProgressView",
       "bar_style": "success",
       "description": "",
       "description_tooltip": null,
       "layout": "IPY_MODEL_5faebb75f07148fca515e5e4d72a9e26",
       "max": 17,
       "min": 0,
       "orientation": "horizontal",
       "style": "IPY_MODEL_2476936f36354c0582cf209811858769",
       "value": 17
      }
     },
     "74d2f123669f4151bf9fd59456f355ba": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "HBoxModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "HBoxModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "HBoxView",
       "box_style": "",
       "children": [
        "IPY_MODEL_a06bfab18f1d49a6a4c0a87c360992c8",
        "IPY_MODEL_731d09ee1159493095283eac20e86c4d",
        "IPY_MODEL_cbd80b044afc4e96b1667ab76a3a1f74"
       ],
       "layout": "IPY_MODEL_7a11aa9b2ecb445a8fc14cc89f06ea13"
      }
     },
     "79579de4686940fb87277980fb3b9033": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "HTMLModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "HTMLModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "HTMLView",
       "description": "",
       "description_tooltip": null,
       "layout": "IPY_MODEL_b0c4c0c11c45494db725902cd5bfb08c",
       "placeholder": "​",
       "style": "IPY_MODEL_f53f890fe98e493a96efcc400345b6b2",
       "value": "Generate report structure: 100%"
      }
     },
     "7a11aa9b2ecb445a8fc14cc89f06ea13": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "7ea526b1e9bd43cdb270777b5f62a95e": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "HTMLModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "HTMLModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "HTMLView",
       "description": "",
       "description_tooltip": null,
       "layout": "IPY_MODEL_ca8a709aac3f4afe9aac06b72112076f",
       "placeholder": "​",
       "style": "IPY_MODEL_c33355f13dfd4f4599031ef8f8db5f53",
       "value": "Render HTML: 100%"
      }
     },
     "837225552aef4717b0ab001ff292f72d": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "HTMLModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "HTMLModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "HTMLView",
       "description": "",
       "description_tooltip": null,
       "layout": "IPY_MODEL_59f46be901ef49cea5e361a23bc258f0",
       "placeholder": "​",
       "style": "IPY_MODEL_a4c35dfafabb40199a5c4c0ce5a14b0c",
       "value": "Export report to file: 100%"
      }
     },
     "896278c20baf49bc9483c86dbe28e6db": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "98f6f531ccd643d09a69140d13b76379": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "DescriptionStyleModel",
      "state": {
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "DescriptionStyleModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "StyleView",
       "description_width": ""
      }
     },
     "997750a67ac645548adf9d6cc5a2c1dd": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "FloatProgressModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "FloatProgressModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "ProgressView",
       "bar_style": "success",
       "description": "",
       "description_tooltip": null,
       "layout": "IPY_MODEL_3047235624bd4df4b992d459afbad807",
       "max": 1,
       "min": 0,
       "orientation": "horizontal",
       "style": "IPY_MODEL_f71a3435837f4fdd8eee21023f928dc2",
       "value": 1
      }
     },
     "a06bfab18f1d49a6a4c0a87c360992c8": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "HTMLModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "HTMLModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "HTMLView",
       "description": "",
       "description_tooltip": null,
       "layout": "IPY_MODEL_137e5d876fda44a481e04a46ce3d52c5",
       "placeholder": "​",
       "style": "IPY_MODEL_a757f29997924f8d97c5b33d53a151cd",
       "value": "Summarize dataset: 100%"
      }
     },
     "a4c35dfafabb40199a5c4c0ce5a14b0c": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "DescriptionStyleModel",
      "state": {
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "DescriptionStyleModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "StyleView",
       "description_width": ""
      }
     },
     "a757f29997924f8d97c5b33d53a151cd": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "DescriptionStyleModel",
      "state": {
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "DescriptionStyleModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "StyleView",
       "description_width": ""
      }
     },
     "ab6133b8ef4f45cfa84344f070d4447f": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "b0c4c0c11c45494db725902cd5bfb08c": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "b810367f103a4e4e9c5be322df67d4c9": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "bd972d756dfe46978be7bb973f690392": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "HTMLModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "HTMLModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "HTMLView",
       "description": "",
       "description_tooltip": null,
       "layout": "IPY_MODEL_22828e38a6f84e388c66ed37fd49e1a3",
       "placeholder": "​",
       "style": "IPY_MODEL_ca9b1619f3f348178c14a36e88ae3d9b",
       "value": " 1/1 [00:00&lt;00:00, 33.29it/s]"
      }
     },
     "c33355f13dfd4f4599031ef8f8db5f53": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "DescriptionStyleModel",
      "state": {
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "DescriptionStyleModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "StyleView",
       "description_width": ""
      }
     },
     "c800f4d86d7f4cb595f97bdd36d14c8f": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "ca8a709aac3f4afe9aac06b72112076f": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "ca9b1619f3f348178c14a36e88ae3d9b": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "DescriptionStyleModel",
      "state": {
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "DescriptionStyleModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "StyleView",
       "description_width": ""
      }
     },
     "cbd80b044afc4e96b1667ab76a3a1f74": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "HTMLModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "HTMLModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "HTMLView",
       "description": "",
       "description_tooltip": null,
       "layout": "IPY_MODEL_421538af4b344eb285a1049283fceb43",
       "placeholder": "​",
       "style": "IPY_MODEL_03486abb248b48dcae43183c9ffb112a",
       "value": " 17/17 [00:05&lt;00:00,  2.09it/s, Completed]"
      }
     },
     "d097f3c35ec644bfa231be2d2fd50129": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "ebd7ac3b623a410a88be5c4d72e48986": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "DescriptionStyleModel",
      "state": {
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "DescriptionStyleModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "StyleView",
       "description_width": ""
      }
     },
     "f53f890fe98e493a96efcc400345b6b2": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "DescriptionStyleModel",
      "state": {
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "DescriptionStyleModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "StyleView",
       "description_width": ""
      }
     },
     "f71a3435837f4fdd8eee21023f928dc2": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ProgressStyleModel",
      "state": {
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "ProgressStyleModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "StyleView",
       "bar_color": null,
       "description_width": ""
      }
     }
    },
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}