examples/grouped_simple_moving_average.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Grouped Simple Moving Average\n",
    "\n",
    "This notebook compares Temporian's, pandas' and Polars' version of a grouped simple moving average, aiming to evaluate the speed and ease of writing of each library in this specific use case.\n",
    "\n",
    "## Data\n",
    "\n",
    "The data we'll be using belongs to the train CSV of [this Kaggle competition](https://www.kaggle.com/competitions/store-sales-time-series-forecasting/data?select=train.csv). It contains daily sales records for grocery stores in Ecuador. Each of the 3 million records corresponds to the daily sales of a certain `family` in a certain store number (`store_nbr`).\n",
    "\n",
    "To run the notebook, download the CSV and place it in `data/train.csv` in the project's root.\n",
    "\n",
    "Our goal is to calculate the **weekly moving average** of the sales for **each family** in each **store** (i.e., we want the moving average grouped by those two features)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import temporian as tp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load data to a pandas DataFrame."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>date</th>\n",
       "      <th>store_nbr</th>\n",
       "      <th>sales</th>\n",
       "      <th>family</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2013-01-01</td>\n",
       "      <td>1</td>\n",
       "      <td>0.000</td>\n",
       "      <td>AUTOMOTIVE</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2013-01-01</td>\n",
       "      <td>1</td>\n",
       "      <td>0.000</td>\n",
       "      <td>BABY CARE</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2013-01-01</td>\n",
       "      <td>1</td>\n",
       "      <td>0.000</td>\n",
       "      <td>BEAUTY</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2013-01-01</td>\n",
       "      <td>1</td>\n",
       "      <td>0.000</td>\n",
       "      <td>BEVERAGES</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2013-01-01</td>\n",
       "      <td>1</td>\n",
       "      <td>0.000</td>\n",
       "      <td>BOOKS</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3000883</th>\n",
       "      <td>2017-08-15</td>\n",
       "      <td>9</td>\n",
       "      <td>438.133</td>\n",
       "      <td>POULTRY</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3000884</th>\n",
       "      <td>2017-08-15</td>\n",
       "      <td>9</td>\n",
       "      <td>154.553</td>\n",
       "      <td>PREPARED FOODS</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3000885</th>\n",
       "      <td>2017-08-15</td>\n",
       "      <td>9</td>\n",
       "      <td>2419.729</td>\n",
       "      <td>PRODUCE</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3000886</th>\n",
       "      <td>2017-08-15</td>\n",
       "      <td>9</td>\n",
       "      <td>121.000</td>\n",
       "      <td>SCHOOL AND OFFICE SUPPLIES</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3000887</th>\n",
       "      <td>2017-08-15</td>\n",
       "      <td>9</td>\n",
       "      <td>16.000</td>\n",
       "      <td>SEAFOOD</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>3000888 rows × 4 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "              date  store_nbr     sales                      family\n",
       "0       2013-01-01          1     0.000                  AUTOMOTIVE\n",
       "1       2013-01-01          1     0.000                   BABY CARE\n",
       "2       2013-01-01          1     0.000                      BEAUTY\n",
       "3       2013-01-01          1     0.000                   BEVERAGES\n",
       "4       2013-01-01          1     0.000                       BOOKS\n",
       "...            ...        ...       ...                         ...\n",
       "3000883 2017-08-15          9   438.133                     POULTRY\n",
       "3000884 2017-08-15          9   154.553              PREPARED FOODS\n",
       "3000885 2017-08-15          9  2419.729                     PRODUCE\n",
       "3000886 2017-08-15          9   121.000  SCHOOL AND OFFICE SUPPLIES\n",
       "3000887 2017-08-15          9    16.000                     SEAFOOD\n",
       "\n",
       "[3000888 rows x 4 columns]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sales_df = pd.read_csv('../data/train.csv', parse_dates=['date'])[['date', 'store_nbr', 'sales', 'family']]\n",
    "sales_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load data to a Temporian EventSet."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:root:Feature \"family\" is an array of numpy.object_ and will be casted to numpy.string_ (Note: numpy.string_ is equivalent to numpy.bytes_).\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "  <div style=\"display: table; margin-bottom:11px; padding:5px; font-size:small; line-height:120%; border:1px solid rgba(127, 127, 127, 0.2)\">\n",
       "    <div style=\"display: table\">\n",
       "      <span>\n",
       "        <span style=\"font-weight:bold\">features</span>\n",
       "        <span style=\"\"> [3]:</span>\n",
       "      </span>\n",
       "      <span style=\"color:#0077BB; font-weight:bold\">sales</span>\n",
       "      <span style=\"color:#009988\"> (float64)</span>\n",
       "      <span style=\"\">, </span>\n",
       "      <span style=\"color:#0077BB; font-weight:bold\">store_nbr</span>\n",
       "      <span style=\"color:#009988\"> (int64)</span>\n",
       "      <span style=\"\">, </span>\n",
       "      <span style=\"color:#0077BB; font-weight:bold\">family</span>\n",
       "      <span style=\"color:#009988\"> (str_)</span>\n",
       "    </div>\n",
       "    <div style=\"display: table\">\n",
       "      <span>\n",
       "        <span style=\"font-weight:bold\">indexes</span>\n",
       "        <span style=\"\"> [0]:</span>\n",
       "      </span>\n",
       "      <span style=\"font-style:italic\">none</span>\n",
       "    </div>\n",
       "    <div style=\"display: table\">\n",
       "      <span style=\"font-weight:bold\">events: </span>\n",
       "      <span style=\"\">3000888</span>\n",
       "    </div>\n",
       "    <div style=\"display: table\">\n",
       "      <span style=\"font-weight:bold\">index values: </span>\n",
       "      <span style=\"\">1</span>\n",
       "    </div>\n",
       "    <div style=\"display: table\">\n",
       "      <span style=\"font-weight:bold\">memory usage: </span>\n",
       "      <span style=\"\">150.0 MB</span>\n",
       "    </div>\n",
       "  </div>\n",
       "  <div style=\"display: table\">\n",
       "    <span style=\"font-weight:bold\">index</span>\n",
       "    <span style=\"\"> (</span>\n",
       "    <span style=\"\">) with 3000888 events</span>\n",
       "  </div>\n",
       "  <table style=\"margin-left:20px; border:1px solid rgba(127, 127, 127, 0.2)\">\n",
       "    <tr>\n",
       "      <th>\n",
       "        <b>\n",
       "          <span style=\"\">timestamp</span>\n",
       "        </b>\n",
       "      </th>\n",
       "      <th>\n",
       "        <b>\n",
       "          <span style=\"color:#0077BB; font-weight:bold; \">sales</span>\n",
       "        </b>\n",
       "      </th>\n",
       "      <th>\n",
       "        <b>\n",
       "          <span style=\"color:#0077BB; font-weight:bold; \">store_nbr</span>\n",
       "        </b>\n",
       "      </th>\n",
       "      <th>\n",
       "        <b>\n",
       "          <span style=\"color:#0077BB; font-weight:bold; \">family</span>\n",
       "        </b>\n",
       "      </th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>\n",
       "        <span style=\"\">2013-01-01 00:00:00+00:00</span>\n",
       "      </td>\n",
       "      <td>\n",
       "        <span style=\"\">0</span>\n",
       "      </td>\n",
       "      <td>\n",
       "        <span style=\"\">1</span>\n",
       "      </td>\n",
       "      <td>\n",
       "        <span style=\"\">AUTOMOTIVE</span>\n",
       "      </td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>\n",
       "        <span style=\"\">2013-01-01 00:00:00+00:00</span>\n",
       "      </td>\n",
       "      <td>\n",
       "        <span style=\"\">0</span>\n",
       "      </td>\n",
       "      <td>\n",
       "        <span style=\"\">1</span>\n",
       "      </td>\n",
       "      <td>\n",
       "        <span style=\"\">BABY CARE</span>\n",
       "      </td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>\n",
       "        <span style=\"\">2013-01-01 00:00:00+00:00</span>\n",
       "      </td>\n",
       "      <td>\n",
       "        <span style=\"\">0</span>\n",
       "      </td>\n",
       "      <td>\n",
       "        <span style=\"\">1</span>\n",
       "      </td>\n",
       "      <td>\n",
       "        <span style=\"\">BEAUTY</span>\n",
       "      </td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>\n",
       "        <span style=\"\">2013-01-01 00:00:00+00:00</span>\n",
       "      </td>\n",
       "      <td>\n",
       "        <span style=\"\">0</span>\n",
       "      </td>\n",
       "      <td>\n",
       "        <span style=\"\">1</span>\n",
       "      </td>\n",
       "      <td>\n",
       "        <span style=\"\">BEVERAGES</span>\n",
       "      </td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>\n",
       "        <span style=\"\">2013-01-01 00:00:00+00:00</span>\n",
       "      </td>\n",
       "      <td>\n",
       "        <span style=\"\">0</span>\n",
       "      </td>\n",
       "      <td>\n",
       "        <span style=\"\">1</span>\n",
       "      </td>\n",
       "      <td>\n",
       "        <span style=\"\">BOOKS</span>\n",
       "      </td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>\n",
       "        <span style=\"\">…</span>\n",
       "      </td>\n",
       "      <td>\n",
       "        <span style=\"\">…</span>\n",
       "      </td>\n",
       "      <td>\n",
       "        <span style=\"\">…</span>\n",
       "      </td>\n",
       "      <td>\n",
       "        <span style=\"\">…</span>\n",
       "      </td>\n",
       "    </tr>\n",
       "  </table>\n",
       "</div>\n"
      ],
      "text/plain": [
       "indexes: []\n",
       "features: [('sales', float64), ('store_nbr', int64), ('family', str_)]\n",
       "events:\n",
       "     (3000888 events):\n",
       "        timestamps: ['2013-01-01T00:00:00' '2013-01-01T00:00:00' '2013-01-01T00:00:00' ...\n",
       "     '2017-08-15T00:00:00' '2017-08-15T00:00:00' '2017-08-15T00:00:00']\n",
       "        'sales': [   0.       0.       0.    ... 2419.729  121.      16.   ]\n",
       "        'store_nbr': [1 1 1 ... 9 9 9]\n",
       "        'family': [b'AUTOMOTIVE' b'BABY CARE' b'BEAUTY' ... b'PRODUCE'\n",
       "         b'SCHOOL AND OFFICE SUPPLIES' b'SEAFOOD']\n",
       "memory usage: 150.0 MB"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sales_evset = tp.from_csv('../data/train.csv', timestamps='date')[['sales', 'store_nbr', 'family']]\n",
    "sales_evset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Grouped moving average in pandas\n",
    "\n",
    "We use the `rolling` method of pandas DataFrames to calculate the moving average. We group by `store_nbr` and `family` and then apply the rolling method to the `sales` column.\n",
    "\n",
    "We'll only measure the time it takes to compute the actual moving average, not the time it takes to group the data, since it is not directly comparable between the two libraries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "grouped_df = sales_df.groupby(['store_nbr', 'family'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "789 ms ± 4.54 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<TimeitResult : 789 ms ± 4.54 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%timeit -o\n",
    "\n",
    "grouped_df.rolling('7d', on='date').mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd_res = _"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Grouped moving average in Temporian\n",
    "\n",
    "Temporian can handle grouped (or hierarchically structured) data natively, using [indexes](https://temporian.readthedocs.io/en/stable/user_guide/#indexes-horizontal-and-vertical-operators). Once our data has the correct index, applying a `simple_moving_average` to it is straightforward."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "grouped_evset = sales_evset.add_index(['store_nbr', 'family'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "24.6 ms ± 282 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<TimeitResult : 24.6 ms ± 282 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%timeit -o\n",
    "\n",
    "grouped_evset.simple_moving_average(tp.duration.weeks(1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "tp_res = _"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Results\n",
    "\n",
    "Computing the same grouped moving average in Temporian resulted in a **30x speedup** in this dataset!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Sanity check\n",
    "\n",
    "As a sanity check, lets make sure the results from both libraries are the same."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Run them again since %%timeit doesn't modify vars in the outer scope\n",
    "pd_result = grouped_df.rolling('7d', on='date').mean()\n",
    "tp_result = grouped_evset.simple_moving_average(tp.duration.weeks(1))\n",
    "\n",
    "tp_sma = tp.to_pandas(tp_result).sort_values(['store_nbr', 'family', 'timestamp'])['sales']\n",
    "pd_sma = pd_result.sort_values(['store_nbr', 'family', 'date'])['sales']\n",
    "np.allclose(pd_sma, tp_sma)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## But... what about Polars?\n",
    "\n",
    "[Polars](https://www.pola.rs/) is a DataFrame library written in Rust, born as a performance-oriented alternative to pandas. Lets see how it fares on this same task!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div><style>\n",
       ".dataframe > thead > tr > th,\n",
       ".dataframe > tbody > tr > td {\n",
       "  text-align: right;\n",
       "  white-space: pre-wrap;\n",
       "}\n",
       "</style>\n",
       "<small>shape: (5, 4)</small><table border=\"1\" class=\"dataframe\"><thead><tr><th>date</th><th>store_nbr</th><th>family</th><th>sales</th></tr><tr><td>date</td><td>i64</td><td>str</td><td>f64</td></tr></thead><tbody><tr><td>2013-01-01</td><td>1</td><td>&quot;AUTOMOTIVE&quot;</td><td>0.0</td></tr><tr><td>2013-01-01</td><td>1</td><td>&quot;BABY CARE&quot;</td><td>0.0</td></tr><tr><td>2013-01-01</td><td>1</td><td>&quot;BEAUTY&quot;</td><td>0.0</td></tr><tr><td>2013-01-01</td><td>1</td><td>&quot;BEVERAGES&quot;</td><td>0.0</td></tr><tr><td>2013-01-01</td><td>1</td><td>&quot;BOOKS&quot;</td><td>0.0</td></tr></tbody></table></div>"
      ],
      "text/plain": [
       "shape: (5, 4)\n",
       "┌────────────┬───────────┬────────────┬───────┐\n",
       "│ date       ┆ store_nbr ┆ family     ┆ sales │\n",
       "│ ---        ┆ ---       ┆ ---        ┆ ---   │\n",
       "│ date       ┆ i64       ┆ str        ┆ f64   │\n",
       "╞════════════╪═══════════╪════════════╪═══════╡\n",
       "│ 2013-01-01 ┆ 1         ┆ AUTOMOTIVE ┆ 0.0   │\n",
       "│ 2013-01-01 ┆ 1         ┆ BABY CARE  ┆ 0.0   │\n",
       "│ 2013-01-01 ┆ 1         ┆ BEAUTY     ┆ 0.0   │\n",
       "│ 2013-01-01 ┆ 1         ┆ BEVERAGES  ┆ 0.0   │\n",
       "│ 2013-01-01 ┆ 1         ┆ BOOKS      ┆ 0.0   │\n",
       "└────────────┴───────────┴────────────┴───────┘"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import polars as pl\n",
    "\n",
    "polars_df = pl.read_csv(\"../data/train.csv\", try_parse_dates=True, columns=['date', 'store_nbr', 'sales', 'family'])\n",
    "polars_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 863 ms, sys: 117 ms, total: 980 ms\n",
      "Wall time: 252 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "pl_result = polars_df.rolling(index_column='date', by=['store_nbr', 'family'], period='7d', offset='-7d').agg(pl.col('sales').mean())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Results\n",
    "\n",
    "Polars didn't get an edge over pandas - and Temporian is still **37x** faster than it.\n",
    "\n",
    "Note that this comparison isn't exactly fair though, since Polars doesn't provide a way to apply `.rolling()` over an already grouped DataFrame, which means we're counting both the grouping and the rolling average in the result!\n",
    "\n",
    "Lets do the same sanity check as before."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pl_sma = pl_result.to_pandas().sort_values(['store_nbr', 'family', 'date'])['sales']\n",
    "np.allclose(pd_sma, pl_sma)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# How does this scale?\n",
    "\n",
    "3 million records is already a decent dataset - but we might just find that scaling it up to larger amounts of data makes Temporian an even more attractive choie.\n",
    "\n",
    "Lets see how each library's performance scales to **5x** and **20x** the original number of rows!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pandas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "sales_df_5x = pd.concat([sales_df] * 5).sort_values(['date']).reset_index(drop=True)\n",
    "grouped_df_5x = sales_df_5x.groupby(['store_nbr', 'family'])\n",
    "\n",
    "sales_df_20x = pd.concat([sales_df] * 20).sort_values(['date']).reset_index(drop=True)\n",
    "grouped_df_20x = sales_df_20x.groupby(['store_nbr', 'family'])\n",
    "\n",
    "sales_df_100x = pd.concat([sales_df] * 100).sort_values(['date']).reset_index(drop=True)\n",
    "grouped_df_100x = sales_df_100x.groupby(['store_nbr', 'family'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.37 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<TimeitResult : 5.37 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%timeit -o -n1 -r1\n",
    "\n",
    "grouped_df_5x.rolling('7d', on='date').mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd_res_5x = _"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23.6 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<TimeitResult : 23.6 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%timeit -o -n1 -r1\n",
    "\n",
    "grouped_df_20x.rolling('7d', on='date').mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd_res_20x = _"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2min 18s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<TimeitResult : 2min 18s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%timeit -o -n1 -r1\n",
    "\n",
    "grouped_df_100x.rolling('7d', on='date').mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd_res_100x = _"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Temporian"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "grouped_evset_5x = tp.combine(*([grouped_evset] * 5))  # No need to sort values nor group again - Temporian natively stores data ordered by timestamp and grouped by index\n",
    "grouped_evset_20x = tp.combine(*([grouped_evset_5x] * 4))\n",
    "grouped_evset_100x = tp.combine(*([grouped_evset_20x] * 5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "73.1 ms ± 449 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<TimeitResult : 73.1 ms ± 449 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%timeit -o\n",
    "\n",
    "grouped_evset_5x.simple_moving_average(tp.duration.weeks(1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "tp_res_5x = _"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "232 ms ± 1.58 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<TimeitResult : 232 ms ± 1.58 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%timeit -o\n",
    "\n",
    "grouped_evset_20x.simple_moving_average(tp.duration.weeks(1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "tp_res_20x = _"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.12 s ± 2.79 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<TimeitResult : 1.12 s ± 2.79 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%timeit -o\n",
    "\n",
    "grouped_evset_100x.simple_moving_average(tp.duration.weeks(1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "tp_res_100x = _"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Results\n",
    "\n",
    "Temporian is **70x**, **95x** and **120x** faster than pandas for 5M, 15M and 60M records respectively! Although both grow linearly with the number of records, Temporian does so at a much slower rate.\n",
    "\n",
    "We can visualize how differently the performance of each library degrades as the number of records increases by plotting the results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "avg = lambda result: round(result.average, 2)\n",
    "\n",
    "data = pd.DataFrame({\n",
    "    \"pandas\": [avg(pd_res), avg(pd_res_5x), avg(pd_res_20x), avg(pd_res_100x)],\n",
    "    \"temporian\": [avg(tp_res), avg(tp_res_5x), avg(tp_res_20x), avg(tp_res_100x)],\n",
    "}, index=['3', '15', '60', '300'])\n",
    "ax = data.plot.bar(xlabel='# of records (millions)', ylabel='Seconds', rot=0)\n",
    "\n",
    "for container in ax.containers:\n",
    "    ax.bar_label(container)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Axes: xlabel='# of records (millions)', ylabel='Times faster than pandas'>"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "data = pd.DataFrame({\n",
    "    \"\": [pd_res.average/tp_res.average, pd_res_5x.average/tp_res_5x.average, pd_res_20x.average/tp_res_20x.average, pd_res_100x.average/tp_res_100x.average],\n",
    "}, index=['3', '15', '60', '300'])\n",
    "data.plot.bar(xlabel='# of records (millions)', ylabel='Times faster than pandas', legend=False, rot=0)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "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.9.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}