getting_started_notebooks/intro_tutorials/10_Introduction_to_Clustering.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"introduction\"></a>\n",
    "## Introduction to Clustering\n",
    "#### By Paul Hendricks\n",
    "-------\n",
    "\n",
    "Clustering is an important technique for helping data scientists partition data, especially when that data doesn't have labels or annotations associated with it. Since these data often don't have labels, clustering is often described as an unsupervised learning technique. While there are many different algorithms that partition data into unique clusters, we will show in this notebook how in certain cases the DBSCAN algorithm can do a better job of clustering than traditional algorithms such as K-Means or Agglomerative Clustering. \n",
    "\n",
    "We will also show how to cluster data with K-Means and DBSCAN in NVIDIA RAPIDS – an open-source data analytics and machine learning acceleration platform that leverages GPUs to accelerate computations. We will see that porting this example from CPU to GPU is trivial and that we can experience massive performance gains by doing so.\n",
    "\n",
    "In this notebook, we will describe K-Means and DBSCAN - several popular clustering algorithms - and show how to use the GPU accelerated implementation of these algorithms in RAPIDS.\n",
    "\n",
    "**Table of Contents**\n",
    "\n",
    "* [Introduction to Clustering](#introduction)\n",
    "* [Setup](#setup)\n",
    "* [Generating Data](#generate)\n",
    "* [Overview of K-Means and Agglomerative Clustering](#overview)\n",
    "* [Clustering using DBSCAN](#dbscan)\n",
    "* [Accelerating Clustering with RAPIDS](#accelerating)\n",
    "* [Clustering using GPU Accelerated K-Means](#gpukmeans)\n",
    "* [Benchmarking: Comparing GPU and CPU](#benchmarking)\n",
    "* [K-Means](#benchmarkingkmeans)\n",
    "  * [GPU](#benchmarkingkmeansgpu)\n",
    "  * [CPU](#benchmarkingkmeanscpu)\n",
    "* [DBSCAN](#benchmarkingdbscan)\n",
    "  * [GPU](#benchmarkingdbscangpu)\n",
    "  * [CPU](#benchmarkingdbscancpu)\n",
    "* [K Nearest Neighbors (coming soon!)](#knn)\n",
    "* [Conclusion](#conclusion)\n",
    "\n",
    "Before going any further, let's make sure we have access to `matplotlib`, a popular Python library for visualizing data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matplotlib Version: 3.1.0\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "\n",
    "try:\n",
    "    import matplotlib; print('Matplotlib Version:', matplotlib.__version__)\n",
    "except ModuleNotFoundError:\n",
    "    os.system('conda install -y matplotlib')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"setup\"></a>\n",
    "## Setup\n",
    "\n",
    "This notebook was tested using the following Docker containers:\n",
    "\n",
    "* `rapidsai/rapidsai-nightly:0.8-cuda10.0-devel-ubuntu18.04-gcc7-py3.7` from [DockerHub - rapidsai/rapidsai-nightly](https://hub.docker.com/r/rapidsai/rapidsai-nightly)\n",
    "\n",
    "This notebook was run on the NVIDIA Tesla V100 GPU. Please be aware that your system may be different and you may need to modify the code or install packages to run the below examples. \n",
    "\n",
    "If you think you have found a bug or an error, please file an issue here: https://github.com/rapidsai/notebooks/issues\n",
    "\n",
    "Before we begin, let's check out our hardware setup by running the `nvidia-smi` command."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tue Jun 11 01:37:51 2019       \n",
      "+-----------------------------------------------------------------------------+\n",
      "| NVIDIA-SMI 418.67       Driver Version: 418.67       CUDA Version: 10.1     |\n",
      "|-------------------------------+----------------------+----------------------+\n",
      "| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n",
      "| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n",
      "|===============================+======================+======================|\n",
      "|   0  Tesla V100-SXM2...  On   | 00000000:06:00.0 Off |                    0 |\n",
      "| N/A   40C    P0    63W / 300W |      0MiB / 16130MiB |      0%      Default |\n",
      "+-------------------------------+----------------------+----------------------+\n",
      "|   1  Tesla V100-SXM2...  On   | 00000000:07:00.0 Off |                    0 |\n",
      "| N/A   38C    P0    42W / 300W |      0MiB / 16130MiB |      0%      Default |\n",
      "+-------------------------------+----------------------+----------------------+\n",
      "|   2  Tesla V100-SXM2...  On   | 00000000:0A:00.0 Off |                    0 |\n",
      "| N/A   39C    P0    44W / 300W |      0MiB / 16130MiB |      0%      Default |\n",
      "+-------------------------------+----------------------+----------------------+\n",
      "|   3  Tesla V100-SXM2...  On   | 00000000:0B:00.0 Off |                    0 |\n",
      "| N/A   37C    P0    43W / 300W |      0MiB / 16130MiB |      0%      Default |\n",
      "+-------------------------------+----------------------+----------------------+\n",
      "|   4  Tesla V100-SXM2...  On   | 00000000:85:00.0 Off |                    0 |\n",
      "| N/A   37C    P0    42W / 300W |      0MiB / 16130MiB |      0%      Default |\n",
      "+-------------------------------+----------------------+----------------------+\n",
      "|   5  Tesla V100-SXM2...  On   | 00000000:86:00.0 Off |                    0 |\n",
      "| N/A   38C    P0    43W / 300W |      0MiB / 16130MiB |      0%      Default |\n",
      "+-------------------------------+----------------------+----------------------+\n",
      "|   6  Tesla V100-SXM2...  On   | 00000000:89:00.0 Off |                    0 |\n",
      "| N/A   40C    P0    43W / 300W |      0MiB / 16130MiB |      0%      Default |\n",
      "+-------------------------------+----------------------+----------------------+\n",
      "|   7  Tesla V100-SXM2...  On   | 00000000:8A:00.0 Off |                    0 |\n",
      "| N/A   36C    P0    42W / 300W |      0MiB / 16130MiB |      0%      Default |\n",
      "+-------------------------------+----------------------+----------------------+\n",
      "                                                                               \n",
      "+-----------------------------------------------------------------------------+\n",
      "| Processes:                                                       GPU Memory |\n",
      "|  GPU       PID   Type   Process name                             Usage      |\n",
      "|=============================================================================|\n",
      "|  No running processes found                                                 |\n",
      "+-----------------------------------------------------------------------------+\n"
     ]
    }
   ],
   "source": [
    "!nvidia-smi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, let's see what CUDA version we have:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nvcc: NVIDIA (R) Cuda compiler driver\r\n",
      "Copyright (c) 2005-2018 NVIDIA Corporation\r\n",
      "Built on Sat_Aug_25_21:08:01_CDT_2018\r\n",
      "Cuda compilation tools, release 10.0, V10.0.130\r\n"
     ]
    }
   ],
   "source": [
    "!nvcc --version"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, let's load some helper functions from `matplotlib` and configure the Jupyter Notebook for visualization."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib.colors import ListedColormap\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"generate\"></a>\n",
    "## Generating Data\n",
    "\n",
    "We'll generate some fake data using the `make_moons` function from the `sklearn.datasets` module. This function generates data points from two equations, each describing a half circle with a unique center. Since each data point is generated by one of these two equations, the cluster each data point belongs to is clear. The ideal clustering algorithm will identify two clusters and associate each data point with the equation that generated it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Scikit-Learn Version: 0.21.2\n",
      "(100, 2)\n"
     ]
    }
   ],
   "source": [
    "import sklearn; print('Scikit-Learn Version:', sklearn.__version__)\n",
    "from sklearn.datasets import make_moons\n",
    "\n",
    "\n",
    "X, y = make_moons(n_samples=int(1e2), noise=0.05, random_state=0)\n",
    "print(X.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's visualize our data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# create figure\n",
    "figure = plt.figure()\n",
    "axis = figure.add_subplot(111)\n",
    "\n",
    "axis.scatter(X[y == 0, 0], X[y == 0, 1], \n",
    "             edgecolor='black',\n",
    "             c='lightblue', marker='o', s=40, label='cluster 1')\n",
    "axis.scatter(X[y == 1, 0], X[y == 1, 1], \n",
    "             edgecolor='black',\n",
    "             c='red', marker='s', s=40, label='cluster 2')\n",
    "axis.set_title('Empirical Data Points with Labels')\n",
    "\n",
    "plt.legend()\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"overview\"></a>\n",
    "## Overview of K-Means and Agglomerative Clustering\n",
    "\n",
    "There exist several algorithms for partitioning data into partitions, two of the more common of which are called K-Means and Agglomerative Clustering.\n",
    "\n",
    "The K-Means algorithm approaches the clustering problem by partitioning a set of data points into disjoint clusters, where each cluster is described by the mean of the samples in the cluster. The mean of the samples in a particular cluster is called a centroid; the K-Means algorithm finds the centroids and associates data points with centroids in such a way as to minimize the within-cluster sum-of-squares.\n",
    "\n",
    "For more information on the K-Means algorithm and its implementatin in scikit-learn, check out this resource: http://scikit-learn.org/stable/modules/clustering.html#k-means\n",
    "\n",
    "In the code cell below, we instantiate the `KMeans` algorithm from the `sklearn.cluster` module and apply it to our data using the `fit_predict` method. We see that `KMeans` identifies two centroids; one located at about (-0.23, 0.56) and the other located at (1.17, -0.05)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.17408322 -0.05027964]\n",
      " [-0.23011109  0.56790752]]\n"
     ]
    }
   ],
   "source": [
    "from sklearn.cluster import KMeans\n",
    "\n",
    "\n",
    "km = KMeans(n_clusters=2, random_state=0)\n",
    "y_km = km.fit_predict(X)\n",
    "print(km.cluster_centers_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Agglomerative Clustering algorithm behaves a little bit differently and does not identify clusters using centroids. Instead, it recursively merges the pair of clusters that minimally increases a given linkage distance. Put another way, the Agglomerative Clustering algorithm identifies the two data points that are \"closest\" out of all the data samples. It then takes those two data points and identifies a third data point that is \"closest\" to those two data points. The algorithm continues in this fashion for each data point; finding the next data point that is \"closest\" to the preceeding cluster of data points, where the definition of \"closest\" depends on the distance metric chosen.\n",
    "\n",
    "For more information on the Agglomerative Clustering algorithm and its implementatin in scikit-learn, check out this resource: http://scikit-learn.org/stable/modules/clustering.html#hierarchical-clustering\n",
    "\n",
    "Below, we instantiate the `AgglomerativeClustering` algorithm from the `sklearn.cluster` module and apply it to our data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.cluster import AgglomerativeClustering\n",
    "\n",
    "\n",
    "ac = AgglomerativeClustering(n_clusters=2,\n",
    "                             affinity='euclidean',\n",
    "                             linkage='complete')\n",
    "y_ac = ac.fit_predict(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can visualize the results of both algorithms applied to the data. Visually, we see that neither algorithm ideally clusters our data. The ideal algorithm for this unique set of data would recognize that both sets of samples are generated from two different equations describing two different half circles."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x216 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "f, (ax1, ax2) = plt.subplots(1, 2, figsize=(8, 3))\n",
    "\n",
    "\n",
    "ax1.scatter(X[y_km == 0, 0], X[y_km == 0, 1],\n",
    "            edgecolor='black',\n",
    "            c='lightblue', marker='o', s=40, label='cluster 1')\n",
    "ax1.scatter(X[y_km == 1, 0], X[y_km == 1, 1],\n",
    "            edgecolor='black',\n",
    "            c='red', marker='s', s=40, label='cluster 2')\n",
    "ax1.set_title('K Means Clustering')\n",
    "\n",
    "\n",
    "ax2.scatter(X[y_ac == 0, 0], X[y_ac == 0, 1], c='lightblue',\n",
    "            edgecolor='black',\n",
    "            marker='o', s=40, label='cluster 1')\n",
    "ax2.scatter(X[y_ac == 1, 0], X[y_ac == 1, 1], c='red',\n",
    "            edgecolor='black',\n",
    "            marker='s', s=40, label='cluster 2')\n",
    "ax2.set_title('Agglomerative Clustering')\n",
    "\n",
    "plt.legend()\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"dbscan\"></a>\n",
    "## Clustering using DBSCAN\n",
    "\n",
    "Unlike K Means or Agglomerative Clustering, DBSCAN is a density-based approach to spatial clustering. It views clusters as areas of high density separated by areas of low density. This approach has several advantages; whereas K Means focuses on finding centroids and assoicating data points with that centroid in a spherical manner, the DBSCAN algorithm can identify clusters of any convex shape. Additionally, DBSCAN is robust to areas of low density. In the above visualization, we see that Agglomerative Clustering ignores the low density space space between the interleaving circles and instead focuses on finding a clustering hierarchy that minimizes the Euclidean distance. While minimizing Euclidean distance is important for some clustering problems, it is visually apparent to a human that following the density trail of points results in the ideal clustering. \n",
    "\n",
    "For more information on the DBSCAN algorithm and its implementation in scikit-learn, check out this resource: http://scikit-learn.org/stable/modules/clustering.html#dbscan"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.cluster import DBSCAN\n",
    "\n",
    "\n",
    "db = DBSCAN(eps=0.2, min_samples=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, let's fit our model to the data and generate predictions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_db = db.fit_predict(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lastly, let's visualize the model applied to our data. We see that the DBSCAN algorithm correctly identifies which half-circle each data point is generated from."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(X[y_db == 0, 0], X[y_db == 0, 1],\n",
    "            c='lightblue', marker='o', s=40,\n",
    "            edgecolor='black', \n",
    "            label='cluster 1')\n",
    "plt.scatter(X[y_db == 1, 0], X[y_db == 1, 1],\n",
    "            c='red', marker='s', s=40,\n",
    "            edgecolor='black', \n",
    "            label='cluster 2')\n",
    "plt.legend()\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"accelerating\"></a>\n",
    "## Accelerating Clustering with RAPIDS\n",
    "\n",
    "So how can we accelerate our code using RAPIDS? First, we cast our data to a `pandas.DataFrame` and use that to create a `cudf.DataFrame`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuDF Version: 0.7.2+0.g3ebd286.dirty\n",
      "Pandas Version: 0.23.4\n"
     ]
    }
   ],
   "source": [
    "import cudf; print('cuDF Version:', cudf.__version__)\n",
    "import pandas as pd; print('Pandas Version:', pd.__version__)\n",
    "\n",
    "\n",
    "X_df = pd.DataFrame({'fea%d'%i: X[:, i] for i in range(X.shape[1])})\n",
    "X_gdf = cudf.DataFrame.from_pandas(X_df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"gpukmeans\"></a>\n",
    "## Clustering using GPU Accelerated K-Means\n",
    "\n",
    "Next, we load the `KMeans` class from the `cuml` package and instantiate it in the same way we did with the `sklearn.cluster.KMeans` class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "from cuml import KMeans as KMeans_GPU\n",
    "\n",
    "\n",
    "km_gpu = KMeans_GPU(n_clusters=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `KMeans` class from `cuml` implements the same API as the `sklearn` version; we can use the `fit` and `fit_predict` methods to fit our `KMeans` model to the data and generate predictions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_km_gpu = km_gpu.fit_predict(X_gdf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lastly, let's visualize our results:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(X[y_km_gpu == 0, 0], X[y_km_gpu == 0, 1],\n",
    "            c='lightblue', marker='o', s=40,\n",
    "            edgecolor='black', \n",
    "            label='cluster 1')\n",
    "plt.scatter(X[y_km_gpu == 1, 0], X[y_km_gpu == 1, 1],\n",
    "            c='red', marker='s', s=40,\n",
    "            edgecolor='black', \n",
    "            label='cluster 2')\n",
    "plt.legend()\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"gpudbscan\"></a>\n",
    "## Clustering using GPU Accelerated DBSCAN"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we load the `DBSCAN` class from the `cuml` package and instantiate it in the same way we did with the `sklearn.cluster.DBSCAN` class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuML Version: 0.8.0a+1003.g7f9e070c\n"
     ]
    }
   ],
   "source": [
    "import cuml; print('cuML Version:', cuml.__version__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "from cuml import DBSCAN as DBSCAN_GPU\n",
    "\n",
    "db_gpu = DBSCAN_GPU(eps=0.2, min_samples=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `DBSCAN` class from `cuml` implements the same API as the `sklearn` version; we can use the `fit` and `fit_predict` methods to fit our `DBSCAN` model to the data and generate predictions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_db_gpu = db_gpu.fit_predict(X_gdf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lastly, let's visualize our results:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(X[y_db_gpu == 0, 0], X[y_db_gpu == 0, 1],\n",
    "            c='lightblue', marker='o', s=40,\n",
    "            edgecolor='black', \n",
    "            label='cluster 1')\n",
    "plt.scatter(X[y_db_gpu == 1, 0], X[y_db_gpu == 1, 1],\n",
    "            c='red', marker='s', s=40,\n",
    "            edgecolor='black', \n",
    "            label='cluster 2')\n",
    "plt.legend()\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"benchmarking\"></a>\n",
    "## Benchmarking: Comparing GPU and CPU\n",
    "\n",
    "RAPIDS uses GPUs to parallelize operations and accelerate computations. We saw porting an example from the traditional scikit-learn interface to cuML was trivial. So how much speedup do we get from using RAPIDS? \n",
    "\n",
    "The answer to this question varies depending on the size and shape of the data. As a good rule of thumb, larger datasets will benefit from RAPIDS. There is overhead associated with using a GPU; data has to be transferred from the CPU to the GPU, computations have to take place on the GPU, and the results need to be transferred back from the GPU to the CPU. However, the transactional overhead of moving data back and forth from the CPU to the GPU can quickly become negligible due to the performance speedup from computing on a GPU instead of a CPU.\n",
    "\n",
    "Feel free to change the number of rows and columns to see how this speedup might change depending on the size and shape of the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NumPy Version: 1.16.2\n",
      "(100000, 128)\n"
     ]
    }
   ],
   "source": [
    "import numpy as np; print('NumPy Version:', np.__version__)\n",
    "\n",
    "n_rows, n_cols = 100000, 128\n",
    "X = np.random.rand(n_rows, n_cols)\n",
    "print(X.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_df = pd.DataFrame({'fea%d'%i: X[:, i] for i in range(X.shape[1])})\n",
    "X_gdf = cudf.DataFrame.from_pandas(X_df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"benchmarkingkmeans\"></a>\n",
    "## K-Means"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"benchmarkingkmeansgpu\"></a>\n",
    "### GPU"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "km_gpu = KMeans_GPU(n_clusters=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 287 ms, sys: 57.9 ms, total: 345 ms\n",
      "Wall time: 344 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "y_km_gpu = km_gpu.fit_predict(X_gdf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"benchmarkingkmeanscpu\"></a>\n",
    "### CPU"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "km = KMeans(n_clusters=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 1min 27s, sys: 12.8 s, total: 1min 40s\n",
      "Wall time: 31.2 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "y_km = km.fit_predict(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"benchmarkingdbscan\"></a>\n",
    "## DBSCAN"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"benchmarkingdbscangpu\"></a>\n",
    "### GPU"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "db_gpu = DBSCAN_GPU(eps=3, min_samples=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 350 ms, sys: 972 ms, total: 1.32 s\n",
      "Wall time: 1.32 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "y_db_gpu = db_gpu.fit_predict(X_gdf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"benchmarkingdbscancpu\"></a>\n",
    "### CPU"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "db = DBSCAN(eps=3, min_samples=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This takes a very long time!\n",
      "CPU times: user 38 µs, sys: 7 µs, total: 45 µs\n",
      "Wall time: 68.9 µs\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "print('This takes a very long time!')\n",
    "# y_db = db.fit_predict(X)  # uncomment this line to execute - run at your own risk of boredom!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"knn\"></a>\n",
    "## K Nearest Neighbors (coming soon!)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"conclusion\"></a>\n",
    "## Conclusion\n",
    "\n",
    "In this notebook, we described K-Means and DBSCAN - several popular clustering algorithms - and showed how to use the GPU accelerated implementation of these algorithms in RAPIDS.\n",
    "\n",
    "To learn more about RAPIDS, be sure to check out: \n",
    "\n",
    "* [Open Source Website](http://rapids.ai)\n",
    "* [GitHub](https://github.com/rapidsai/)\n",
    "* [Press Release](https://nvidianews.nvidia.com/news/nvidia-introduces-rapids-open-source-gpu-acceleration-platform-for-large-scale-data-analytics-and-machine-learning)\n",
    "* [NVIDIA Blog](https://blogs.nvidia.com/blog/2018/10/10/rapids-data-science-open-source-community/)\n",
    "* [Developer Blog](https://devblogs.nvidia.com/gpu-accelerated-analytics-rapids/)\n",
    "* [NVIDIA Data Science Webpage](https://www.nvidia.com/en-us/deep-learning-ai/solutions/data-science/)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}