code/performance-comparisons.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Performance comparison"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook compares the performance of `cuDF` and `pandas`. The comparisons performed are on identical data sizes. This notebook primarily showcases the factor of speedups users can have when the similar `pandas` APIs are run on GPUs using `cudf`.\n",
    "\n",
    "This notebook is written to measure performance on NVIDIA GPUs with large memory and was tested with a single A100-40GB (~1 hour to run). If using any hardware with smaller memory and/or compute (eg. laptop, workstation), please consider pushing this project to a machine with heavier hardware to run this notebook. Thankfully, NVIDIA AI Workbench makes this process easy!\n",
    "\n",
    "Alternatively, you may consider lowering the `num_rows` values. \n",
    "\n",
    "**Note**: Performance results may vary by data size, as well as the CPU and GPU used. The hardware details used to run these performance comparisons are at the end of this page."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import time\n",
    "import timeit\n",
    "from io import BytesIO\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "import cudf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "np.random.seed(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Concat, count & joins performance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>numbers</th>\n",
       "      <th>business</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>-316</td>\n",
       "      <td>Buckees</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>-441</td>\n",
       "      <td>Costco</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>653</td>\n",
       "      <td>Costco</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>216</td>\n",
       "      <td>McD</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>-165</td>\n",
       "      <td>Costco</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>149999995</th>\n",
       "      <td>807</td>\n",
       "      <td>Costco</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>149999996</th>\n",
       "      <td>-441</td>\n",
       "      <td>Buckees</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>149999997</th>\n",
       "      <td>-377</td>\n",
       "      <td>Costco</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>149999998</th>\n",
       "      <td>966</td>\n",
       "      <td>Costco</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>149999999</th>\n",
       "      <td>-384</td>\n",
       "      <td>Costco</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>150000000 rows × 2 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "           numbers business\n",
       "0             -316  Buckees\n",
       "1             -441   Costco\n",
       "2              653   Costco\n",
       "3              216      McD\n",
       "4             -165   Costco\n",
       "...            ...      ...\n",
       "149999995      807   Costco\n",
       "149999996     -441  Buckees\n",
       "149999997     -377   Costco\n",
       "149999998      966   Costco\n",
       "149999999     -384   Costco\n",
       "\n",
       "[150000000 rows x 2 columns]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num_rows = 150_000_000\n",
    "pdf = pd.DataFrame(\n",
    "    {\n",
    "        \"numbers\": np.random.randint(-1000, 1000, num_rows, dtype=\"int64\"),\n",
    "        \"business\": np.random.choice(\n",
    "            [\"McD\", \"Buckees\", \"Walmart\", \"Costco\"], size=num_rows\n",
    "        ),\n",
    "    }\n",
    ")\n",
    "pdf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>numbers</th>\n",
       "      <th>business</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>-316</td>\n",
       "      <td>Buckees</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>-441</td>\n",
       "      <td>Costco</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>653</td>\n",
       "      <td>Costco</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>216</td>\n",
       "      <td>McD</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>-165</td>\n",
       "      <td>Costco</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>149999995</th>\n",
       "      <td>807</td>\n",
       "      <td>Costco</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>149999996</th>\n",
       "      <td>-441</td>\n",
       "      <td>Buckees</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>149999997</th>\n",
       "      <td>-377</td>\n",
       "      <td>Costco</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>149999998</th>\n",
       "      <td>966</td>\n",
       "      <td>Costco</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>149999999</th>\n",
       "      <td>-384</td>\n",
       "      <td>Costco</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>150000000 rows × 2 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "           numbers business\n",
       "0             -316  Buckees\n",
       "1             -441   Costco\n",
       "2              653   Costco\n",
       "3              216      McD\n",
       "4             -165   Costco\n",
       "...            ...      ...\n",
       "149999995      807   Costco\n",
       "149999996     -441  Buckees\n",
       "149999997     -377   Costco\n",
       "149999998      966   Costco\n",
       "149999999     -384   Costco\n",
       "\n",
       "[150000000 rows x 2 columns]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gdf = cudf.from_pandas(pdf)\n",
    "gdf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def timeit_pandas_cudf(pd_obj, gd_obj, func, **kwargs):\n",
    "    \"\"\"\n",
    "    A utility function to measure execution time of an\n",
    "    API(`func`) in pandas & cudf.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    pd_obj : Pandas object\n",
    "    gd_obj : cuDF object\n",
    "    func : callable\n",
    "    \"\"\"\n",
    "    pandas_time = timeit.timeit(lambda: func(pd_obj), **kwargs)\n",
    "    cudf_time = timeit.timeit(lambda: func(gd_obj), **kwargs)\n",
    "    return pandas_time, cudf_time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "pandas_value_counts, cudf_value_counts = timeit_pandas_cudf(\n",
    "    pdf, gdf, lambda df: df.value_counts(), number=30\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "pdf = pdf.head(50_000_000)\n",
    "gdf = gdf.head(50_000_000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "pandas_concat = timeit.timeit(lambda: pd.concat([pdf, pdf, pdf]), number=30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "cudf_concat = timeit.timeit(lambda: cudf.concat([gdf, gdf, gdf]), number=30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "pandas_groupby, cudf_groupby = timeit_pandas_cudf(\n",
    "    pdf,\n",
    "    gdf,\n",
    "    lambda df: df.groupby(\"business\").agg([\"min\", \"max\", \"mean\"]),\n",
    "    number=30,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "num_rows = 500_000\n",
    "pdf = pd.DataFrame(\n",
    "    {\n",
    "        \"numbers\": np.random.randint(-1000, 1000, num_rows, dtype=\"int64\"),\n",
    "        \"business\": np.random.choice(\n",
    "            [\"McD\", \"Buckees\", \"Walmart\", \"Costco\"], size=num_rows\n",
    "        ),\n",
    "    }\n",
    ")\n",
    "gdf = cudf.from_pandas(pdf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "pandas_merge, cudf_merge = timeit_pandas_cudf(\n",
    "    pdf, gdf, lambda df: df.merge(df), number=30\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "performance_df = pd.DataFrame(\n",
    "    {\n",
    "        \"cudf speedup vs. pandas\": [\n",
    "            pandas_value_counts / cudf_value_counts,\n",
    "            pandas_concat / cudf_concat,\n",
    "            pandas_groupby / cudf_groupby,\n",
    "            pandas_merge / cudf_merge,\n",
    "        ],\n",
    "    },\n",
    "    index=[\"value_counts\", \"concat\", \"groupby\", \"merge\"],\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>cudf speedup vs. pandas</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>value_counts</th>\n",
       "      <td>98.795870</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>concat</th>\n",
       "      <td>40.988709</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>groupby</th>\n",
       "      <td>89.501697</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>merge</th>\n",
       "      <td>52.585589</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              cudf speedup vs. pandas\n",
       "value_counts                98.795870\n",
       "concat                      40.988709\n",
       "groupby                     89.501697\n",
       "merge                       52.585589"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "performance_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ax = performance_df.plot.bar(\n",
    "    color=\"#7400ff\",\n",
    "    ylim=(1, 150),\n",
    "    rot=0,\n",
    "    xlabel=\"Operation\",\n",
    "    ylabel=\"Speedup factor\",\n",
    ")\n",
    "ax.bar_label(ax.containers[0], fmt=\"%.0f\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Cleaning up used memory for later benchmarks\n",
    "del pdf\n",
    "del gdf\n",
    "import gc\n",
    "\n",
    "_ = gc.collect()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings Performance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "num_rows = 100_000_000\n",
    "pd_series = pd.Series(\n",
    "    np.random.choice(\n",
    "        [\"123\", \"56.234\", \"Walmart\", \"Costco\", \"rapids ai\"], size=num_rows\n",
    "    )\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "gd_series = cudf.from_pandas(pd_series)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "pandas_upper, cudf_upper = timeit_pandas_cudf(\n",
    "    pd_series, gd_series, lambda s: s.str.upper(), number=20\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "pandas_contains, cudf_contains = timeit_pandas_cudf(\n",
    "    pd_series, gd_series, lambda s: s.str.contains(r\"[0-9][a-z]\"), number=20\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "pandas_isalpha, cudf_isalpha = timeit_pandas_cudf(\n",
    "    pd_series, gd_series, lambda s: s.str.isalpha(), number=20\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "performance_df = pd.DataFrame(\n",
    "    {\n",
    "        \"cudf speedup vs. pandas\": [\n",
    "            pandas_upper / cudf_upper,\n",
    "            pandas_contains / cudf_contains,\n",
    "            pandas_isalpha / cudf_isalpha,\n",
    "        ],\n",
    "    },\n",
    "    index=[\"upper\", \"contains\", \"isalpha\"],\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>cudf speedup vs. pandas</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>upper</th>\n",
       "      <td>1012.916918</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>contains</th>\n",
       "      <td>321.727087</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>isalpha</th>\n",
       "      <td>3665.660623</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          cudf speedup vs. pandas\n",
       "upper                 1012.916918\n",
       "contains               321.727087\n",
       "isalpha               3665.660623"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "performance_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ax = performance_df.plot.bar(\n",
    "    color=\"#7400ff\",\n",
    "    ylim=(1, 4000),\n",
    "    rot=0,\n",
    "    xlabel=\"String method\",\n",
    "    ylabel=\"Speedup factor\",\n",
    ")\n",
    "ax.bar_label(ax.containers[0], fmt=\"%.0f\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## User-defined function (UDF) performance (with JIT overhead)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first UDF runs include JIT compilation overhead, due to which the performance of first run and average of next few runs are compared separately."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>age</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>59</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>20</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>86</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>73</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4999995</th>\n",
       "      <td>18</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4999996</th>\n",
       "      <td>86</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4999997</th>\n",
       "      <td>18</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4999998</th>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4999999</th>\n",
       "      <td>88</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>5000000 rows × 1 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "         age\n",
       "0         59\n",
       "1         20\n",
       "2         86\n",
       "3         73\n",
       "4          6\n",
       "...      ...\n",
       "4999995   18\n",
       "4999996   86\n",
       "4999997   18\n",
       "4999998    7\n",
       "4999999   88\n",
       "\n",
       "[5000000 rows x 1 columns]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num_rows = 5_000_000\n",
    "pdf_age = pd.DataFrame(\n",
    "    {\n",
    "        \"age\": np.random.randint(0, 100, num_rows),\n",
    "    }\n",
    ")\n",
    "pdf_age"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>age</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>59</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>20</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>86</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>73</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4999995</th>\n",
       "      <td>18</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4999996</th>\n",
       "      <td>86</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4999997</th>\n",
       "      <td>18</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4999998</th>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4999999</th>\n",
       "      <td>88</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>5000000 rows × 1 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "         age\n",
       "0         59\n",
       "1         20\n",
       "2         86\n",
       "3         73\n",
       "4          6\n",
       "...      ...\n",
       "4999995   18\n",
       "4999996   86\n",
       "4999997   18\n",
       "4999998    7\n",
       "4999999   88\n",
       "\n",
       "[5000000 rows x 1 columns]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gdf_age = cudf.from_pandas(pdf_age)\n",
    "gdf_age"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def age_udf(row):\n",
    "    if row[\"age\"] < 18:\n",
    "        return 0\n",
    "    elif 18 <= row[\"age\"] < 20:\n",
    "        return 1\n",
    "    elif 20 <= row[\"age\"] < 30:\n",
    "        return 2\n",
    "    elif 30 <= row[\"age\"] < 40:\n",
    "        return 3\n",
    "    elif 40 <= row[\"age\"] < 50:\n",
    "        return 4\n",
    "    elif 50 <= row[\"age\"] < 60:\n",
    "        return 5\n",
    "    elif 60 <= row[\"age\"] < 70:\n",
    "        return 6\n",
    "    else:\n",
    "        return 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "pandas_int_udf, cudf_int_udf = timeit_pandas_cudf(\n",
    "    pdf_age, gdf_age, lambda df: df.apply(age_udf, axis=1), number=1\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def str_isupper_udf(row):\n",
    "    if row.isupper():\n",
    "        return 0\n",
    "    else:\n",
    "        return 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0                   abc\n",
       "1                    AI\n",
       "2                   ABC\n",
       "3                   abc\n",
       "4                    AI\n",
       "               ...     \n",
       "49999995            ABC\n",
       "49999996            abc\n",
       "49999997    hello world\n",
       "49999998            abc\n",
       "49999999             AI\n",
       "Name: strings, Length: 50000000, dtype: object"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd_series = pd.Series(\n",
    "    np.random.choice([\"ABC\", \"abc\", \"hello world\", \"AI\"], size=50_000_000),\n",
    "    name=\"strings\",\n",
    ")\n",
    "pd_series"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0                   abc\n",
       "1                    AI\n",
       "2                   ABC\n",
       "3                   abc\n",
       "4                    AI\n",
       "               ...     \n",
       "49999995            ABC\n",
       "49999996            abc\n",
       "49999997    hello world\n",
       "49999998            abc\n",
       "49999999             AI\n",
       "Name: strings, Length: 50000000, dtype: object"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gd_series = cudf.from_pandas(pd_series)\n",
    "gd_series"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "pandas_str_udf, cudf_str_udf = timeit_pandas_cudf(\n",
    "    pd_series, gd_series, lambda s: s.apply(str_isupper_udf), number=1\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>cudf speedup vs. pandas</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Numeric</th>\n",
       "      <td>153.236482</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>String</th>\n",
       "      <td>108.242918</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         cudf speedup vs. pandas\n",
       "Numeric               153.236482\n",
       "String                108.242918"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "performance_df = pd.DataFrame(\n",
    "    {\n",
    "        \"cudf speedup vs. pandas\": [\n",
    "            pandas_int_udf / cudf_int_udf,\n",
    "            pandas_str_udf / cudf_str_udf,\n",
    "        ]\n",
    "    },\n",
    "    index=[\"Numeric\", \"String\"],\n",
    ")\n",
    "performance_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below is the plot showing performance speedup in case of Numeric UDFs & String UDFs on their first runs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ax = performance_df.plot.bar(\n",
    "    color=\"#7400ff\",\n",
    "    ylim=(1, 200),\n",
    "    rot=0,\n",
    "    xlabel=\"UDF Kind\",\n",
    "    ylabel=\"Speedup factor\",\n",
    ")\n",
    "ax.bar_label(ax.containers[0], fmt=\"%.0f\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## User-defined function (UDF) performance (without JIT overhead)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "pandas_int_udf, cudf_int_udf = timeit_pandas_cudf(\n",
    "    pdf_age, gdf_age, lambda df: df.apply(age_udf, axis=1), number=10\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "pandas_str_udf, cudf_str_udf = timeit_pandas_cudf(\n",
    "    pd_series, gd_series, lambda s: s.apply(str_isupper_udf), number=10\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>cudf speedup vs. pandas</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Numeric</th>\n",
       "      <td>20594.774013</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>String</th>\n",
       "      <td>1609.251766</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         cudf speedup vs. pandas\n",
       "Numeric             20594.774013\n",
       "String               1609.251766"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "performance_df = pd.DataFrame(\n",
    "    {\n",
    "        \"cudf speedup vs. pandas\": [\n",
    "            pandas_int_udf / cudf_int_udf,\n",
    "            pandas_str_udf / cudf_str_udf,\n",
    "        ]\n",
    "    },\n",
    "    index=[\"Numeric\", \"String\"],\n",
    ")\n",
    "performance_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below is the plot showing performance speedup in case of Numeric UDFs & String UDFs on their consequent runs. In this case the speedup is massive because of no JIT overhead present."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ax = performance_df.plot.bar(\n",
    "    color=\"#7400ff\",\n",
    "    ylim=(1, 30000),\n",
    "    rot=0,\n",
    "    xlabel=\"UDF Kind\",\n",
    "    ylabel=\"Speedup factor\",\n",
    ")\n",
    "ax.bar_label(ax.containers[0], fmt=\"%.0f\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## UDF Performance in GroupBy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "num_rows = 50_000_000\n",
    "pdf = pd.DataFrame()\n",
    "pdf[\"key\"] = np.random.randint(0, 2, num_rows)\n",
    "pdf[\"val\"] = np.random.randint(0, 7, num_rows)\n",
    "\n",
    "\n",
    "def custom_formula_udf(df):\n",
    "    df[\"out\"] = df[\"key\"] * df[\"val\"] - 10\n",
    "    return df\n",
    "\n",
    "\n",
    "gdf = cudf.from_pandas(pdf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "pandas_udf_groupby, cudf_udf_groupby = timeit_pandas_cudf(\n",
    "    pdf,\n",
    "    gdf,\n",
    "    lambda df: df.groupby([\"key\"], group_keys=False).apply(custom_formula_udf),\n",
    "    number=10,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>cudf speedup vs. pandas</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Grouped UDF</th>\n",
       "      <td>146.587285</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             cudf speedup vs. pandas\n",
       "Grouped UDF               146.587285"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "performance_df = pd.DataFrame(\n",
    "    {\"cudf speedup vs. pandas\": [pandas_udf_groupby / cudf_udf_groupby]},\n",
    "    index=[\"Grouped UDF\"],\n",
    ")\n",
    "performance_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ax = performance_df.plot.bar(\n",
    "    color=\"#7400ff\", ylim=(1, 250), rot=0, ylabel=\"Speedup factor\"\n",
    ")\n",
    "ax.bar_label(ax.containers[0], fmt=\"%.0f\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# System Configuration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## CPU Configuration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Architecture:            x86_64\n",
      "  CPU op-mode(s):        32-bit, 64-bit\n",
      "  Address sizes:         45 bits physical, 48 bits virtual\n",
      "  Byte Order:            Little Endian\n",
      "CPU(s):                  32\n",
      "  On-line CPU(s) list:   0-31\n",
      "Vendor ID:               GenuineIntel\n",
      "  Model name:            Intel(R) Xeon(R) Gold 6240R CPU @ 2.40GHz\n",
      "    CPU family:          6\n",
      "    Model:               85\n",
      "    Thread(s) per core:  1\n",
      "    Core(s) per socket:  16\n",
      "    Socket(s):           2\n",
      "    Stepping:            7\n",
      "    BogoMIPS:            4788.74\n",
      "    Flags:               fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mc\n",
      "                         a cmov pat pse36 clflush mmx fxsr sse sse2 ss ht syscal\n",
      "                         l nx pdpe1gb rdtscp lm constant_tsc arch_perfmon nopl x\n",
      "                         topology tsc_reliable nonstop_tsc cpuid tsc_known_freq \n",
      "                         pni pclmulqdq ssse3 fma cx16 pcid sse4_1 sse4_2 x2apic \n",
      "                         movbe popcnt tsc_deadline_timer aes xsave avx f16c rdra\n",
      "                         nd hypervisor lahf_lm abm 3dnowprefetch invpcid_single \n",
      "                         ssbd ibrs ibpb stibp ibrs_enhanced fsgsbase tsc_adjust \n",
      "                         bmi1 avx2 smep bmi2 invpcid avx512f avx512dq rdseed adx\n",
      "                          smap clflushopt clwb avx512cd avx512bw avx512vl xsaveo\n",
      "                         pt xsavec xgetbv1 xsaves arat pku ospke avx512_vnni md_\n",
      "                         clear flush_l1d arch_capabilities\n",
      "Virtualization features: \n",
      "  Hypervisor vendor:     VMware\n",
      "  Virtualization type:   full\n",
      "Caches (sum of all):     \n",
      "  L1d:                   1 MiB (32 instances)\n",
      "  L1i:                   1 MiB (32 instances)\n",
      "  L2:                    32 MiB (32 instances)\n",
      "  L3:                    71.5 MiB (2 instances)\n",
      "NUMA:                    \n",
      "  NUMA node(s):          2\n",
      "  NUMA node0 CPU(s):     0-15\n",
      "  NUMA node1 CPU(s):     16-31\n",
      "Vulnerabilities:         \n",
      "  Gather data sampling:  Unknown: Dependent on hypervisor status\n",
      "  Itlb multihit:         KVM: Mitigation: VMX unsupported\n",
      "  L1tf:                  Not affected\n",
      "  Mds:                   Not affected\n",
      "  Meltdown:              Not affected\n",
      "  Mmio stale data:       Vulnerable: Clear CPU buffers attempted, no microcode; \n",
      "                         SMT Host state unknown\n",
      "  Retbleed:              Mitigation; Enhanced IBRS\n",
      "  Spec store bypass:     Mitigation; Speculative Store Bypass disabled via prctl\n",
      "  Spectre v1:            Mitigation; usercopy/swapgs barriers and __user pointer\n",
      "                          sanitization\n",
      "  Spectre v2:            Mitigation; Enhanced IBRS, IBPB conditional, RSB fillin\n",
      "                         g, PBRSB-eIBRS SW sequence\n",
      "  Srbds:                 Not affected\n",
      "  Tsx async abort:       Not affected\n"
     ]
    }
   ],
   "source": [
    "!lscpu"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## GPU Configuration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fri Sep 22 17:07:12 2023       \n",
      "+---------------------------------------------------------------------------------------+\n",
      "| NVIDIA-SMI 535.86.05              Driver Version: 535.86.05    CUDA Version: 12.2     |\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",
      "|                                         |                      |               MIG M. |\n",
      "|=========================================+======================+======================|\n",
      "|   0  NVIDIA A100-PCIE-40GB          Off | 00000000:03:00.0 Off |                    0 |\n",
      "| N/A   31C    P0              56W / 250W |   5029MiB / 40960MiB |      0%      Default |\n",
      "|                                         |                      |             Disabled |\n",
      "+-----------------------------------------+----------------------+----------------------+\n",
      "                                                                                         \n",
      "+---------------------------------------------------------------------------------------+\n",
      "| Processes:                                                                            |\n",
      "|  GPU   GI   CI        PID   Type   Process name                            GPU Memory |\n",
      "|        ID   ID                                                             Usage      |\n",
      "|=======================================================================================|\n",
      "+---------------------------------------------------------------------------------------+\n"
     ]
    }
   ],
   "source": [
    "!nvidia-smi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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.10.11"
  },
  "vscode": {
   "interpreter": {
    "hash": "b4f3463dcc83b00b9c65791e378b11fabec52613a2a7831cd4af76c548ff6047"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}