team_contributions/cuxfilter-tutorial/cuxfilter_tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "friendly-floating",
   "metadata": {},
   "source": [
    "<img src=\"https://github.com/jupytercon/2020-exactlyallan/raw/master/images/RAPIDS-header-graphic.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "settled-cornwall",
   "metadata": {},
   "source": [
    "# Exploratory Data Visualization with Cuxfilter\n",
    "***Quickly finding linked patterns in your data with cross filtering***\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "advised-globe",
   "metadata": {},
   "source": [
    "## Introduction\n",
    "\n",
    "<img src=\"https://raw.githubusercontent.com/rapidsai/cuxfilter/main/docs/_images/demo.gif\">\n",
    "\n",
    "**Cuxfilter : \"ku-cross-filter\"** <br>\n",
    "Part of **[RAPIDS](https://rapids.ai/)**, **[cuxfilter](https://github.com/rapidsai/cuxfilter)** is a library by the visualization team that enables GPU accelerated cross filtered dashboards in just a few lines of notebook code. You can find a list of features on our **[docs page](https://docs.rapids.ai/api/cuxfilter/stable/)**.\n",
    "\n",
    "Cuxfilter acts as a connector library rather than a visualization chart library. It abstracts away all the 'plumbing' required to inter-connect a **[curated list of visualizations](https://docs.rapids.ai/api/cuxfilter/stable/charts/charts.html)** to a cuDF GPU dataframe. By simply enabling accelerated dashboards within a notebook workflow, cuxfilter allows analysts to get to exploring their data faster.\n",
    "\n",
    "**Part of a Visualization Workflow** <br>\n",
    "A generalized python data visualization workflow invovles performing ETL with cuDF and charting libraries like **[hvplot](https://hvplot.holoviz.org/)** or **[holoviews](http://holoviews.org/)** (part of the great **[HoloViz](https://holoviz.org/)** eco-system), performing more detailed cross-filtered exploration and dashboard prototyping with cuxfilter, and then building stand alone explanatory data visualization appliactions with **[Plotly Dash](https://plotly.com/dash/)**.\n",
    "\n",
    "Illustrating how easy it is to use RAPIDS libraries together, we will use:\n",
    "\n",
    "- **[cuDF](https://docs.rapids.ai/api/cudf/stable/)** a RAPIDS GPU DataFrame library for manipulating data with a pandas-like API.\n",
    "\n",
    "- **[cuGraph](https://docs.rapids.ai/api/cugraph/stable/)** a RAPIDS GPU accelerated graph analytics library with functionality like NetworkX.\n",
    "\n",
    "- **[cuSpatial](https://docs.rapids.ai/api/cusignal/stable/)** a RAPIDS GPU accelerated spatial analytics library used in cuxfilter's geospatial selections tools.\n",
    "\n",
    "**Learn More** <br>\n",
    "To hear more about RAPIDS, visualization, and additional resources, have a listen to our **[RAPIDSFire Podcast](https://anchor.fm/rapidsfire/episodes/Data-Visualization-at-Scale-with-Allan-Enemark-and-Bryan-Van-de-Ven-eq65l5)** or visit the **[RAPIDS Home Page](https://rapids.ai/)**.\n",
    "\n",
    "A more extensive version of this tutorial can be found on our **[RAPIDS Community GitHub](https://github.com/rapidsai-community/showcase/tree/master/event_notebooks/JupyterCon_2020_RAPIDSViz)**.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "naval-seafood",
   "metadata": {},
   "source": [
    "## Installation and Requirements\n",
    "\n",
    "For this tutorial you'll need an NVIDIA GPU with at least 16GB of memory and RAPIDS installed. You can find further requirements and installation instructions on our **[Getting Started Page](https://rapids.ai/start.html)**."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "intense-termination",
   "metadata": {},
   "source": [
    "## Data Download\n",
    "For this tutorial, we are using the **[Divvy Chicago bike share dataset](https://www.divvybikes.com/system-data)** sourced from this **[Kaggle page](https://www.kaggle.com/yingwurenjian/chicago-divvy-bicycle-sharing-data?select=data.csv)**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "acceptable-inspector",
   "metadata": {},
   "outputs": [],
   "source": [
    "from pathlib import Path\n",
    "\n",
    "DATA_DIR = Path(\"./data\")\n",
    "FILENAME = Path(\"data.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "important-japanese",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Download and Extract the dataset\n",
    "! wget -N -P {DATA_DIR} https://data.rapids.ai/viz-data/data.tar.xz\n",
    "! tar -xf {DATA_DIR}/data.tar.xz -C {DATA_DIR}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "perfect-tactics",
   "metadata": {},
   "source": [
    "## Imports\n",
    "Let's first make sure the necessary imports are present to load, as well as setting the data location."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "greater-placement",
   "metadata": {},
   "outputs": [],
   "source": [
    "import cuxfilter\n",
    "import cudf\n",
    "import cugraph\n",
    "from bokeh.models import NumeralTickFormatter\n",
    "from bokeh.palettes import Inferno\n",
    "from pathlib import Path\n",
    "from preprocess import * # for compactness we added functions to preprocess.py\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "excess-viewer",
   "metadata": {},
   "source": [
    "## Load Data Into cuDF and Format Data\n",
    "Load `datda.csv` into the GPU dataframe:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "facial-afternoon",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = cudf.read_csv(DATA_DIR / FILENAME)\n",
    "\n",
    "# Check\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "provincial-wallpaper",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Remove unnessary data and format using the script in preprocess.py\n",
    "trips = process_trips(data)\n",
    "\n",
    "# Check\n",
    "trips.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "global-clause",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a weekday string map\n",
    "days_of_week_map = {\n",
    "    0: 'monday',\n",
    "    1: 'tuesday',\n",
    "    2: 'wednesday',\n",
    "    3: 'thursday',\n",
    "    4: 'friday',\n",
    "    5: 'saturday',\n",
    "    6: 'sunday'\n",
    "}\n",
    "\n",
    "# month map\n",
    "month_map = {\n",
    "    1: 'jan', 2: 'feb', 3: 'mar', 4: 'apr', 5: 'may', 6: 'jun', 7: 'jul', 8: 'aug', 9: 'sep', 10: 'oct', 11: 'nov', 12: 'dec'\n",
    "}\n",
    "\n",
    "# weekend / weekday map\n",
    "day_type_map = {0:'weekday', 1:'weekend', '':'all'}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "intense-consensus",
   "metadata": {},
   "source": [
    "## An Aside  on Cognitive Load  \n",
    "Creating the string maps above is important. To make the dashboard values more *human* understandable, we are creating string maps to convert the dataset's numbers to their proper names. Though it may seem trivial, it removes unnecessary ambiguity and helps **[reduce cognitive load](https://www.nngroup.com/articles/minimize-cognitive-load/)** when our focus needs to be on finding patterns.\n",
    "\n",
    "\n",
    "## An Aside on Preattentive Attributes\n",
    "Preattentive Attributes are a subconcious ability to quickly recognize patterns is due to our brain's natural ability to find **[preattentive attributes](http://daydreamingnumbers.com/blog/preattentive-attributes-example/)**, such as height, orientation, or color. Imagine 100 values in a table and 100 in a bar chart and how quickly you would be albe to find the smallest and largest values in either. This is one key reason visualizations are a powerful mechanism for recognizing patterns."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "lined-design",
   "metadata": {},
   "source": [
    "## Cuxfilter Basic Dashboard, Adding Charts, and Custom Layouts\n",
    "First lets investigate trip totals by varous time slices by linking the dataframe to cuxfilter:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "gothic-command",
   "metadata": {},
   "outputs": [],
   "source": [
    "cux_df = cuxfilter.DataFrame.from_dataframe(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "stuck-television",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Inferno Taken from bokeh color pallettes https://docs.bokeh.org/en/latest/docs/reference/palettes.html\n",
    "colors = Inferno[10]\n",
    "\n",
    "# Specify the charts and widgets to use with the selected columns of data and string maps\n",
    "widget1 = cuxfilter.charts.multi_select('year')\n",
    "widget2 = cuxfilter.charts.multi_select('day_type', label_map=day_type_map)\n",
    "chart1 = cuxfilter.charts.bar('hour', title='trips per hour')\n",
    "chart2 = cuxfilter.charts.bar('month', x_label_map=month_map)\n",
    "chart3 = cuxfilter.charts.bar('day', x_label_map=days_of_week_map)\n",
    "\n",
    "# Update the yaxis ticker to an easily readable format\n",
    "chart1.y_axis_tick_formatter = NumeralTickFormatter(format=\"0,0\")\n",
    "chart2.y_axis_tick_formatter = NumeralTickFormatter(format=\"0,0\")\n",
    "chart3.y_axis_tick_formatter = NumeralTickFormatter(format=\"0,0\")\n",
    "\n",
    "\n",
    "# TRY:\n",
    "# Add chart: \n",
    "# chart4 = cuxfilter.charts.datashader.heatmap(x='hour', y='day', aggregate_col='hour', point_shape='rect_horizontal', point_size=10, color_palette=colors)\n",
    "\n",
    "# TRY:\n",
    "# Use custom layout with `layout_array` parameter:\n",
    "layout_array = [[1, 2], [3, 2]\n",
    "\n",
    "# Preset layout with `layout` parameter\n",
    "# layout = cuxfilter.layouts.feature_and_double_base\n",
    "\n",
    "# Generate the dashboard and select a layout\n",
    "d = cux_df.dashboard([chart1, chart2, chart3, chart4], sidebar=[widget1, widget2], layout_array=layout_array, title='Bike Trips Dashboard')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "chronic-folder",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Start the dashboard, a green button should appear to open one in a new tab.\n",
    "# NOTE: use the slider below each chart to cross filter.\n",
    "\n",
    "# IMPORTANT: replace notebook_url with your jupyterhub/binder base url\n",
    "# IMPORTANT: if your notebook environment is in jupyterhub, set service_proxy='jupyterhub', otherwise set to 'none'\n",
    "\n",
    "BASE_URL = 'http://localhost:8888'\n",
    "d.show(notebook_url=BASE_URL, service_proxy='none')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "familiar-creator",
   "metadata": {},
   "source": [
    "## Export Dashboard UI Queried Dataframe\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "artificial-prototype",
   "metadata": {},
   "outputs": [],
   "source": [
    "# From last run querie on dashboard\n",
    "queried_df = d.export()\n",
    "\n",
    "# Check results\n",
    "queried_df.columns"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "legislative-collect",
   "metadata": {},
   "source": [
    "## Cuxfilter Basic Dashboard, Preview, and Themes\n",
    "Lets continue investigating, this time following up on the increasing trips year over year and decreases in winter months. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fancy-jewelry",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Specify the charts and widgets to use with the selected columns of data and string maps\n",
    "chart1 = cuxfilter.charts.bar('all_time_week', title='rides per week')\n",
    "chart2 = cuxfilter.charts.heatmap(x='all_time_week', y='day', aggregate_col='temperature',\n",
    "                             aggregate_fn='mean', point_size=40, legend_position='right',\n",
    "                             title='mean temperature by day')\n",
    "widget1 = cuxfilter.charts.multi_select('day_type', label_map=day_type_map)\n",
    "\n",
    "# Update the yaxis ticker to an easily readable format\n",
    "chart1.y_axis_tick_formatter = NumeralTickFormatter(format=\"0,0\")\n",
    "chart2.y_axis_tick_formatter = NumeralTickFormatter(format=\"0,0\")\n",
    "\n",
    "# Generate the dashboard and select a layout\n",
    "d = cux_df.dashboard([chart1, chart2], sidebar=[widget1], \n",
    "                     layout=cuxfilter.layouts.feature_and_base, \n",
    "                     title='Temperature Dashboard', \n",
    "                     theme=cuxfilter.themes.dark) #options: rapids, light, dark\n",
    "# TRY: \n",
    "# Set different theme options and see the result in d.preview()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "global-representation",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Start the dashboard, a green button should appear to open one in a new tab.\n",
    "# NOTE: pan to match up the top and bottom chart axis\n",
    "\n",
    "# IMPORTANT: replace notebook_url with your jupyterhub/binder base url\n",
    "# IMPORTANT: if your notebook environment is in jupyterhub, set service_proxy='jupyterhub', otherwise set to 'none'\n",
    "d.show(notebook_url=BASE_URL, service_proxy='none')\n",
    "\n",
    "\n",
    "# TRY:\n",
    "# Use an inline image preview:\n",
    "# await d.preview()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "limited-makeup",
   "metadata": {},
   "source": [
    "## Cuxfilter Geospatial Graph Dashboard\n",
    "Next, lets take a look at the geospatial element of the data and see if we can find interesting patterns. Based on how the trip data is logged, converting it into a graph will make managing it easier.\n",
    "\n",
    "For this we will need [cuGraph](https://docs.rapids.ai/api/cugraph/stable/api.html) to translate the dataset into an edge list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "corporate-drive",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Build Graph\n",
    "G = cugraph.Graph() \n",
    "G.from_cudf_edgelist(data, source='from_station_id', destination='to_station_id')\n",
    "edges = G.edges()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "distinct-heritage",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Trips have been converted into edges with source and destination based on station IDs.\n",
    "edges.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "indirect-department",
   "metadata": {},
   "source": [
    "Next we load the formatted data into cuxfilter and specify the chart types:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "immune-activity",
   "metadata": {},
   "outputs": [],
   "source": [
    "cux_df = cuxfilter.DataFrame.load_graph((trips, edges))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "continued-peter",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Specifying a graph chart type will use Datashader and its required parameters\n",
    "widget1 = cuxfilter.charts.multi_select('year')\n",
    "widget2 = cuxfilter.charts.multi_select('day_type', label_map=day_type_map)\n",
    "\n",
    "chart1 = cuxfilter.charts.graph(\n",
    "            node_id='from_station_id',\n",
    "            edge_source='src', edge_target='dst',\n",
    "            node_aggregate_fn='count',\n",
    "            node_pixel_shade_type='linear', node_point_size=35, #node size is fixed set\n",
    "            edge_render_type='direct', #direct, curved\n",
    "            edge_transparency=0.7, #0.1 - 0.9\n",
    "            tile_provider='CARTODBPOSITRON', \n",
    "            title='Graph for trip source_stations (color by count)'\n",
    "        )\n",
    "chart2 = cuxfilter.charts.bar('from_station_id')\n",
    "chart3 = cuxfilter.charts.bar('to_station_id')\n",
    "\n",
    "# Update the yaxis ticker to an easily readable format\n",
    "chart2.y_axis_tick_formatter = NumeralTickFormatter(format=\"0,0\")\n",
    "chart3.y_axis_tick_formatter = NumeralTickFormatter(format=\"0,0\")\n",
    "\n",
    "        \n",
    "# Generate the dashboard, select a layout and theme\n",
    "d = cux_df.dashboard([chart1, chart2, chart3], sidebar=[widget1, widget2], layout=cuxfilter.layouts.feature_and_double_base, theme=cuxfilter.themes.rapids, title='Geospatial Trips')\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "significant-chest",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Start the dashboard, a green button should appear to open one in a new tab.\n",
    "# NOTE: Graph edges can be turned on/off via the line tool icon\n",
    "# NOTE: Inspect Neighboring Edges can be turned on/off for box or lasso select\n",
    "\n",
    "# Caution: Selecting areas with `Inspect Neighboring Edges` on can result in slow performance or OOM errors  \n",
    "# Caution: If the dashboard freezes, simply close the tab and restart this cell\n",
    "# NOTE: This is rendering 9 MILLION edges!\n",
    "\n",
    "# IMPORTANT: replace notebook_url with your jupyterhub/binder base url\n",
    "# IMPORTANT: if your notebook environment is in jupyterhub, set service_proxy='jupyterhub', otherwise set to 'none'\n",
    "\n",
    "d.show(notebook_url=BASE_URL, service_proxy='none')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "roman-executive",
   "metadata": {},
   "source": [
    "## CuGraph Clustering\n",
    "While the above produced many findings, filtering through so many trip edges is not ideal.\n",
    "Next we will try to push the visual analytics further with a clustered network graph along side the geospatial graph using the [ForceAtlas2](https://docs.rapids.ai/api/cugraph/stable/api.html?highlight=force#module-cugraph.layout.force_atlas2) algorithm from cuGraph:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "central-filter",
   "metadata": {},
   "outputs": [],
   "source": [
    "# NOTE: Often a good visualization result only comes from a lot of trial and error\n",
    "# The below parameters produce useful clustering, but try experimenting with them further\n",
    "ITERATIONS=500\n",
    "THETA=10.0\n",
    "\n",
    "# Using the previously created edge list, we calculate the FA2 layout positions here\n",
    "trips_force_atlas2_layout = cugraph.layout.force_atlas2(G, \n",
    "                max_iter=ITERATIONS,\n",
    "                strong_gravity_mode=False,\n",
    "                outbound_attraction_distribution=True,\n",
    "                lin_log_mode=False,\n",
    "                barnes_hut_optimize=True,\n",
    "                barnes_hut_theta=THETA,\n",
    "                verbose=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bearing-digit",
   "metadata": {},
   "source": [
    "Merge the calculated forceAtlas2 layout with the trip dataframe:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "solid-tokyo",
   "metadata": {},
   "outputs": [],
   "source": [
    "final_df = trips_force_atlas2_layout.merge(\n",
    "                trips[['from_station_id', 'from_station_name','to_station_id', 'year', 'hour', 'day_type', 'x', 'y']],\n",
    "                left_on='vertex',\n",
    "                right_on='from_station_id',\n",
    "                suffixes=('', '_original')\n",
    ")\n",
    "\n",
    "# Check\n",
    "final_df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "global-trauma",
   "metadata": {},
   "source": [
    "## Cuxfilter Clustered Graph and Geospatial Dashboard Two\n",
    "\n",
    "Next we load the data into cuxfilter and specify the chart types:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "broken-session",
   "metadata": {},
   "outputs": [],
   "source": [
    "cux_df = cuxfilter.DataFrame.load_graph((final_df, edges))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "marked-spiritual",
   "metadata": {},
   "outputs": [],
   "source": [
    "# NOTE: Both scatter and graph chart types use Datashader \n",
    "chart1 = cuxfilter.charts.graph(\n",
    "          edge_source='src', edge_target='dst',\n",
    "          edge_color_palette=['gray', 'black'],\n",
    "          ode_pixel_shade_type='linear',\n",
    "          edge_render_type='curved', #curved, direct\n",
    "          edge_transparency=0.6, #0.1 - 0.9\n",
    "          title='ForceAtlas2 Graph'\n",
    "      )\n",
    "chart2 = cuxfilter.charts.scatter(\n",
    "        x='x_original', y='y_original', \n",
    "        tile_provider='CARTODBPOSITRON',\n",
    "        point_size=4,\n",
    "        pixel_shade_type='linear',\n",
    "        pixel_spread='spread',\n",
    "        title='Scatter Layout'\n",
    "      )\n",
    "chart3 = cuxfilter.charts.bar('hour', title='Trips per hour')\n",
    "chart4 = cuxfilter.charts.bar('from_station_id', title='Source station')\n",
    "chart5 = cuxfilter.charts.bar('to_station_id', title='Destination station')\n",
    "\n",
    "widget1 = cuxfilter.charts.multi_select('year')\n",
    "widget2 = cuxfilter.charts.multi_select('day_type', label_map={0:'weekday', 1:'weekend', '':'all'})\n",
    "\n",
    "\n",
    "# Update the yaxis ticker to an easily readable format\n",
    "chart3.y_axis_tick_formatter = NumeralTickFormatter(format=\"0,0\")\n",
    "chart4.y_axis_tick_formatter = NumeralTickFormatter(format=\"0,0\")\n",
    "chart5.y_axis_tick_formatter = NumeralTickFormatter(format=\"0,0\")\n",
    "\n",
    "# Custom layout\n",
    "layout_array_3rds = [[1,1,2],[1,1,2],[3,4,5]]\n",
    "\n",
    "# Generate the dashboard, select a layout and theme\n",
    "d = cux_df.dashboard([chart1, chart2, chart3, chart4, chart5], sidebar=[widget1, widget2], layout_array = layout_array_3rds, theme=cuxfilter.themes.rapids, title=\"Network and Geospatial Graph\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "multiple-turning",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Start the dashboard, a green button should appear to open one in a new tab.\n",
    "# NOTE: Graph edges can be turned on/off via the line tool icon\n",
    "# NOTE: Inspect Neighboring Edges can be turned on/off for box or lasso select\n",
    "\n",
    "# Caution: Selecting areas with Inspect Neighboring Edges on can result in slow performance or OOM errors  \n",
    "# Caution: If the dashboard freezes, simply close the tab and restart this cell\n",
    "# NOTE: This is rendering 9 MILLION edges\n",
    "\n",
    "# IMPORTANT: replace notebook_url with your jupyterhub/binder base url\n",
    "# IMPORTANT: if your notebook environment is in jupyterhub, set service_proxy='jupyterhub', otherwise set to 'none'\n",
    "\n",
    "BASE_URL = 'http://localhost:8888'\n",
    "d.show(notebook_url=BASE_URL, service_proxy='none')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "compliant-breathing",
   "metadata": {},
   "source": [
    "## Visualization Findings\n",
    "\n",
    "Running the FA2 algorithm to group the station nodes together in a graph and placing the geospatial chart along side provided some compelling findings:\n",
    "- Stations form clusters of connectivity that are clearly geographically distinct \n",
    "- The core weekday group is actually multiple distinct clusters in close proximity (different work districts?)\n",
    "- The weekday group stays focused until after work hours where they then disperse north (happy hour?)\n",
    "- The weekend group is overall more spread out, starting along the coast then dispersing throughout the city towards the evening (sight seeing?)\n",
    "- Theater on Lake Station is a hyper focal point for the weekend group\n",
    "\n",
    "These are only a few notable points found relatively quickly - there are certainly more patterns.\n",
    "\n",
    "As you can tell, by the end of this tutorial, finding patterns in the data is becoming the primary focus and the tooling is fading to the background. This is the behavior we hope to achieve with our 'interactive big data visuailzation' goal. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "seeing-advisory",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "married-chinese",
   "metadata": {},
   "source": [
    "## A Final Summary on the Benefits of Running with RAPIDS\n",
    "\n",
    "Hopefully as you've clicked through this tutorial notebook, you've noticed how seamless it is working within the RAPIDS libraries and with other libraries. One of the key goals of RAPIDS is to keep the tools and workflows you are familiar with, but turn them into end-to-end GPU accelerated pipelines. From ETL, exploration, analytics, and visualization - you can take advantage of the speed ups from GPUs.\n",
    "\n",
    "We on the viz team are continuing to integrate with other visualization libraries, and have projects in the works to improve the performance and capabilities of web visualizations even further."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "robust-advertising",
   "metadata": {},
   "source": [
    "## FYI: cuxfilter Troubleshooting\n",
    "As we just released the graph visualization capability in cuxfilter, we are still working on building out features and fixes. \n",
    "\n",
    "If you find something that needs fixing or have feature requests, please submit an [issue on our Github Page](https://github.com/rapidsai/cuxfilter/issues). Better yet, [help contribute](https://github.com/rapidsai/cuxfilter#contributing-developers-guide). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "outside-suggestion",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}