Snowflake APAC Python VHOLS.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "1053bb77",
   "metadata": {},
   "source": [
    "# Snowflake APAC Python VHOLS - July 2022\n",
    "\n",
    "Welcome and thanks for joining us! \n",
    "\n",
    "This session is focused on:\n",
    "- An initial introduction and walkthrough Snowpark - how to use it from a local perspective, and how to use it to interact with Python in Snowflake itself\n",
    "- Simple connectivity, data engineering and machine learning in Snowflake\n",
    "- Seeing how Snowpark can help us quickly and easily get started analysing and using data\n",
    "\n",
    "What we're not doing today:\n",
    "- Going deep on ML algorithms and training hyper-accurate models - would take too long for this session\n",
    "- Building a machine learning pipeline\n",
    "- Detailed Streamlit usage\n",
    "- Using massive data\n",
    "\n",
    "I'd love to run through these pieces, but they're deeper than we have time for today - especially if we try to leave room for questions! If you'd like to go deeper on these aspects, there is an excellent quickstart that we ran at the recent Snowflake Summit 2022 - you can check it out at https://quickstarts.snowflake.com/guide/machine_learning_with_snowpark_python/index.html. \n",
    "\n",
    "If you'd like to learn more about Streamlit, you can check out our Quickstart at https://quickstarts.snowflake.com/guide/getting_started_with_snowpark_for_python_streamlit/index.html\n",
    "\n",
    "(I'm not using massive data because I happened to choose a relatively small dataset - this is also a little easier to manipulate for those of you working from home!)\n",
    "\n",
    "## Agenda\n",
    "\n",
    "Today we will be using Snowflake to (try to) build and explore a model of how weather affects pedestrian patterns in the Melbourne CBD. We'll go through the following steps:\n",
    "\n",
    "1. Setup - getting connected to Snowflake through the Snowpark API, some basics, and double checking that our environment is workable.\n",
    "\n",
    "2. Collecting data in my Jupyter notebook (weather data) and converting it to Snowpark.\n",
    "\n",
    "3. Collecting data from an S3 bucket and connecting that to Snowpark.\n",
    "\n",
    "4. Local Machine Learning using Snowpark's dataframes to prepare the data.\n",
    "\n",
    "5. Exploration of Python UDFs - different ways of running Python code within the Snowflake parallel compute environment\n",
    "\n",
    "6. Using a Python UDF to train my model in Snowflake\n",
    "\n",
    "7. Using a Python UDF to run my model in Snowflake\n",
    "\n",
    "8. Using Streamlit to connect to Snowflake and explore the model vs the actuals."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "abecebec",
   "metadata": {},
   "source": [
    "# Step 1: Setup + Connecting to Snowflake"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3eecfb27",
   "metadata": {},
   "outputs": [],
   "source": [
    "from snowflake.snowpark.session import Session\n",
    "from snowflake.snowpark.functions import col, sql_expr, to_timestamp\n",
    "from snowflake.snowpark.exceptions import SnowparkSQLException\n",
    "from snowflake.snowpark.types import TimestampType, DecimalType, StructType, StructField\n",
    "import pandas as pd\n",
    "from meteostat import Point, Hourly\n",
    "from datetime import datetime \n",
    "import matplotlib.pyplot as plt\n",
    "import requests\n",
    "import json\n",
    "from pprint import pprint"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f872d33d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# fill your connection details into secrets.json - use secrets_FILL_ME_IN.json as the template\n",
    "try:\n",
    "    with open('./secrets.json','r') as secrets_file:\n",
    "        secrets = json.load(secrets_file)\n",
    "except FileNotFoundError:\n",
    "    print(\"Please put your Snowflake connection details into a secrets.json file in the working directory.\")\n",
    "    \n",
    "if secrets[\"snowflake\"][\"account\"] == \"YOUR_ACCOUNT_HERE\":\n",
    "    print(\"Please fill in the secrets into the file!\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "685d91fb",
   "metadata": {},
   "outputs": [],
   "source": [
    "session = Session.builder.configs(secrets[\"snowflake\"]).create()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0864ddf0",
   "metadata": {},
   "source": [
    "Let's take a quick look at one of the key differences between the Snowflake Connector for Python and the Snowflake Snowpark Python methods for querying data. To start, let's use the underlying connector for the session to run a query:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "640af0c4",
   "metadata": {},
   "outputs": [],
   "source": [
    "session._conn._conn.cursor().execute(\"select current_warehouse(), current_database(), current_schema()\").fetchone()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de85f160",
   "metadata": {},
   "source": [
    "Notice that the SQL is run immediately, and that it is returned (using `fetchone`, at least) immediately as a tuple. The Snowflake Connector for Python will also let us return multiple records using `fetchmany` and `fetchall`, or Pandas/Arrow dataframes using `fetch_pandas_batches`, `fetch_pandas_all`, `fetch_arrow_all`, or `fetch_arrow_batches`, but no matter what, `execute` will immediately run the statement. \n",
    "\n",
    "_Also note: the underscore preceeding the `_conn` objects indicates that this is a private API; while you **can** call it, you probably shouldn't, as it's not supported and might change at any time. Instead, spin up a separate connection instance from the regular Snowflake Connector for Python API if you need one._\n",
    "\n",
    "Now, let's run the same statement, but with the Snowpark session API:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "241af9ea",
   "metadata": {},
   "outputs": [],
   "source": [
    "session.sql(\"select current_warehouse(), current_database(), current_schema()\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a4fd1adf",
   "metadata": {},
   "source": [
    "_This didn't run._ Check your query history if you don't believe me! This is because Snowpark uses _lazy execution_, which means it won't run a query until it has to. To force the query to run so that we can check it works, we can use `collect` (or `show` if we want it nicely formatted):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7edce52c",
   "metadata": {},
   "outputs": [],
   "source": [
    "session.sql(\"select current_warehouse(), current_database(), current_schema()\").collect()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f1c0d5ed",
   "metadata": {},
   "outputs": [],
   "source": [
    "session.sql(\"select current_warehouse(), current_database(), current_schema()\").show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec9c3269",
   "metadata": {},
   "source": [
    "The following is a little bit of setup code - we need a sandbox environment in which to do our work."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "279d5cad",
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "import warnings\n",
    "\n",
    "# convert usernames with anything that's not alphanumeric to be an underscore\n",
    "safe_user = re.sub(\"[^0-9a-zA-Z]+\",'_',secrets[\"snowflake\"][\"user\"])\n",
    "\n",
    "# create the warehouse defined in the secrets file if it didn't exist already\n",
    "session.sql(f\"CREATE WAREHOUSE IF NOT EXISTS {secrets['snowflake']['warehouse']} INITIALLY_SUSPENDED = TRUE;\").collect()\n",
    "\n",
    "# create the database defined in the secrets file if it didn't exist already\n",
    "session.sql(f\"CREATE DATABASE IF NOT EXISTS {secrets['snowflake']['database']};\").collect()\n",
    "session.sql(f\"USE DATABASE {secrets['snowflake']['database']};\").collect()\n",
    "\n",
    "# check to see if a schema already exists for this lab - either the one defined in the secrets file, or \n",
    "# (if we have to create one), that but with the safe username appended so as not to stomp on others in the same env.\n",
    "if session.sql(f\"SHOW SCHEMAS;\").filter((f'''upper(\"name\")=upper('{secrets[\"snowflake\"][\"schema\"]}')\n",
    "                                     or (upper(\"name\")=upper('{secrets[\"snowflake\"][\"schema\"]}_{safe_user}')) '''))\\\n",
    ".count() == 0:\n",
    "    session.sql(f'CREATE SCHEMA {secrets[\"snowflake\"][\"schema\"]}_{safe_user}').collect()\n",
    "\n",
    "try:\n",
    "    session.sql(f'USE SCHEMA {secrets[\"snowflake\"][\"schema\"]}').collect();\n",
    "except SnowparkSQLException:\n",
    "    session.sql(f'USE SCHEMA {secrets[\"snowflake\"][\"schema\"]}_{safe_user}').collect()\n",
    "\n",
    "    \n",
    "# check that this all worked.\n",
    "session.sql(\"select current_warehouse(), current_database(), current_schema()\").show()"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "4e408ce9",
   "metadata": {},
   "source": [
    "If your output looks similar to the below, you're ready to go! If you see \"None\" for any of the values, you need to ensure that you have either already got a Virtual Warehouse, Database and Schema that match the configurations in secrets.json, or a role with the ability to create them. \n",
    "\n",
    "**Note: a red ERROR is fine, so long as the output from show() is good.**\n",
    "\n",
    "![image.png](attachment:image.png)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd5696e0",
   "metadata": {},
   "source": [
    "The below code checks to see if you can run Anaconda packages in your organisation. If you can't, you will need your orgadmin to perform the instructions at https://docs.snowflake.com/en/developer-guide/udf/python/udf-python-packages.html#using-third-party-packages-from-anaconda. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7925d719",
   "metadata": {},
   "outputs": [],
   "source": [
    "from snowflake.snowpark.functions import udf\n",
    "try:\n",
    "    # check to see if we can use Anaconda packages\n",
    "    @udf(packages=[\"scikit-learn\"], session=session)\n",
    "    def check_anaconda() -> list:\n",
    "        import sklearn as sk\n",
    "        return [sk.__version__]\n",
    "\n",
    "    print(session.sql('SELECT 1').select(check_anaconda()).collect())\n",
    "    can_run_anaconda = True\n",
    "\n",
    "except SnowparkSQLException:\n",
    "    # cannot run anaconda packages\n",
    "    print(\"You will need to follow the instructions at https://docs.snowflake.com/en/developer-guide/udf/python/udf-python-packages.html#using-third-party-packages-from-anaconda.\")\n",
    "    print(\"This will require Orgadmin access - if you don't have this access, contact your Snowflake administrator.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ee771c7",
   "metadata": {},
   "source": [
    "# Step 2: Get Weather Data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "432f7695",
   "metadata": {},
   "source": [
    "We use a library here known as [meteostat](https://meteostat.net/en/), which provides data from a number of weather data sources. It's very good for quick work, but there are data quality issues. If you want a better source of data that's just as easy to get access to, it's worth checking out the providers on the [Snowflake Data Marketplace](https://www.snowflake.com/marketplace/)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2fb984fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "start = datetime(2019, 1, 1)\n",
    "end = datetime(2022, 6, 30)\n",
    "\n",
    "melbourne = Point(-37.8136, 144.9631)\n",
    "melair = Hourly(94866, start, end).fetch() # Melbourne Airport\n",
    "\n",
    "# For some reason, meteostat only grabs full years if they're available, so we get the dailies for this year also\n",
    "melair2 = Hourly(94866, datetime(2022,1,1), datetime(2022,6,30)).fetch() \n",
    "\n",
    "melair = pd.concat([melair,melair2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "409d69f1",
   "metadata": {},
   "outputs": [],
   "source": [
    "melair = melair.reset_index()\n",
    "melair"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a33e547c",
   "metadata": {},
   "source": [
    "Now we have a _Pandas_ dataframe, but we want to work with this data in Snowflake - we need a Snowpark dataframe; the two are different! Fortunately, this is an easy conversion:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cb593ae6",
   "metadata": {},
   "outputs": [],
   "source": [
    "melair_weather = session.create_dataframe(melair)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "99dafbaf",
   "metadata": {},
   "source": [
    "#### The difference between `write_pandas` and `create_dataframe`\n",
    "There are two Snowpark functions that allow you to create a Snowpark object from a Pandas dataframe: `write_pandas` and `create_dataframe`. The main difference is that `write_pandas` creates a permanent table for the data to live in, while `create_dataframe`, by default, will create a temporary table that gets deleted at the end of the session. We use `create_dataframe` here for the sake of repeatability and because the amount of data is small. If the data were larger, we might consider creating a permanent table for it with `write_pandas`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "93ef9228",
   "metadata": {},
   "outputs": [],
   "source": [
    "melair_weather.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a6480d4",
   "metadata": {},
   "source": [
    "# Step 3: Get Pedestrian Count Data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42e9fdbd",
   "metadata": {},
   "source": [
    "Today's session uses data from the City of Melbourne, specifically Pedestrian Counts from various pedestrian sensors around the city. To start with, we can use the below code to get the data directly from their API. I encourage you to explore this method following the lab. \n",
    "\n",
    "However, it's probably better for now that we don't all hit the API at once for some 500MB of data, so I've rehosted it in S3. We can use Snowflake External Stages to get that data and load it into a dataframe directly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c3fe067e",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sodapy import Socrata\n",
    "from os import path, remove\n",
    "import pickle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1cb6bd60",
   "metadata": {},
   "outputs": [],
   "source": [
    "# To get an API Key for Socrata, please see: https://support.socrata.com/hc/en-us/articles/210138558-Generating-an-App-Token\n",
    "\n",
    "# Note: this downloads approximately 300-500MB of data to the local machine. \n",
    "# If this machine is on a metered or slow connection, please set METERED_CONNECTION to True. \n",
    "# You will skip downloading the data locally, but this is not required for the rest of the lab.\n",
    "\n",
    "# This data is made available under CC BY 4.0 by the City of Melbourne from \n",
    "# https://data.melbourne.vic.gov.au/Transport/Pedestrian-Counting-System-Monthly-counts-per-hour/b2ak-trbp\n",
    "\n",
    "METERED_CONNECTION = True\n",
    "\n",
    "if not METERED_CONNECTION:\n",
    "    client = Socrata(\"data.melbourne.vic.gov.au\", secrets['socrata']['app_key'])\n",
    "    file_name = 'melbourne_pedestrian_counts.pkl'\n",
    "\n",
    "\n",
    "    if not path.isfile(f'./{file_name}'):\n",
    "        results = list(client.get_all(\"b2ak-trbp\",limit=50000, where=\"date_time >= '2019-01-01T00:00:00'\"))\n",
    "        try:\n",
    "            with open(f'./{file_name}', 'wb') as pkl:\n",
    "                pickle.dump(results, pkl)\n",
    "        except:\n",
    "            remove(f'./{file_name}')\n",
    "            raise\n",
    "    else:\n",
    "        with open(f'./{file_name}', 'rb') as pkl: \n",
    "            results = pickle.load(pkl)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "61da35f2",
   "metadata": {},
   "source": [
    "We could convert the above to a Pandas or Snowpark dataframe relatively easily, but that would require everyone in the lab hitting the Socrata API endpoint at once, which is probably not very friendly and would make you all wait for a 500MB download. Instead, this data is available on S3; let's put it straight into Snowflake from there, using a `stage` object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1e17a5b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "session.sql(\"CREATE STAGE IF NOT EXISTS python_vhols url='s3://melbourne-cc-pedestrian-counts-json' file_format = (type=JSON STRIP_OUTER_ARRAY=TRUE)\").collect()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "881b3231",
   "metadata": {},
   "source": [
    "The data in this stage is JSON data, let's take a look:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "254bb8e1",
   "metadata": {},
   "outputs": [],
   "source": [
    "pedestrian_counts = session.read.option(\"STRIP_OUTER_ARRAY\", True).json(\"@python_vhols\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c859da06",
   "metadata": {},
   "source": [
    "That was fast! Except... it didn't run! Remember: lazy execution!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5e8daf1d",
   "metadata": {},
   "outputs": [],
   "source": [
    "pedestrian_counts.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d608de8",
   "metadata": {},
   "source": [
    "Now we have data from a stage in my dataframe, let's transform it into tabular data, and put it into a table for later use:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2d10d049",
   "metadata": {},
   "outputs": [],
   "source": [
    "def cast_check(value):\n",
    "    try:\n",
    "        datetime.strptime(value+\"000\",\"%Y-%m-%dT%H:%M:%S.%f\")\n",
    "        return \"::timestamp\"\n",
    "    except:\n",
    "        pass\n",
    "    try:\n",
    "        float(value)\n",
    "        return \"::decimal\"\n",
    "    except:\n",
    "        pass\n",
    "    return \"\"\n",
    "\n",
    "# 1. Get the first record from Snowflake. \n",
    "column_headers = list(json.loads(pedestrian_counts.limit(1).collect()[0]['$1']).items())\n",
    "\n",
    "# 2. Pretty print it so that we can see it - notice everything is a string; this is an issue in source.\n",
    "pprint(column_headers)\n",
    "\n",
    "# 3. Use the cast_check method above to generate the right casts for each column.\n",
    "pedestrian_counts = pedestrian_counts.select([sql_expr(f\"$1:{x}{cast_check(y)} {x}\") for x,y in column_headers])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a43885b5",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "pedestrian_counts.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c77572f",
   "metadata": {},
   "source": [
    "This is kind of ugly, but luckily, it's very easy to bring it back into Pandas for pretty display:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dc5e1c58",
   "metadata": {},
   "outputs": [],
   "source": [
    "pedestrian_counts.limit(10).to_pandas()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b1eb4da1",
   "metadata": {},
   "source": [
    "Now I have my transform the way that I want it, I can write this to a table of its own:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f8ec4bf8",
   "metadata": {},
   "outputs": [],
   "source": [
    "pedestrian_counts.write.mode(\"overwrite\").save_as_table(\"pedestrian_counts\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c2e8e72a",
   "metadata": {},
   "outputs": [],
   "source": [
    "session.table(\"pedestrian_counts\").count()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50752d13",
   "metadata": {},
   "source": [
    "And that's it! I've loaded my pedestrian counts from a stage into a Snowflake table."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f60c9cb7",
   "metadata": {},
   "source": [
    "# Step 4: Simple ML"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad8bb458",
   "metadata": {},
   "source": [
    "We're now going to build an _exceedingly simple_ model based on Scikit Learn's Linear Regression model. Scikit Learn is not the only machine learning / AI package supported in Snowflake, however - it's just one of many. The full list can be found at the [Anaconda Snowpark Channel](https://repo.anaconda.com/pkgs/snowflake/), and include:\n",
    "\n",
    "- Spacy (Natural Language Processing)\n",
    "- Keras\n",
    "- Tensorflow\n",
    "- XGBoost\n",
    "- Pytorch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e7c8279d",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn import linear_model"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a480b5d",
   "metadata": {},
   "source": [
    "The first thing I need to do is get the pedestrian counts from the table I created earlier. Let's start by looking at just one sensor's worth of data. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fe8bb0a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "melb_central = session.table(\"pedestrian_counts\").filter(col(\"sensor_name\") == \"Melbourne Central-Elizabeth St (East)\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f78423b0",
   "metadata": {},
   "outputs": [],
   "source": [
    "melb_central.limit(10).to_pandas()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba6ed5f0",
   "metadata": {},
   "source": [
    "Now, let's join this data to the weather details from Melbourne Airport.\n",
    "Notice we join _dataframes_ here. Although in this instance they're very similar to tables, this makes it easy to join dataframes that have a heavy set of transformations applied."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e13914c9",
   "metadata": {},
   "outputs": [],
   "source": [
    "joined = melb_central.join(melair_weather, \n",
    "                           ((to_timestamp(melair_weather.col('\"time\"'),6))==melb_central.col(\"date_time\")))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "716965f4",
   "metadata": {},
   "outputs": [],
   "source": [
    "joined.limit(10).to_pandas()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a245c867",
   "metadata": {},
   "source": [
    "This is a little unwieldy - let's cut down to only the columns we need to train with."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "23d33074",
   "metadata": {},
   "outputs": [],
   "source": [
    "joined = joined.select(col('hourly_counts'), col('time'), col('\"temp\"'), col('\"dwpt\"'), col('\"rhum\"'), col('\"wspd\"'))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "62e10367",
   "metadata": {},
   "source": [
    "Now, let's convert the dataframe to a Pandas dataframe for use in training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "36d5d2a5",
   "metadata": {},
   "outputs": [],
   "source": [
    "pd_joined = joined.to_pandas()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d7799864",
   "metadata": {},
   "outputs": [],
   "source": [
    "pd_joined"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e979497e",
   "metadata": {},
   "source": [
    "Finally, let's use half the dataset as a training set and the other half for testing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "98acf106",
   "metadata": {},
   "outputs": [],
   "source": [
    "y = pd_joined[\"HOURLY_COUNTS\"]\n",
    "x = pd_joined.copy().drop(\"HOURLY_COUNTS\",axis=1)\n",
    "x_training = x[:38712//2]\n",
    "x_test = x[38712//2:]\n",
    "y_training = y[:38712//2]\n",
    "y_test = y[38712//2:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fa35e11c",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn import linear_model\n",
    "regr = linear_model.LinearRegression()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a4b0cd95",
   "metadata": {},
   "outputs": [],
   "source": [
    "regr.fit(x_training.to_numpy(), y_training.to_numpy())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "88960963",
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred = regr.predict(x_test.to_numpy())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "50305f43",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import mean_squared_error, r2_score\n",
    "print(\"Coefficients: \\n\", regr.coef_)\n",
    "# The mean squared error\n",
    "print(\"Mean squared error: %.2f\" % mean_squared_error(y_test, y_pred))\n",
    "# The coefficient of determination: 1 is perfect prediction\n",
    "print(\"Coefficient of determination: %.2f\" % r2_score(y_test, y_pred))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5289a52b",
   "metadata": {},
   "source": [
    "### To be clear, this is not a great model.\n",
    "There are a number of potential reasons this is bad, including the COVID-19 related lockdowns that happened in Melbourne throughout the training period. For now, let's move on and deploy version 0.1. \n",
    "\n",
    "## Parallelising the training\n",
    "Snowpark goes beyond simply allowing us to run Snowflake's functions in dataframes - we can define our own as well. These work as UDFs in the Snowflake engine. This will allow us to take the code we've run above and deploy it to Snowflake rather than running it locally, which means we can parallelise it using Snowflake's virtual warehouses. \n",
    "\n",
    "There are a couple of ways to create Python User Defined Functions (UDF) from Snowpark - let's start by looking through them."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27e49cae",
   "metadata": {},
   "source": [
    "### Temporary Anonymous  (Session Local) UDFs\n",
    "Here we create a temporary session-local UDF (similar to a temporary table) that you can call from here, but you won't be able to use it later. Best for testing or very quick elements that you won't want later. Note that it's best practice, but not _required_, to set the session variable as you can see below. Otherwise, if you have multiple sessions active, you're essentially asking Snowpark to guess which one to add it to - this doesn't work and will throw an exception. In a notebook environment like this one, this is most likely to occur when you have the notebook open for a long time and the Snowflake session times out so you have to re-authenticate it. Ask me how I know."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1af522b2",
   "metadata": {},
   "outputs": [],
   "source": [
    "from snowflake.snowpark.functions import udf\n",
    "from snowflake.snowpark.types import StringType"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6f631cfe",
   "metadata": {},
   "outputs": [],
   "source": [
    "# This implementation of pig latin is, er, non-traditional. Don't worry about it.\n",
    "\n",
    "pig_latin = udf(lambda x: ' '.join([y[-2:]+y[:-2]+'ay' for y in x.split()]), \n",
    "                return_type=StringType(), input_types=[StringType()], session=session)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "045d566a",
   "metadata": {},
   "source": [
    "A couple of things to take note of - one, I use a lambda function here, but that's not necessary; we can use any type of Python function just fine. Two, we must define the return type, and the input types. As this is a _scalar_ UDF, there is only one return type - we'll come back to this later. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "71e24321",
   "metadata": {},
   "outputs": [],
   "source": [
    "session.table(\"pedestrian_counts\").select(pig_latin('\"SENSOR_NAME\"').as_(\"ORSENSAY_MENAY\")).show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7581fd9f",
   "metadata": {},
   "source": [
    "You can also use the `UDFRegistration` class as below. Note that this is basically the same as using the `udf` function, but you set the session in the instance creation of `UDFRegistration`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9a8f5327",
   "metadata": {},
   "outputs": [],
   "source": [
    "from snowflake.snowpark.udf import UDFRegistration\n",
    "\n",
    "pig_latin2 = UDFRegistration(session=session).register(func = lambda x: ' '.join([y[-2:]+y[:-2]+'ay' for y in x.split()]), \n",
    "                             return_type=StringType(), input_types=[StringType()])\n",
    "\n",
    "session.table(\"pedestrian_counts\").select(pig_latin2('\"SENSOR_NAME\"').as_(\"ORSENSAY_MENAY\")).show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18838900",
   "metadata": {},
   "source": [
    "Last but not least, you can use a decorator and Python 3 type hints to define a udf. Very pythonic!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a13d9c84",
   "metadata": {},
   "outputs": [],
   "source": [
    "@udf(session=session)\n",
    "def pig_latin3(x: str) -> str:\n",
    "    return ' '.join([y[-2:]+y[:-2]+'ay' for y in x.split()])\n",
    "\n",
    "session.table(\"pedestrian_counts\").select(pig_latin3('\"SENSOR_NAME\"').as_(\"ORSENSAY_MENAY\")).show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a7985f4",
   "metadata": {},
   "source": [
    "### Named UDFs\n",
    "Side note: you can also create a session-local named UDF by _not_ setting `is_permanent=True`. This allows you to use the UDF by name if you need to (eg. in direct SQL calls) but without having it stick around. We won't spend any time on that here, but you can if you want to. \n",
    "\n",
    "\n",
    "Note that for a named, permanent UDF, you must supply a stage for us to upload a representation of your code to. The code will live here, so for long term use you probably want to organise this better than we are here. (We'll come back to the \"keeping the code in an internal stage\" part soon.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5318cea1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# We use a table stage here for convenience, but I *don't* recommend that for anything other than very short term use!\n",
    "@udf(session=session, is_permanent=True, name=\"pig_latin\", stage_location=\"@%pedestrian_counts\", replace=True)\n",
    "def pig_latin3(x: str) -> str:\n",
    "    return ' '.join([y[-2:]+y[:-2]+'ay' for y in x.split()])\n",
    "\n",
    "session.sql('SELECT pig_latin(SENSOR_NAME) FROM pedestrian_counts').show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b899443b",
   "metadata": {},
   "source": [
    "### Vectorised UDFs\n",
    "Vectorised (or _vectorized_, if you're following our American spelling) UDFs let you build UDFs that operate over Pandas Dataframes rather than over individual records. This can be _significantly_ faster, particularly for prediction algorithms, but it also means you can easily use algorithms that were built to use dataframes. \n",
    "\n",
    "You create these in the same way you create regular UDFs, but with dataframes or series as the input and return data types. Note the use of the \"max_batch_size\" parameter, which we use to make sure that the UDF returns within 60s (a hard time-out). \n",
    "\n",
    "For more info on the Python UDF Batch API, or Vectorised UDF execution, see: https://docs.snowflake.com/en/developer-guide/udf/python/udf-python-batch.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "70c50205",
   "metadata": {},
   "outputs": [],
   "source": [
    "from snowflake.snowpark.types import PandasSeries\n",
    "\n",
    "@udf(session=session, max_batch_size=1000)\n",
    "def pig_latin_series(series: PandasSeries[str]) -> PandasSeries[str]:\n",
    "    return series.apply(lambda x: ' '.join([y[-2:]+y[:-2]+'ay' for y in x.split()]))\n",
    "\n",
    "\n",
    "#Note: this also works if you use the pd.DataFrame or pd.Series types. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cc6b6e98",
   "metadata": {},
   "outputs": [],
   "source": [
    "session.table(\"pedestrian_counts\").select(pig_latin_series('\"SENSOR_NAME\"').as_(\"ORSENSAY_MENAY\")).show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6073425c",
   "metadata": {},
   "source": [
    "### User Defined Table Functions\n",
    "\n",
    "Last but not least, Python Snowpark also allows you to define User Defined Table Functions. This is a little bit more involved, but _very_ powerful, as with a User Defined Table Function we can control how data is partitioned and passed into the function. To build a UDTF, we need a class with three methods (one non-optional, two optional):\n",
    "1. An `__init__` method that optionally initializes the stateful processing of input,\n",
    "2. A `process` method that processes each row,\n",
    "3. An `end_partition` method that finalises processing of each input partition. \n",
    "\n",
    "A UDTF is _partition-aware_ if it implements the `__init__` and `end_partition` methods. \n",
    "\n",
    "You might see where we're going with this - let's go back to parallelising our training algorithm!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4d2c1264",
   "metadata": {},
   "outputs": [],
   "source": [
    "from snowflake.snowpark.types import StructField, StructType, StringType, IntegerType, FloatType, BinaryType \n",
    "from snowflake.snowpark.functions import udtf, table_function\n",
    "from snowflake.snowpark.exceptions import SnowparkSQLException\n",
    "\n",
    "\n",
    "# Create an internal stage if we don't have one - this holds our code.\n",
    "session.sql(f\"CREATE STAGE IF NOT EXISTS {safe_user}_stg\").collect()\n",
    "\n",
    "# Tell Snowflake what the outputs of this UDTF are (this is referenced in the @udtf decorator below)\n",
    "output_schema = StructType([\n",
    "        StructField(\"sid\", IntegerType()),\n",
    "        StructField(\"model\", BinaryType())\n",
    "    ])\n",
    "\n",
    "# Use the UDTF decorator to mark this as a Snowflake Python UDTF\n",
    "@udtf(output_schema=output_schema, \n",
    "      is_permanent=True, \n",
    "      stage_location=f'{safe_user}_stg',\n",
    "      replace=True,\n",
    "      packages=(\"numpy\", \"scikit-learn\", \"pandas\",\"munch\"),\n",
    "      name=\"linear_regression_trainer_udtf\",\n",
    "      session=session)\n",
    "class linear_regression_trainer:\n",
    "    def __init__(self) -> None:\n",
    "        # we perform initialisation here - simple.\n",
    "        self.x = []\n",
    "        self.y = []\n",
    "        self.sensor_id = None\n",
    "    \n",
    "    \n",
    "    def process(self, hourly_counts: int, hour: int, temp: float, dwpt: float, rhum: float, wspd: float, sensor_id:int) -> list:\n",
    "        # The process method is fairly small here; the actual work is done in end_partition.\n",
    "        # The key is that we store all the data in memory as a list that end_partition will convert to a \n",
    "        # numpy array and pass to scikit.\n",
    "        if self.sensor_id is not None and self.sensor_id != sensor_id:\n",
    "            raise Exception(\"Must partition on sensor_id.\")\n",
    "        if self.sensor_id is None:\n",
    "            self.sensor_id = sensor_id\n",
    "        self.y.append(hourly_counts)\n",
    "        self.x.append([hour, temp, dwpt, rhum, wspd])\n",
    "        return None\n",
    "        \n",
    "    def end_partition(self) -> tuple:\n",
    "        # Here we take the data we collected with process(), convert it to a numpy array and then use it\n",
    "        # to train a linear regression model. Then we dump the model to a Pickle, which we can store in a \n",
    "        # Binary column in Snowflake. \n",
    "        import numpy as np\n",
    "        from sklearn import linear_model\n",
    "        import pickle\n",
    "        x_arr = np.array(x)\n",
    "        y_arr = np.array(y)\n",
    "        regr = linear_model.LinearRegression()\n",
    "        regr.fit(x_arr, y_arr)\n",
    "        \n",
    "        return ((self.sensor_id, pickle.dumps(regr)),)\n",
    "        \n",
    "        \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "419c918c",
   "metadata": {},
   "source": [
    "**To summarise:** the above will take data that has been partitioned by Sensor ID and use it to train a set of models - one model per sensor ID - using Snowflake's parallel compute. There are some limitations to this approach:\n",
    "\n",
    "1. Because we store the data in a Snowflake column, we are limited to the 16MB limit on "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "867062d1",
   "metadata": {},
   "outputs": [],
   "source": [
    "from snowflake.snowpark.functions import lit\n",
    "lrt = table_function(\"linear_regression_trainer_udtf\")\n",
    "#recall that joined is only over one sensor_id\n",
    "joined.join_table_function(lrt(joined[\"HOURLY_COUNTS\"], joined[\"TIME\"], joined['\"temp\"'], \n",
    "                               joined['\"dwpt\"'], joined['\"rhum\"'], joined['\"wspd\"'], lit(1))).show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f21a46d",
   "metadata": {},
   "source": [
    "Ok, we've now run the table function for _one_ sensor id - let's see how to parallelise it. To start with, we'll need an unfiltered dataframe, then we'll partition it by sensor id, and order by date_time within the partition. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "712ff811",
   "metadata": {},
   "outputs": [],
   "source": [
    "ped_counts = session.table(\"pedestrian_counts\")\n",
    "joined = ped_counts.join(melair_weather, ((to_timestamp(melair_weather.col('\"time\"'),6))==ped_counts.col(\"date_time\")))\n",
    "joined = joined.filter(joined[\"date_time\"]<datetime(2021,1,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ca501a8b",
   "metadata": {},
   "outputs": [],
   "source": [
    "joined_lrt = (joined.join_table_function(\n",
    "    lrt(joined[\"HOURLY_COUNTS\"], \n",
    "        joined[\"TIME\"], \n",
    "        joined['\"temp\"'], \n",
    "        joined['\"dwpt\"'], \n",
    "        joined['\"rhum\"'], \n",
    "        joined['\"wspd\"'], \n",
    "        joined[\"sensor_id\"])\n",
    "                           .over(partition_by=\"sensor_id\", order_by=\"date_time\"))\n",
    "    .select(col(\"model\"), col(\"sid\")))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fc246417",
   "metadata": {},
   "outputs": [],
   "source": [
    "joined_lrt.write.mode(\"overwrite\").save_as_table(\"pedestrian_models\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cda537f8",
   "metadata": {},
   "outputs": [],
   "source": [
    "grouped = session.table(\"pedestrian_models\").group_by(\"SID\").count()\n",
    "grouped.sort(col(\"COUNT\").desc()).show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "448af6ad",
   "metadata": {},
   "source": [
    "### Leveraging the models\n",
    "Now we need to leverage the models that we just built, one per sensor ID. This is a perfect time to leverage the vectorised processing we mentioned earlier. As our models are sitting within a single column in our pedestrian models table, we can join that to our pedestrian count table and leverage it in a vectorised process, or we can write another UDTF. Performance-wise, these two options are probably similar at this scale but may differ depending on the number of sensor-ids (ie. partitions) and how well the data is sorted. Let's go ahead and write it as a vectorised UDF. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a835491c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from snowflake.snowpark.types import PandasSeries, PandasDataFrame\n",
    "\n",
    "@udf(session=session, max_batch_size=10000, \n",
    "     name=\"linear_regression_predictor\", is_permanent=True, replace=True, stage_location=\"@%pedestrian_counts\",\n",
    "    packages=[\"numpy\",\"pandas\",\"scikit-learn\", \"dill\", \"munch\"])\n",
    "def linear_regression_predictor(sid: PandasSeries[int], model: PandasSeries[bytes],\n",
    "                               time: PandasSeries[float], temp: PandasSeries[float],\n",
    "                               dwpt: PandasSeries[float], rhum: PandasSeries[float],\n",
    "                               wspd: PandasSeries[float]) -> PandasSeries[float]:\n",
    "    import dill\n",
    "    import munch\n",
    "    import numpy as np\n",
    "    import pandas as pd\n",
    "    # link the models to the sensor ids\n",
    "    models = pd.DataFrame({\"sid\":sid, \"model\":model}).drop_duplicates()\n",
    "    \n",
    "    # unpickle the model back into a Python object\n",
    "    models[\"unpickled\"] = models[\"model\"].apply(lambda x: dill.loads(x))\n",
    "    \n",
    "    # group the data by sensor ID\n",
    "    data = pd.DataFrame({\"sid\":sid, \"time\":time, \"temp\":temp, \"dwpt\":dwpt, \"rhum\":rhum, \"wspd\":wspd}).groupby(\"sid\")\n",
    "    preds = []\n",
    "    for sid_group in data.groups:\n",
    "        df = data.get_group(sid_group)\n",
    "        # get the relevant model\n",
    "        regr = models[models[\"sid\"]==sid_group][\"unpickled\"].iloc[0]\n",
    "        # predict!\n",
    "        prediction = (regr.predict(df.drop(\"sid\", axis=1).to_numpy()))\n",
    "        preds.append(prediction)\n",
    "    return pd.Series(np.concatenate(preds))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7feb99cf",
   "metadata": {},
   "source": [
    "To test that this is being called correctly, we can set up a model for which we know the outputs:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d81acef1",
   "metadata": {},
   "outputs": [],
   "source": [
    "output_schema = StructType([\n",
    "        StructField(\"sid\", IntegerType()),\n",
    "        StructField(\"model\", BinaryType())\n",
    "    ])\n",
    "\n",
    "\n",
    "@udtf(output_schema=output_schema, \n",
    "      is_permanent=True, \n",
    "      stage_location=f'{safe_user}_stg',\n",
    "      replace=True,\n",
    "      packages=(\"numpy\",\"munch\", \"dill\"),\n",
    "      name=\"static_model_udtf\",\n",
    "      session=session)\n",
    "class StaticModel:\n",
    "    def __init__(self) -> None:\n",
    "        self.sensor_id = None    \n",
    "    \n",
    "    def process(self, hourly_counts: int, hour: int, temp: float, dwpt: float, rhum: float, wspd: float, sensor_id:int) -> list:\n",
    "        if self.sensor_id is not None and self.sensor_id != sensor_id:\n",
    "            raise Exception(\"Must partition on sensor_id.\")\n",
    "        if self.sensor_id is None:\n",
    "            self.sensor_id = sensor_id\n",
    "        return None\n",
    "        \n",
    "    def end_partition(self) -> list:\n",
    "        from munch import Munch\n",
    "        import numpy as np\n",
    "        import dill\n",
    "        x = Munch() \n",
    "        x.predict = lambda arr: np.sum(arr, axis=1)\n",
    "        return ((self.sensor_id, dill.dumps(x)),)\n",
    "    \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "21c8dbe8",
   "metadata": {},
   "outputs": [],
   "source": [
    "static_model = table_function(\"static_model_udtf\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "71ab830f",
   "metadata": {},
   "outputs": [],
   "source": [
    "joined_test_models = (joined.join_table_function(\n",
    "    static_model(joined[\"HOURLY_COUNTS\"], \n",
    "        joined[\"TIME\"], \n",
    "        joined['\"temp\"'], \n",
    "        joined['\"dwpt\"'], \n",
    "        joined['\"rhum\"'], \n",
    "        joined['\"wspd\"'], \n",
    "        joined[\"sensor_id\"])\n",
    "                           .over(partition_by=\"sensor_id\", order_by=\"date_time\"))\n",
    "    .select(col(\"model\"), col(\"sid\")))\n",
    "joined_test_models.write.mode(\"overwrite\").save_as_table(\"test_model\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1cd8f734",
   "metadata": {},
   "outputs": [],
   "source": [
    "session.table(\"test_model\").show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5cd2e9bf",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "joined_test = session.table(\"test_model\").join(joined.drop(\"HOURLY_COUNTS\"),col(\"sensor_id\") == col(\"sid\"))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d2894507",
   "metadata": {},
   "outputs": [],
   "source": [
    "joined_test = joined_test.select(col('sid'),\n",
    "                                 col('model'), \n",
    "                                 col('time'), \n",
    "                                 col('\"temp\"'), \n",
    "                                 col('\"dwpt\"'), \n",
    "                                 col('\"rhum\"'), \n",
    "                                 col('\"wspd\"')).sort('sid')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "518b0cf8",
   "metadata": {},
   "outputs": [],
   "source": [
    "joined_test.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cecfb110",
   "metadata": {},
   "outputs": [],
   "source": [
    "from snowflake.snowpark.functions import call_udf, count\n",
    "\n",
    "# Pass in the SID and 4 1s, so the output should always be SID+4.\n",
    "joined_test.select(col(\"sid\"),call_udf(\"linear_regression_predictor\", \n",
    "                                         [col(\"sid\"), col('model'), col(\"sid\"),lit(1.0), lit(1.0),lit(1.0), lit(1.0)])\n",
    "                                         .as_(\"predict\")).write.mode(\"overwrite\").save_as_table(\"test_results\")\n",
    "# make sure we have results\n",
    "session.table('test_results').show()\n",
    "\n",
    "# find any time we got multiple results for the same SID (would indicate the partitioning is wrong)\n",
    "joined_test_multiple_count = (session.table('test_results').distinct()\n",
    "     .group_by(\"SID\")\n",
    "     .count()\n",
    "     .filter(col(\"count\")>1)\n",
    "     .show())\n",
    "\n",
    "# find any time we got a wrong result\n",
    "joined_test_wrong = session.table('test_results').filter(col(\"SID\")+lit(4) != col(\"PREDICT\")).show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c3d9eb5",
   "metadata": {},
   "source": [
    "This looks good! So now, let's go ahead and apply it with the real models!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "94b8988f",
   "metadata": {},
   "outputs": [],
   "source": [
    "ped_counts = session.table(\"pedestrian_counts\")\n",
    "\n",
    "joined = ped_counts.join(melair_weather, \n",
    "                         ((to_timestamp(melair_weather.col('\"time\"'),6))==ped_counts.col(\"date_time\")))\n",
    "\n",
    "joined = joined.filter(joined[\"date_time\"]>datetime(2021,1,1)) #this has been flipped from < to >\n",
    "\n",
    "predictions = session.table(\"pedestrian_models\").join(joined.drop(\"HOURLY_COUNTS\"),col(\"sensor_id\") == col(\"sid\"))\n",
    "\n",
    "predictions.select(col(\"sid\"),col(\"date_time\"), call_udf(\"linear_regression_predictor\", \n",
    "                                         [col(\"sid\"),\n",
    "                                          col('model'), \n",
    "                                          col('time'), \n",
    "                                          col('\"temp\"'), \n",
    "                                          col('\"dwpt\"'), \n",
    "                                          col('\"rhum\"'), \n",
    "                                          col('\"wspd\"')])\n",
    "                                         .as_(\"predict\")).write.mode(\"overwrite\").save_as_table(\"predictions\")\n",
    "session.table('predictions').show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e98004ab",
   "metadata": {},
   "outputs": [],
   "source": [
    "predictions = session.table('predictions')\n",
    "predictions_actuals = (predictions.join(ped_counts, \n",
    "                                       (predictions[\"SID\"]==ped_counts[\"sensor_id\"]) & \n",
    "                                       (predictions[\"DATE_TIME\"]==ped_counts[\"DATE_TIME\"])))\n",
    "predictions_actuals.limit(10).to_pandas()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce5be2f3",
   "metadata": {},
   "source": [
    "# Exploration in Streamlit"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa0bb61d",
   "metadata": {},
   "source": [
    "Streamlit is a tool that lets us very quickly and easily create data driven applications in Python. Let's very quickly take a look at what we can do with it. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f78609cd",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%writefile ./__init__.py\n",
    "\n",
    "pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6080f981",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%writefile ./part_2.py\n",
    "\n",
    "# Stub file. We'll come back to this.\n",
    "\n",
    "def run_part_2(session):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3b241d53",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%writefile ./main.py\n",
    "\n",
    "import streamlit as st\n",
    "from snowflake.snowpark import Session\n",
    "from snowflake.snowpark.functions import col\n",
    "from snowflake.snowpark.exceptions import SnowparkSQLException\n",
    "from part_2 import run_part_2\n",
    "import json\n",
    "import re\n",
    "import warnings\n",
    "\n",
    "# fill your connection details into secrets.json - use secrets_FILL_ME_IN.json as the template\n",
    "try:\n",
    "    with open('./secrets.json','r') as secrets_file:\n",
    "        secrets = json.load(secrets_file)\n",
    "except FileNotFoundError:\n",
    "    print(\"Please put your Snowflake connection details into a secrets.json file in the working directory.\")\n",
    "    \n",
    "if secrets[\"snowflake\"][\"account\"] == \"YOUR_ACCOUNT_HERE\":\n",
    "    print(\"Please fill in the secrets into the file!\")\n",
    "\n",
    "st.set_page_config(\n",
    "     page_title=\"Ex-stream-ly Cool App\",\n",
    "     page_icon=\"❄️\",\n",
    "     layout=\"wide\",\n",
    " )  \n",
    "    \n",
    "\n",
    "session = Session.builder.configs(secrets[\"snowflake\"]).create()\n",
    "\n",
    "safe_user = re.sub(\"[^0-9a-zA-Z]+\",'_',secrets[\"snowflake\"][\"user\"])\n",
    "session.sql(f\"CREATE WAREHOUSE IF NOT EXISTS {secrets['snowflake']['warehouse']} INITIALLY_SUSPENDED = TRUE;\").collect()\n",
    "session.sql(f\"CREATE DATABASE IF NOT EXISTS {secrets['snowflake']['database']};\").collect()\n",
    "session.sql(f\"USE DATABASE {secrets['snowflake']['database']};\").collect()\n",
    "if session.sql(f\"SHOW SCHEMAS;\").filter((f'''upper(\"name\")=upper('{secrets[\"snowflake\"][\"schema\"]}')\n",
    "                                     or (upper(\"name\")=upper('{secrets[\"snowflake\"][\"schema\"]}_{safe_user}')) '''))\\\n",
    ".count() == 0:\n",
    "    session.sql(f'CREATE SCHEMA {secrets[\"snowflake\"][\"schema\"]}_{safe_user}').collect()\n",
    "\n",
    "try:\n",
    "    session.sql(f'USE SCHEMA {secrets[\"snowflake\"][\"schema\"]}').collect();\n",
    "except SnowparkSQLException:\n",
    "    session.sql(f'USE SCHEMA {secrets[\"snowflake\"][\"schema\"]}_{safe_user}').collect()\n",
    "\n",
    "st.title(\"Pedestrian count predictions\")\n",
    "st.write(session.table(\"pedestrian_counts\").select(col(\"sensor_id\"), col(\"sensor_name\")).distinct().sort(col(\"sensor_id\")).to_pandas())\n",
    "\n",
    "run_part_2(session)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "819118b6",
   "metadata": {},
   "source": [
    "### THIS IS NOT A GOOD WAY TO RUN (or develop for) STREAMLIT!\n",
    "I cannot emphasize this enough - we do it here only so that I don't have to mess around screensharing different windows. _You_ should open up a terminal window and execute `streamlit run main.py` there. I had no fewer than 8 zombie streamlit processes running in the background because this is suboptimal (and I forgot to run the kill command). \n",
    "\n",
    "When you're writing streamlit code, it is much easier to use a text editor (such as Sublime Text or VS Code) or an IDE (like PyCharm) than it is to use %%writefile as we do above. Streamlit will even hot reload code for you so you don't have to re-run the execution each time - it's really cool. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cb686f69",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%script sh --bg --proc streamlit_process --err streamlit_err --out streamlit_out\n",
    "streamlit run main.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "99a21d99",
   "metadata": {},
   "outputs": [],
   "source": [
    "streamlit_process.kill()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea24b118",
   "metadata": {},
   "source": [
    "## Visualising our models\n",
    "Let's add a way we can visualise our (beautiful, faultless) models vs the actuals. To start, we want to have a way to select the sensor we're interested in."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f4baefa0",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%writefile ./part_2.py\n",
    "\n",
    "import streamlit as st\n",
    "from snowflake.snowpark.functions import col\n",
    "from snowflake.snowpark.exceptions import SnowparkSQLException\n",
    "import datetime\n",
    "\n",
    "def run_part_2(session):\n",
    "    sensors = session.table(\"pedestrian_counts\").select(col(\"sensor_id\"), col(\"sensor_name\")).sort(col(\"sensor_id\")).distinct()\n",
    "    chosen_sensor = st.selectbox(\"Select a sensor:\",sensors.collect(), format_func = lambda x: x[\"SENSOR_NAME\"])\n",
    "    st.write(chosen_sensor)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98971bb4",
   "metadata": {},
   "source": [
    "Now, we can use Snowpark to get the data, and display it with `st.line_chart`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "866db896",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%writefile -a ./part_2.py\n",
    "    \n",
    "    chosen_sensor_actuals = session.table(\"pedestrian_counts\").filter(col(\"sensor_id\")==chosen_sensor[\"SENSOR_ID\"]).select(col(\"HOURLY_COUNTS\"), col(\"date_time\")).sort(\"date_time\")\n",
    "    chosen_sensor_predictions = session.table(\"predictions\").filter(col(\"sid\")==chosen_sensor[\"SENSOR_ID\"]).select(col(\"predict\"), col(\"date_time\")).sort(\"date_time\")\n",
    "    st.line_chart(data=chosen_sensor_actuals.to_pandas().set_index(\"DATE_TIME\"))\n",
    "    st.line_chart(data=chosen_sensor_predictions.to_pandas().set_index(\"DATE_TIME\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "924bc2ba",
   "metadata": {},
   "source": [
    "It would be nice if we could filter the data down - let's do that with a slider:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "15efcaf3",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%writefile -a ./part_2.py\n",
    "    date_filter = st.slider(\"Filter by date:\", min_value=datetime.date(2020,1,1), max_value=datetime.date(2022,6,1), value=(datetime.date(2020,1,1),datetime.date(2022,6,1)))\n",
    "    chosen_sensor_actuals = session.table(\"pedestrian_counts\").filter(col(\"sensor_id\")==chosen_sensor[\"SENSOR_ID\"]).select(col(\"HOURLY_COUNTS\"), col(\"date_time\")).sort(\"date_time\").filter(col(\"date_time\").between(date_filter[0], date_filter[1]))\n",
    "    chosen_sensor_predictions = session.table(\"predictions\").filter(col(\"sid\")==chosen_sensor[\"SENSOR_ID\"]).select(col(\"predict\"), col(\"date_time\")).sort(\"date_time\").filter(col(\"date_time\").between(date_filter[0], date_filter[1]))\n",
    "    st.line_chart(data=chosen_sensor_actuals.to_pandas().set_index(\"DATE_TIME\"))\n",
    "    st.line_chart(data=chosen_sensor_predictions.to_pandas().set_index(\"DATE_TIME\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0764db6d",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}