examples/verbose_example.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import scipy.stats as ss\n",
    "from typing import List"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data loading"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                         TMP\n",
      "timestamp                                   \n",
      "2017-06-13 14:22:13+02:00         382.209991\n",
      "2017-06-13 14:22:13.250000+02:00  382.209991\n",
      "2017-06-13 14:22:13.500000+02:00  382.209991\n",
      "------------------------------------------------------------\n",
      "                                  ACC_x  ACC_y  ACC_z\n",
      "timestamp                                            \n",
      "2017-06-13 14:22:13+02:00             0      5     63\n",
      "2017-06-13 14:22:13.031250+02:00      0      5     63\n",
      "2017-06-13 14:22:13.062500+02:00      0      5     63\n",
      "2017-06-13 14:22:13.093750+02:00      0      5     63\n",
      "2017-06-13 14:22:13.125000+02:00      0      5     63\n",
      "2017-06-13 14:22:13.156250+02:00     -1      5     63\n",
      "------------------------------------------------------------\n",
      "                                       EDA\n",
      "timestamp                                 \n",
      "2017-06-13 14:22:13+02:00         0.000000\n",
      "2017-06-13 14:22:13.250000+02:00  0.400309\n",
      "2017-06-13 14:22:13.500000+02:00  0.475767\n"
     ]
    }
   ],
   "source": [
    "# Load your data\n",
    "df_tmp = pd.read_parquet(\"data/empatica/tmp.parquet\").set_index(\"timestamp\")\n",
    "df_gsr = pd.read_parquet(\"data/empatica/gsr.parquet\").set_index(\"timestamp\")\n",
    "df_acc = pd.read_parquet(\"data/empatica/acc.parquet\").set_index(\"timestamp\")\n",
    "\n",
    "# !!! The data MUST datetime Indexed\n",
    "assert isinstance(df_tmp.index, pd.DatetimeIndex)\n",
    "\n",
    "print(df_tmp.head(3))   # ~4Hz\n",
    "print('-'*60)\n",
    "print(df_acc.head(6))  # ~32Hz\n",
    "print('-'*60)\n",
    "print(df_gsr.head(3))   # ~4Hz"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**note**: The `ACC` signal is sampled at a different sample frequency.\n",
    "\n",
    "> So we deal with `multivariate data` of which each modality has a different sample-frequency."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Series Processing pipeline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "try: \n",
    "    from tsflex.processing import SeriesProcessor, SeriesPipeline\n",
    "    from tsflex.processing.logger import get_processor_logs\n",
    "except:\n",
    "    import sys\n",
    "    sys.path.append('../')\n",
    "    from tsflex.processing import SeriesProcessor, SeriesPipeline\n",
    "    from tsflex.processing.logger import get_processor_logs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **note**: processing takes place on one or multiple flat series as is and does not use window-stride parameters<br>the **output** of a processing step should either be `one or multiple` existing **series** (which will be updated in the internal representation ) and/or `one-multiple` new series."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[link to docs](https://predict-idlab.github.io/tsflex/features/index.html#getting-started)**\n",
    "\n",
    "![series uml](https://raw.githubusercontent.com/predict-idlab/tsflex/main/docs/_static/series_uml.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As shown above, there are 2 relevant classes for processing.\n",
    "\n",
    "1. [SeriesPipeline](https://predict-idlab.github.io/tsflex/processing/#tsflex.processing.SeriesPipeline): serves as a pipeline, withholding the to-be-applied processing steps\n",
    "2. [SeriesProcessor](https://predict-idlab.github.io/tsflex/processing/#tsflex.processing.SeriesProcessor): an instance of this class describes a processing step.<br>\n",
    "   Processors are defined by:<br>\n",
    "   * `function`: the Callable processing-function - e.g. scipy.signal.detrend\n",
    "   * `series_names`: the name(s) of the series on which the processing function should be applied\n",
    "   * `**kwargs`: the keyword arguments for the function.\n",
    "\n",
    "The snippets below show how the SeriesPipeline & SeriesProcessor interplay:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# --------------------- some custom signal procesisng functions ---------------------\n",
    "from scipy.signal import savgol_filter\n",
    "\n",
    "def clip_quantiles(sig: pd.Series, lower_q=0.01, upper_q=0.99) -> np.ndarray:\n",
    "    # Note that this function induces a data leakage\n",
    "    quantile_vals = np.quantile(sig, q=[lower_q, upper_q])\n",
    "    return np.clip(sig, *quantile_vals)\n",
    "\n",
    "def smv(*sigs) -> pd.Series:\n",
    "    # creates a new series\n",
    "    sig_prefixes = set(sig.name.split('_')[0] for sig in sigs)\n",
    "    result = np.sqrt(np.sum([np.square(sig) for sig in sigs], axis=0))\n",
    "    return pd.Series(result, index=sigs[0].index, name='|'.join(sig_prefixes)+'_'+'SMV')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[\n",
       "\tclip_quantiles {'lower_q': 0, 'upper_q': 0.999} :  ('TMP',)\n",
       "\tsavgol_filter {'window_length': 5, 'polyorder': 2} :  ('EDA',)\n",
       "\tsavgol_filter {'window_length': 33, 'polyorder': 2} :  ('ACC_x',) ('ACC_y',) ('ACC_z',)\n",
       "\tsmv {} :  ('ACC_x', 'ACC_y', 'ACC_z')\n",
       "\tclip_quantiles {} :  ('ACC_SMV',)\n",
       "]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# -- 1.  Create the series processors (with their keyword arguments)\n",
    "clipper_tmp = SeriesProcessor(clip_quantiles, series_names=\"TMP\", lower_q=0, upper_q=0.999)\n",
    "savgol_eda = SeriesProcessor(savgol_filter, \"EDA\", window_length=5, polyorder=2)\n",
    "savgol_acc = SeriesProcessor(savgol_filter, [\"ACC_x\", \"ACC_y\", \"ACC_z\"], window_length=33, polyorder=2)\n",
    "smv_processor = SeriesProcessor(smv, (\"ACC_x\", \"ACC_y\", \"ACC_z\"))\n",
    "clipper_smv = SeriesProcessor(clip_quantiles, \"ACC_SMV\")\n",
    "\n",
    "# -- 2. Create the series pipeline which wittholds a list of processors\n",
    "series_pipe = SeriesPipeline(\n",
    "    processors=[clipper_tmp, savgol_eda, savgol_acc, smv_processor, clipper_smv]\n",
    ")\n",
    "series_pipe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EDA\n",
      "ACC_x\n",
      "ACC_y\n",
      "ACC_z\n",
      "TMP\n",
      "ACC_SMV\n"
     ]
    }
   ],
   "source": [
    "# 3. Process the data\n",
    "out_data : List[pd.Series] = series_pipe.process(\n",
    "    [df_gsr, df_acc, df_tmp]\n",
    ")\n",
    "\n",
    "# update the df_gsr and the df_tmp, and save the df_smv\n",
    "for series in out_data:\n",
    "    print(series.name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Processing function logging"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `ProcessingPipeline` can also log the duration of it's `SeriesProcessor` steps\n",
    "\n",
    "To do so, one needs to set the `logging_file_path` argumetn and then call the `get_processor_logs()` method with this corresponding path to see the output dataframe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/snil/Documents/tsflex/tsflex/utils/logging.py:81: RuntimeWarning: Logging file (example_processing_logs.log) already exists. This file will be overwritten!\n",
      "  warnings.warn(\n"
     ]
    }
   ],
   "source": [
    "_ = series_pipe.process([df_gsr, df_acc, df_tmp], logging_file_path=\"example_processing_logs.log\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "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>log_time</th>\n",
       "      <th>function</th>\n",
       "      <th>series_names</th>\n",
       "      <th>output_names</th>\n",
       "      <th>duration</th>\n",
       "      <th>duration %</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2023-08-09 11:27:14.106</td>\n",
       "      <td>clip_quantiles</td>\n",
       "      <td>(TMP,)</td>\n",
       "      <td>TMP</td>\n",
       "      <td>0 days 00:00:00.001249584</td>\n",
       "      <td>6.05</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2023-08-09 11:27:14.107</td>\n",
       "      <td>savgol_filter</td>\n",
       "      <td>(EDA,)</td>\n",
       "      <td>EDA</td>\n",
       "      <td>0 days 00:00:00.000535822</td>\n",
       "      <td>2.59</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2023-08-09 11:27:14.118</td>\n",
       "      <td>savgol_filter</td>\n",
       "      <td>(ACC_x,), (ACC_y,), (ACC_z,)</td>\n",
       "      <td>ACC_x, ACC_y, ACC_z</td>\n",
       "      <td>0 days 00:00:00.011542282</td>\n",
       "      <td>55.89</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2023-08-09 11:27:14.122</td>\n",
       "      <td>smv</td>\n",
       "      <td>(ACC_x, ACC_y, ACC_z)</td>\n",
       "      <td>ACC_SMV</td>\n",
       "      <td>0 days 00:00:00.003439890</td>\n",
       "      <td>16.66</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2023-08-09 11:27:14.126</td>\n",
       "      <td>clip_quantiles</td>\n",
       "      <td>(ACC_SMV,)</td>\n",
       "      <td>ACC_SMV</td>\n",
       "      <td>0 days 00:00:00.003885668</td>\n",
       "      <td>18.81</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                 log_time        function                  series_names  \\\n",
       "0 2023-08-09 11:27:14.106  clip_quantiles                        (TMP,)   \n",
       "1 2023-08-09 11:27:14.107   savgol_filter                        (EDA,)   \n",
       "2 2023-08-09 11:27:14.118   savgol_filter  (ACC_x,), (ACC_y,), (ACC_z,)   \n",
       "3 2023-08-09 11:27:14.122             smv         (ACC_x, ACC_y, ACC_z)   \n",
       "4 2023-08-09 11:27:14.126  clip_quantiles                    (ACC_SMV,)   \n",
       "\n",
       "          output_names                  duration  duration %  \n",
       "0                  TMP 0 days 00:00:00.001249584        6.05  \n",
       "1                  EDA 0 days 00:00:00.000535822        2.59  \n",
       "2  ACC_x, ACC_y, ACC_z 0 days 00:00:00.011542282       55.89  \n",
       "3              ACC_SMV 0 days 00:00:00.003439890       16.66  \n",
       "4              ACC_SMV 0 days 00:00:00.003885668       18.81  "
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_processor_logs(\"example_processing_logs.log\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is especially useful to see which of the processing step is the bottleneck"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Feature extraction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "try: \n",
    "    from tsflex.features import FeatureCollection, FuncWrapper\n",
    "    from tsflex.features import FeatureDescriptor, MultipleFeatureDescriptors\n",
    "    from tsflex.features.logger import get_feature_logs\n",
    "except:\n",
    "    import sys\n",
    "    sys.path.append('../')\n",
    "    from tsflex.features import FeatureCollection, FuncWrapper\n",
    "    from tsflex.features import FeatureDescriptor, MultipleFeatureDescriptors\n",
    "    from tsflex.features.logger import get_feature_logs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Defining functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[link to docs](https://predict-idlab.github.io/tsflex/features/index.html#getting-started)**\n",
    "\n",
    "![features uml](https://raw.githubusercontent.com/predict-idlab/tsflex/main/docs/_static/features_uml.png)\n",
    "\n",
    "As shown above, there are 3 relevant classes for feature-extraction.\n",
    "\n",
    "1. [FeatureCollection](https://predict-idlab.github.io/tsflex/features/#tsflex.features.FeatureCollection): serves as a registry, withholding the to-be-calculated _features_\n",
    "2. [FeatureDescriptor](https://predict-idlab.github.io/tsflex/features/#tsflex.features.FeatureDescriptor): an instance of this class describes a _feature_. <br>Features are defined by:\n",
    "      * `series_name`: the names of the signal(s) which this feature will use. \n",
    "      * `function`: the _Callable_ feature-function - e.g. _np.mean_\n",
    "      * `window`: the _time-based_ window -  e.g. _\"1hour\"_\n",
    "      * `stride`: the _time-based_ stride - e.g. _\"2days\"_\n",
    "3. [NumpyFuncWrapper](https://predict-idlab.github.io/tsflex/features/#tsflex.features.NumpyFuncWrapper): a wrapper around _Callable_ functions, intended for advanced feature function definitions, such as:\n",
    "    * features with multiple output columns\n",
    "    * passing _**kwargs_ to feature functions\n",
    "\n",
    "\n",
    "**Note**: this library does `not` provide any feature-functions as:\n",
    "* There already exist many other feature extraction libraries such as numpy, scipy, tsfresh with which `tsflex` integrates.\n",
    "* (Relevant) features are dependent on the objective and signals-modalites, making features methods very problem specific.\n",
    "* Finally, as can be seen in the example below, our `NumpyFuncWrapper`'s `func`-attribute is versatile enough to wrap the end-user's desired features."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<function numpy.mean(a, axis=None, dtype=None, out=None, keepdims=<no value>, *, where=<no value>)>,\n",
       " <function numpy.std(a, axis=None, dtype=None, out=None, ddof=0, keepdims=<no value>, *, where=<no value>)>,\n",
       " <function numpy.var(a, axis=None, dtype=None, out=None, ddof=0, keepdims=<no value>, *, where=<no value>)>,\n",
       " <function numpy.amax(a, axis=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)>,\n",
       " <function numpy.amin(a, axis=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)>,\n",
       " <function scipy.stats._stats_py.skew(a, axis=0, bias=True, nan_policy='propagate', *, keepdims=False)>,\n",
       " <function scipy.stats._stats_py.kurtosis(a, axis=0, fisher=True, bias=True, nan_policy='propagate', *, keepdims=False)>,\n",
       " FuncWrapper(quantile, ['quantile_0.25', 'quantile_0.5', 'quantile_0.75'], {'q': [0.25, 0.5, 0.75]}),\n",
       " FuncWrapper(slope, ['slope'], {}),\n",
       " FuncWrapper(<lambda>, ['rms'], {}),\n",
       " FuncWrapper(sum, ['area'], {})]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# --------------------- some custom feature extraction functions ---------------------\n",
    "# -- 1. one-to-many functions\n",
    "#    To compute quantiles, you need sort the windowed data, which is a rather expensive\n",
    "#    operation O(n*log(n)). Hence, you might want to calculate all your desired \n",
    "#    quantiles in a single function-wrapper, returning multiple outputs.\n",
    "\n",
    "quantiles = [0.25, 0.5, 0.75]\n",
    "f_quantiles = FuncWrapper(\n",
    "    func=np.quantile,  # the wrapped function that will operate on numpy arrays\n",
    "    output_names=[f\"quantile_{q}\" for q in quantiles],  # the output column names\n",
    "    q=quantiles,  # optional - additional function-related kwargs\n",
    ")\n",
    "\n",
    "\n",
    "# -- 2. in-line functions\n",
    "#    You can define your functions locally; these will serialize flawlessly\n",
    "def slope(x):\n",
    "    return np.polyfit(np.arange(0, len(x)), x, 1)[0]\n",
    "\n",
    "f_slope = FuncWrapper(slope, output_names=\"slope\")\n",
    "\n",
    "# -- 3. Lambda's\n",
    "#    Or even use lambda's and other modules' functions\n",
    "f_rms = FuncWrapper(lambda x: np.sqrt(np.mean(x ** 2)), output_names=\"rms\")\n",
    "f_area = FuncWrapper(np.sum, output_names=\"area\")\n",
    "\n",
    "\n",
    "# (For convenience) we store the constructed `NumpyFuncWrappers` in a list\n",
    "segment_funcs = [\n",
    "    np.mean,\n",
    "    np.std,\n",
    "    np.var,\n",
    "    np.max,\n",
    "    np.min,\n",
    "    ss.skew,  # use other libraries such as scipy\n",
    "    ss.kurtosis,\n",
    "    f_quantiles,\n",
    "    f_slope,\n",
    "    f_rms,\n",
    "    f_area,\n",
    "]\n",
    "segment_funcs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Single series feature extraction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The defined functions above will be encapsulated in a [FeatureDescriptor](https://predict-idlab.github.io/tsflex/features/index.html#tsflex.features.FeatureDescriptor) object.\n",
    "\n",
    "A `FeatureDescriptor` describes a feature, and has 4 main attributes:\n",
    "\n",
    "<center>\n",
    "\n",
    "## Featuredescriptor constructor args:\n",
    "\n",
    "| attribute | type | info |\n",
    "| --------: | :--: | ---- |\n",
    "| `function` | Union[Callable, <br>NumpyFuncWrapper] | The `function` that calculates this feature. |\n",
    "|      `key` |           Tuple[str, ...]             | The signal key; i.e., the `pd.DataFrame` column name or <br> `pd.Series` name on which the function will operate. |\n",
    "|   `window` |      Union[str, pd.timedelta]         | The window size on which this feature will be applied, <br> expressed in a **time-based** manner. |\n",
    "|   `stride` |      Union[str, pd.timedelta]         | The stride of the window rolling process, also as <br> expressed in a **time-based** manner |\n",
    "\n",
    "</center>\n",
    "\n",
    "\n",
    "**note**: [MultipleFeatureDescriptor](https://predict-idlab.github.io/tsflex/features/index.html#tsflex.features.MultipleFeatureDescriptors) is actaully a factory for `FeatureDescriptor` objects."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Fixed window size & stride"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**note**: this functionality is exposed by most existing time-series libraries (often on a sample-based matter).\n",
    "\n",
    "In this example, we will use the _temperature_ signal from a wearable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "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>TMP</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>timestamp</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2017-06-13 15:14:15.500000+02:00</th>\n",
       "      <td>34.450001</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2017-06-13 15:37:18.750000+02:00</th>\n",
       "      <td>34.970001</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                        TMP\n",
       "timestamp                                  \n",
       "2017-06-13 15:14:15.500000+02:00  34.450001\n",
       "2017-06-13 15:37:18.750000+02:00  34.970001"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_tmp.sample(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note how the `TMP`-column is used as signal_key in the `FeatureCollection`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TMP: (\n",
       "\twin: 1m    : [\n",
       "\t\tFeatureDescriptor - func: FuncWrapper(mean, ['mean'], {})    stride: ['30s'],\n",
       "\t\tFeatureDescriptor - func: FuncWrapper(std, ['std'], {})    stride: ['30s'],\n",
       "\t\tFeatureDescriptor - func: FuncWrapper(var, ['var'], {})    stride: ['30s'],\n",
       "\t\tFeatureDescriptor - func: FuncWrapper(amax, ['amax'], {})    stride: ['30s'],\n",
       "\t\tFeatureDescriptor - func: FuncWrapper(amin, ['amin'], {})    stride: ['30s'],\n",
       "\t\tFeatureDescriptor - func: FuncWrapper(skew, ['skew'], {})    stride: ['30s'],\n",
       "\t\tFeatureDescriptor - func: FuncWrapper(kurtosis, ['kurtosis'], {})    stride: ['30s'],\n",
       "\t\tFeatureDescriptor - func: FuncWrapper(quantile, ['quantile_0.25', 'quantile_0.5', 'quantile_0.75'], {'q': [0.25, 0.5, 0.75]})    stride: ['30s'],\n",
       "\t\tFeatureDescriptor - func: FuncWrapper(slope, ['slope'], {})    stride: ['30s'],\n",
       "\t\tFeatureDescriptor - func: FuncWrapper(<lambda>, ['rms'], {})    stride: ['30s'],\n",
       "\t\tFeatureDescriptor - func: FuncWrapper(sum, ['area'], {})    stride: ['30s'],\n",
       "\t]\n",
       ")"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Define the sample frequency and window size\n",
    "tmp_feat_extr = FeatureCollection(\n",
    "    feature_descriptors=[\n",
    "        MultipleFeatureDescriptors(\n",
    "            functions=segment_funcs,  # The list of functions we constructed earlier\n",
    "            series_names=[\"TMP\"],\n",
    "            windows='60s',\n",
    "            strides='30s',\n",
    "        )\n",
    "    ]\n",
    ")\n",
    "\n",
    "# The FeatureCollection's __repr__() gives a nice overview of the structure\n",
    "tmp_feat_extr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "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>TMP__amax__w=1m</th>\n",
       "      <th>TMP__amin__w=1m</th>\n",
       "      <th>TMP__area__w=1m</th>\n",
       "      <th>TMP__kurtosis__w=1m</th>\n",
       "      <th>TMP__mean__w=1m</th>\n",
       "      <th>TMP__quantile_0.25__w=1m</th>\n",
       "      <th>TMP__quantile_0.5__w=1m</th>\n",
       "      <th>TMP__quantile_0.75__w=1m</th>\n",
       "      <th>TMP__rms__w=1m</th>\n",
       "      <th>TMP__skew__w=1m</th>\n",
       "      <th>TMP__slope__w=1m</th>\n",
       "      <th>TMP__std__w=1m</th>\n",
       "      <th>TMP__var__w=1m</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>timestamp</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2017-06-13 16:10:43+02:00</th>\n",
       "      <td>30.670000</td>\n",
       "      <td>30.51</td>\n",
       "      <td>7341.119629</td>\n",
       "      <td>-0.190920</td>\n",
       "      <td>30.587999</td>\n",
       "      <td>30.570000</td>\n",
       "      <td>30.590000</td>\n",
       "      <td>30.610001</td>\n",
       "      <td>30.588018</td>\n",
       "      <td>0.184326</td>\n",
       "      <td>0.000359</td>\n",
       "      <td>0.032599</td>\n",
       "      <td>0.001063</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2017-06-13 15:14:43+02:00</th>\n",
       "      <td>34.610001</td>\n",
       "      <td>34.43</td>\n",
       "      <td>8282.679688</td>\n",
       "      <td>-1.381112</td>\n",
       "      <td>34.511166</td>\n",
       "      <td>34.450001</td>\n",
       "      <td>34.490002</td>\n",
       "      <td>34.570000</td>\n",
       "      <td>34.511223</td>\n",
       "      <td>0.391330</td>\n",
       "      <td>-0.000798</td>\n",
       "      <td>0.061267</td>\n",
       "      <td>0.003754</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                           TMP__amax__w=1m  TMP__amin__w=1m  TMP__area__w=1m  \\\n",
       "timestamp                                                                      \n",
       "2017-06-13 16:10:43+02:00        30.670000            30.51      7341.119629   \n",
       "2017-06-13 15:14:43+02:00        34.610001            34.43      8282.679688   \n",
       "\n",
       "                           TMP__kurtosis__w=1m  TMP__mean__w=1m  \\\n",
       "timestamp                                                         \n",
       "2017-06-13 16:10:43+02:00            -0.190920        30.587999   \n",
       "2017-06-13 15:14:43+02:00            -1.381112        34.511166   \n",
       "\n",
       "                           TMP__quantile_0.25__w=1m  TMP__quantile_0.5__w=1m  \\\n",
       "timestamp                                                                      \n",
       "2017-06-13 16:10:43+02:00                 30.570000                30.590000   \n",
       "2017-06-13 15:14:43+02:00                 34.450001                34.490002   \n",
       "\n",
       "                           TMP__quantile_0.75__w=1m  TMP__rms__w=1m  \\\n",
       "timestamp                                                             \n",
       "2017-06-13 16:10:43+02:00                 30.610001       30.588018   \n",
       "2017-06-13 15:14:43+02:00                 34.570000       34.511223   \n",
       "\n",
       "                           TMP__skew__w=1m  TMP__slope__w=1m  TMP__std__w=1m  \\\n",
       "timestamp                                                                      \n",
       "2017-06-13 16:10:43+02:00         0.184326          0.000359        0.032599   \n",
       "2017-06-13 15:14:43+02:00         0.391330         -0.000798        0.061267   \n",
       "\n",
       "                           TMP__var__w=1m  \n",
       "timestamp                                  \n",
       "2017-06-13 16:10:43+02:00        0.001063  \n",
       "2017-06-13 15:14:43+02:00        0.003754  "
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# to extract the features we just call the collection's `calculate()` function\n",
    "extracted_feats = tmp_feat_extr.calculate(\n",
    "    data=out_data,    # The signals on which features are calculated\n",
    "    # NOTE: out_data withholds the updated TMP signal\n",
    "    return_df=True,  # If true, an outer merge on the feature-outputs will be performed\n",
    "    n_jobs=2         # If > 1, the feature extraction is parallellized\n",
    ")\n",
    "\n",
    "extracted_feats.sample(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Multiple `time-based` window sizes and strides"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_In this example, we use **multiple** stride-window-size combinations on a wearables' ElectorDermal Activity (EDA)_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that we do not use int-based window-stride combinations, but `time-based` ones. Also take a closer look at the `__repr__` string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EDA: (\n",
      "\twin: 30s   : [\n",
      "\t\tFeatureDescriptor - func: FuncWrapper(mean, ['mean'], {})    stride: ['30s'],\n",
      "\t\tFeatureDescriptor - func: FuncWrapper(var, ['var'], {})    stride: ['30s'],\n",
      "\t\tFeatureDescriptor - func: FuncWrapper(slope, ['slope'], {})    stride: ['15s'],\n",
      "\t]\n",
      "\twin: 1m30s : [\n",
      "\t\tFeatureDescriptor - func: FuncWrapper(std, ['std'], {})    stride: ['30s'],\n",
      "\t\tFeatureDescriptor - func: FuncWrapper(kurtosis, ['kurtosis'], {})    stride: ['15s'],\n",
      "\t\tFeatureDescriptor - func: FuncWrapper(sum, ['area'], {})    stride: ['30s'],\n",
      "\t]\n",
      "\twin: 1h    : [\n",
      "\t\tFeatureDescriptor - func: FuncWrapper(amax, ['amax'], {})    stride: ['30s'],\n",
      "\t\tFeatureDescriptor - func: FuncWrapper(quantile, ['quantile_0.25', 'quantile_0.5', 'quantile_0.75'], {'q': [0.25, 0.5, 0.75]})    stride: ['30s'],\n",
      "\t]\n",
      "\twin: 2m    : [\n",
      "\t\tFeatureDescriptor - func: FuncWrapper(amin, ['amin'], {})    stride: ['15s'],\n",
      "\t\tFeatureDescriptor - func: FuncWrapper(skew, ['skew'], {})    stride: ['15s'],\n",
      "\t\tFeatureDescriptor - func: FuncWrapper(<lambda>, ['rms'], {})    stride: ['15s'],\n",
      "\t]\n",
      ")\n",
      "\n",
      "------------------------------------------------------------\n"
     ]
    },
    {
     "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>EDA__amax__w=1h</th>\n",
       "      <th>EDA__amin__w=2m</th>\n",
       "      <th>EDA__area__w=1m30s</th>\n",
       "      <th>EDA__kurtosis__w=1m30s</th>\n",
       "      <th>EDA__mean__w=30s</th>\n",
       "      <th>EDA__quantile_0.25__w=1h</th>\n",
       "      <th>EDA__quantile_0.5__w=1h</th>\n",
       "      <th>EDA__quantile_0.75__w=1h</th>\n",
       "      <th>EDA__rms__w=2m</th>\n",
       "      <th>EDA__skew__w=2m</th>\n",
       "      <th>EDA__slope__w=30s</th>\n",
       "      <th>EDA__std__w=1m30s</th>\n",
       "      <th>EDA__var__w=30s</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>timestamp</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2017-06-13 16:10:58+02:00</th>\n",
       "      <td>NaN</td>\n",
       "      <td>1.110558</td>\n",
       "      <td>NaN</td>\n",
       "      <td>1.415249</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>1.146106</td>\n",
       "      <td>0.161287</td>\n",
       "      <td>-0.000208</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2017-06-13 16:26:13+02:00</th>\n",
       "      <td>4.738588</td>\n",
       "      <td>0.753633</td>\n",
       "      <td>350.18045</td>\n",
       "      <td>1.489872</td>\n",
       "      <td>0.896758</td>\n",
       "      <td>1.053005</td>\n",
       "      <td>1.526214</td>\n",
       "      <td>2.536808</td>\n",
       "      <td>0.979037</td>\n",
       "      <td>-0.808600</td>\n",
       "      <td>-0.000461</td>\n",
       "      <td>0.084573</td>\n",
       "      <td>0.010754</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                           EDA__amax__w=1h  EDA__amin__w=2m  \\\n",
       "timestamp                                                     \n",
       "2017-06-13 16:10:58+02:00              NaN         1.110558   \n",
       "2017-06-13 16:26:13+02:00         4.738588         0.753633   \n",
       "\n",
       "                           EDA__area__w=1m30s  EDA__kurtosis__w=1m30s  \\\n",
       "timestamp                                                               \n",
       "2017-06-13 16:10:58+02:00                 NaN                1.415249   \n",
       "2017-06-13 16:26:13+02:00           350.18045                1.489872   \n",
       "\n",
       "                           EDA__mean__w=30s  EDA__quantile_0.25__w=1h  \\\n",
       "timestamp                                                               \n",
       "2017-06-13 16:10:58+02:00               NaN                       NaN   \n",
       "2017-06-13 16:26:13+02:00          0.896758                  1.053005   \n",
       "\n",
       "                           EDA__quantile_0.5__w=1h  EDA__quantile_0.75__w=1h  \\\n",
       "timestamp                                                                      \n",
       "2017-06-13 16:10:58+02:00                      NaN                       NaN   \n",
       "2017-06-13 16:26:13+02:00                 1.526214                  2.536808   \n",
       "\n",
       "                           EDA__rms__w=2m  EDA__skew__w=2m  EDA__slope__w=30s  \\\n",
       "timestamp                                                                       \n",
       "2017-06-13 16:10:58+02:00        1.146106         0.161287          -0.000208   \n",
       "2017-06-13 16:26:13+02:00        0.979037        -0.808600          -0.000461   \n",
       "\n",
       "                           EDA__std__w=1m30s  EDA__var__w=30s  \n",
       "timestamp                                                      \n",
       "2017-06-13 16:10:58+02:00                NaN              NaN  \n",
       "2017-06-13 16:26:13+02:00           0.084573         0.010754  "
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# PoC: we will select a random combination of the window_size stride combination\n",
    "window_size_s = ['30s', '120s', '90s', '1h']\n",
    "stride_size_s = ['15s', '30s']\n",
    "\n",
    "import random\n",
    "\n",
    "gsr_feat_extr = FeatureCollection(\n",
    "    [\n",
    "        FeatureDescriptor(\n",
    "            series_name=\"EDA\",\n",
    "            window=random.choice(window_size_s),\n",
    "            stride=random.choice(stride_size_s),\n",
    "            function=f,\n",
    "        )\n",
    "        for f in segment_funcs\n",
    "    ]\n",
    ")\n",
    "\n",
    "# the __repr__ string outputs the windows & strides in a time-string representation :)\n",
    "print(gsr_feat_extr)\n",
    "print('-'*60)\n",
    "gsr_feat_extr.calculate(df_gsr, return_df=True, show_progress=False, n_jobs=None).sample(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**note**: The `NaN` values in the above pd.DataFrame are cause by the outer merge which we do to retain the time-indices. Various feature were extracted at different windows & strides, thus making few features share the same time-indices.\n",
    "<br><br>\n",
    "If we set `return_df=False`, a `List[pd.Series]` will be returned"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11\n"
     ]
    },
    {
     "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>EDA__area__w=1m30s</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>timestamp</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2017-06-13 15:14:43+02:00</th>\n",
       "      <td>596.880798</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2017-06-13 15:40:43+02:00</th>\n",
       "      <td>789.627686</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2017-06-13 15:16:43+02:00</th>\n",
       "      <td>518.155457</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                           EDA__area__w=1m30s\n",
       "timestamp                                    \n",
       "2017-06-13 15:14:43+02:00          596.880798\n",
       "2017-06-13 15:40:43+02:00          789.627686\n",
       "2017-06-13 15:16:43+02:00          518.155457"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "feat_list : List[pd.Series] = gsr_feat_extr.calculate(df_gsr, return_df=False, show_progress=False, n_jobs=None)\n",
    "print(len(feat_list))\n",
    "feat_list[0].sample(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Multiple series feature extraction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EDA: (\n",
      "\twin: 30s   : [\n",
      "\t\tFeatureDescriptor - func: FuncWrapper(mean, ['mean'], {})    stride: ['30s'],\n",
      "\t\tFeatureDescriptor - func: FuncWrapper(var, ['var'], {})    stride: ['30s'],\n",
      "\t\tFeatureDescriptor - func: FuncWrapper(slope, ['slope'], {})    stride: ['15s'],\n",
      "\t]\n",
      "\twin: 1m30s : [\n",
      "\t\tFeatureDescriptor - func: FuncWrapper(std, ['std'], {})    stride: ['30s'],\n",
      "\t\tFeatureDescriptor - func: FuncWrapper(kurtosis, ['kurtosis'], {})    stride: ['15s'],\n",
      "\t\tFeatureDescriptor - func: FuncWrapper(sum, ['area'], {})    stride: ['30s'],\n",
      "\t]\n",
      "\twin: 1h    : [\n",
      "\t\tFeatureDescriptor - func: FuncWrapper(amax, ['amax'], {})    stride: ['30s'],\n",
      "\t\tFeatureDescriptor - func: FuncWrapper(quantile, ['quantile_0.25', 'quantile_0.5', 'quantile_0.75'], {'q': [0.25, 0.5, 0.75]})    stride: ['30s'],\n",
      "\t]\n",
      "\twin: 2m    : [\n",
      "\t\tFeatureDescriptor - func: FuncWrapper(amin, ['amin'], {})    stride: ['15s'],\n",
      "\t\tFeatureDescriptor - func: FuncWrapper(skew, ['skew'], {})    stride: ['15s'],\n",
      "\t\tFeatureDescriptor - func: FuncWrapper(<lambda>, ['rms'], {})    stride: ['15s'],\n",
      "\t]\n",
      ")\n",
      "TMP: (\n",
      "\twin: 1m    : [\n",
      "\t\tFeatureDescriptor - func: FuncWrapper(mean, ['mean'], {})    stride: ['30s'],\n",
      "\t\tFeatureDescriptor - func: FuncWrapper(std, ['std'], {})    stride: ['30s'],\n",
      "\t\tFeatureDescriptor - func: FuncWrapper(var, ['var'], {})    stride: ['30s'],\n",
      "\t\tFeatureDescriptor - func: FuncWrapper(amax, ['amax'], {})    stride: ['30s'],\n",
      "\t\tFeatureDescriptor - func: FuncWrapper(amin, ['amin'], {})    stride: ['30s'],\n",
      "\t\tFeatureDescriptor - func: FuncWrapper(skew, ['skew'], {})    stride: ['30s'],\n",
      "\t\tFeatureDescriptor - func: FuncWrapper(kurtosis, ['kurtosis'], {})    stride: ['30s'],\n",
      "\t\tFeatureDescriptor - func: FuncWrapper(quantile, ['quantile_0.25', 'quantile_0.5', 'quantile_0.75'], {'q': [0.25, 0.5, 0.75]})    stride: ['30s'],\n",
      "\t\tFeatureDescriptor - func: FuncWrapper(slope, ['slope'], {})    stride: ['30s'],\n",
      "\t\tFeatureDescriptor - func: FuncWrapper(<lambda>, ['rms'], {})    stride: ['30s'],\n",
      "\t\tFeatureDescriptor - func: FuncWrapper(sum, ['area'], {})    stride: ['30s'],\n",
      "\t]\n",
      ")\n",
      "\n",
      "------------------------------------------------------------\n"
     ]
    },
    {
     "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>EDA__amax__w=1h</th>\n",
       "      <th>EDA__amin__w=2m</th>\n",
       "      <th>EDA__area__w=1m30s</th>\n",
       "      <th>EDA__kurtosis__w=1m30s</th>\n",
       "      <th>EDA__mean__w=30s</th>\n",
       "      <th>EDA__quantile_0.25__w=1h</th>\n",
       "      <th>EDA__quantile_0.5__w=1h</th>\n",
       "      <th>EDA__quantile_0.75__w=1h</th>\n",
       "      <th>EDA__rms__w=2m</th>\n",
       "      <th>EDA__skew__w=2m</th>\n",
       "      <th>...</th>\n",
       "      <th>TMP__kurtosis__w=1m</th>\n",
       "      <th>TMP__mean__w=1m</th>\n",
       "      <th>TMP__quantile_0.25__w=1m</th>\n",
       "      <th>TMP__quantile_0.5__w=1m</th>\n",
       "      <th>TMP__quantile_0.75__w=1m</th>\n",
       "      <th>TMP__rms__w=1m</th>\n",
       "      <th>TMP__skew__w=1m</th>\n",
       "      <th>TMP__slope__w=1m</th>\n",
       "      <th>TMP__std__w=1m</th>\n",
       "      <th>TMP__var__w=1m</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>timestamp</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2017-06-13 15:26:58+02:00</th>\n",
       "      <td>NaN</td>\n",
       "      <td>1.722092</td>\n",
       "      <td>NaN</td>\n",
       "      <td>-0.796609</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>1.949415</td>\n",
       "      <td>0.345014</td>\n",
       "      <td>...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2017-06-13 15:00:58+02:00</th>\n",
       "      <td>NaN</td>\n",
       "      <td>0.726775</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.724335</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.751184</td>\n",
       "      <td>0.649367</td>\n",
       "      <td>...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>2 rows × 26 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                           EDA__amax__w=1h  EDA__amin__w=2m  \\\n",
       "timestamp                                                     \n",
       "2017-06-13 15:26:58+02:00              NaN         1.722092   \n",
       "2017-06-13 15:00:58+02:00              NaN         0.726775   \n",
       "\n",
       "                           EDA__area__w=1m30s  EDA__kurtosis__w=1m30s  \\\n",
       "timestamp                                                               \n",
       "2017-06-13 15:26:58+02:00                 NaN               -0.796609   \n",
       "2017-06-13 15:00:58+02:00                 NaN                0.724335   \n",
       "\n",
       "                           EDA__mean__w=30s  EDA__quantile_0.25__w=1h  \\\n",
       "timestamp                                                               \n",
       "2017-06-13 15:26:58+02:00               NaN                       NaN   \n",
       "2017-06-13 15:00:58+02:00               NaN                       NaN   \n",
       "\n",
       "                           EDA__quantile_0.5__w=1h  EDA__quantile_0.75__w=1h  \\\n",
       "timestamp                                                                      \n",
       "2017-06-13 15:26:58+02:00                      NaN                       NaN   \n",
       "2017-06-13 15:00:58+02:00                      NaN                       NaN   \n",
       "\n",
       "                           EDA__rms__w=2m  EDA__skew__w=2m  ...  \\\n",
       "timestamp                                                   ...   \n",
       "2017-06-13 15:26:58+02:00        1.949415         0.345014  ...   \n",
       "2017-06-13 15:00:58+02:00        0.751184         0.649367  ...   \n",
       "\n",
       "                           TMP__kurtosis__w=1m  TMP__mean__w=1m  \\\n",
       "timestamp                                                         \n",
       "2017-06-13 15:26:58+02:00                  NaN              NaN   \n",
       "2017-06-13 15:00:58+02:00                  NaN              NaN   \n",
       "\n",
       "                           TMP__quantile_0.25__w=1m  TMP__quantile_0.5__w=1m  \\\n",
       "timestamp                                                                      \n",
       "2017-06-13 15:26:58+02:00                       NaN                      NaN   \n",
       "2017-06-13 15:00:58+02:00                       NaN                      NaN   \n",
       "\n",
       "                           TMP__quantile_0.75__w=1m  TMP__rms__w=1m  \\\n",
       "timestamp                                                             \n",
       "2017-06-13 15:26:58+02:00                       NaN             NaN   \n",
       "2017-06-13 15:00:58+02:00                       NaN             NaN   \n",
       "\n",
       "                           TMP__skew__w=1m  TMP__slope__w=1m  TMP__std__w=1m  \\\n",
       "timestamp                                                                      \n",
       "2017-06-13 15:26:58+02:00              NaN               NaN             NaN   \n",
       "2017-06-13 15:00:58+02:00              NaN               NaN             NaN   \n",
       "\n",
       "                           TMP__var__w=1m  \n",
       "timestamp                                  \n",
       "2017-06-13 15:26:58+02:00             NaN  \n",
       "2017-06-13 15:00:58+02:00             NaN  \n",
       "\n",
       "[2 rows x 26 columns]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Construct the feature FeatureCollection\n",
    "#   =  higher order wrapper which aggregates the featuredescriptions\n",
    "multimodal_feature_extraction = FeatureCollection(\n",
    "    feature_descriptors=[gsr_feat_extr, tmp_feat_extr]\n",
    ")\n",
    "\n",
    "print(multimodal_feature_extraction)\n",
    "print('-'*60)\n",
    "\n",
    "df_feat = multimodal_feature_extraction.calculate(\n",
    "    [df_gsr, df_tmp], return_df=True\n",
    ")\n",
    "df_feat.sample(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Grouping feature extraction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "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>store</th>\n",
       "      <th>product</th>\n",
       "      <th>number_sold</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2019-01-01</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>845</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-01-02</th>\n",
       "      <td>3</td>\n",
       "      <td>7</td>\n",
       "      <td>357</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-01-03</th>\n",
       "      <td>6</td>\n",
       "      <td>1</td>\n",
       "      <td>904</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-01-04</th>\n",
       "      <td>3</td>\n",
       "      <td>8</td>\n",
       "      <td>273</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-01-05</th>\n",
       "      <td>3</td>\n",
       "      <td>9</td>\n",
       "      <td>326</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2088-12-09</th>\n",
       "      <td>4</td>\n",
       "      <td>7</td>\n",
       "      <td>982</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2088-12-10</th>\n",
       "      <td>4</td>\n",
       "      <td>8</td>\n",
       "      <td>967</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2088-12-11</th>\n",
       "      <td>4</td>\n",
       "      <td>9</td>\n",
       "      <td>1020</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2088-12-12</th>\n",
       "      <td>4</td>\n",
       "      <td>3</td>\n",
       "      <td>976</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2088-12-13</th>\n",
       "      <td>6</td>\n",
       "      <td>9</td>\n",
       "      <td>886</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>25550 rows × 3 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "            store  product  number_sold\n",
       "2019-01-01      0        0          845\n",
       "2019-01-02      3        7          357\n",
       "2019-01-03      6        1          904\n",
       "2019-01-04      3        8          273\n",
       "2019-01-05      3        9          326\n",
       "...           ...      ...          ...\n",
       "2088-12-09      4        7          982\n",
       "2088-12-10      4        8          967\n",
       "2088-12-11      4        9         1020\n",
       "2088-12-12      4        3          976\n",
       "2088-12-13      6        9          886\n",
       "\n",
       "[25550 rows x 3 columns]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Loading data\n",
    "df_grp = pd.read_parquet(\"data/grouped_data.parquet\").set_index(\"Date\")\n",
    "df_grp = df_grp.sort_index()\n",
    "df_grp.set_index(\n",
    "    pd.date_range(\"2019-01-01\", periods=len(df_grp.index), freq=\"D\"), inplace=True\n",
    ")\n",
    "\n",
    "\n",
    "# !!! The data MUST datetime Indexed\n",
    "assert isinstance(df_grp.index, pd.DatetimeIndex)\n",
    "\n",
    "df_grp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "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>number_sold__amin__w=manual</th>\n",
       "      <th>number_sold__amax__w=manual</th>\n",
       "      <th>number_sold__mean__w=manual</th>\n",
       "      <th>number_sold__var__w=manual</th>\n",
       "      <th>number_sold__std__w=manual</th>\n",
       "      <th>store</th>\n",
       "      <th>__start</th>\n",
       "      <th>__end</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>845</td>\n",
       "      <td>845</td>\n",
       "      <td>845.000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0</td>\n",
       "      <td>2019-01-01</td>\n",
       "      <td>2019-01-01</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>357</td>\n",
       "      <td>357</td>\n",
       "      <td>357.000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>3</td>\n",
       "      <td>2019-01-02</td>\n",
       "      <td>2019-01-02</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>904</td>\n",
       "      <td>904</td>\n",
       "      <td>904.000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>6</td>\n",
       "      <td>2019-01-03</td>\n",
       "      <td>2019-01-03</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>273</td>\n",
       "      <td>326</td>\n",
       "      <td>299.500</td>\n",
       "      <td>702.250000</td>\n",
       "      <td>26.500000</td>\n",
       "      <td>3</td>\n",
       "      <td>2019-01-04</td>\n",
       "      <td>2019-01-05</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>871</td>\n",
       "      <td>871</td>\n",
       "      <td>871.000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0</td>\n",
       "      <td>2019-01-06</td>\n",
       "      <td>2019-01-06</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>22117</th>\n",
       "      <td>275</td>\n",
       "      <td>360</td>\n",
       "      <td>333.000</td>\n",
       "      <td>1158.500000</td>\n",
       "      <td>34.036745</td>\n",
       "      <td>3</td>\n",
       "      <td>2088-11-28</td>\n",
       "      <td>2088-12-01</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>22118</th>\n",
       "      <td>963</td>\n",
       "      <td>1084</td>\n",
       "      <td>1023.500</td>\n",
       "      <td>3660.250000</td>\n",
       "      <td>60.500000</td>\n",
       "      <td>4</td>\n",
       "      <td>2088-12-02</td>\n",
       "      <td>2088-12-03</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>22119</th>\n",
       "      <td>323</td>\n",
       "      <td>323</td>\n",
       "      <td>323.000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>3</td>\n",
       "      <td>2088-12-04</td>\n",
       "      <td>2088-12-04</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>22120</th>\n",
       "      <td>887</td>\n",
       "      <td>1045</td>\n",
       "      <td>982.875</td>\n",
       "      <td>2350.859375</td>\n",
       "      <td>48.485662</td>\n",
       "      <td>4</td>\n",
       "      <td>2088-12-05</td>\n",
       "      <td>2088-12-12</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>22121</th>\n",
       "      <td>886</td>\n",
       "      <td>886</td>\n",
       "      <td>886.000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>6</td>\n",
       "      <td>2088-12-13</td>\n",
       "      <td>2088-12-13</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>22122 rows × 8 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "       number_sold__amin__w=manual  number_sold__amax__w=manual  \\\n",
       "0                              845                          845   \n",
       "1                              357                          357   \n",
       "2                              904                          904   \n",
       "3                              273                          326   \n",
       "4                              871                          871   \n",
       "...                            ...                          ...   \n",
       "22117                          275                          360   \n",
       "22118                          963                         1084   \n",
       "22119                          323                          323   \n",
       "22120                          887                         1045   \n",
       "22121                          886                          886   \n",
       "\n",
       "       number_sold__mean__w=manual  number_sold__var__w=manual  \\\n",
       "0                          845.000                    0.000000   \n",
       "1                          357.000                    0.000000   \n",
       "2                          904.000                    0.000000   \n",
       "3                          299.500                  702.250000   \n",
       "4                          871.000                    0.000000   \n",
       "...                            ...                         ...   \n",
       "22117                      333.000                 1158.500000   \n",
       "22118                     1023.500                 3660.250000   \n",
       "22119                      323.000                    0.000000   \n",
       "22120                      982.875                 2350.859375   \n",
       "22121                      886.000                    0.000000   \n",
       "\n",
       "       number_sold__std__w=manual  store    __start      __end  \n",
       "0                        0.000000      0 2019-01-01 2019-01-01  \n",
       "1                        0.000000      3 2019-01-02 2019-01-02  \n",
       "2                        0.000000      6 2019-01-03 2019-01-03  \n",
       "3                       26.500000      3 2019-01-04 2019-01-05  \n",
       "4                        0.000000      0 2019-01-06 2019-01-06  \n",
       "...                           ...    ...        ...        ...  \n",
       "22117                   34.036745      3 2088-11-28 2088-12-01  \n",
       "22118                   60.500000      4 2088-12-02 2088-12-03  \n",
       "22119                    0.000000      3 2088-12-04 2088-12-04  \n",
       "22120                   48.485662      4 2088-12-05 2088-12-12  \n",
       "22121                    0.000000      6 2088-12-13 2088-12-13  \n",
       "\n",
       "[22122 rows x 8 columns]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Grouping data\n",
    "\n",
    "grp_segment_funcs = [\n",
    "    np.mean,\n",
    "    np.std,\n",
    "    np.var,\n",
    "    np.max,\n",
    "    np.min\n",
    "]\n",
    "\n",
    "grp_feat_extr = FeatureCollection(\n",
    "    feature_descriptors=[\n",
    "        MultipleFeatureDescriptors(\n",
    "            functions=grp_segment_funcs,  # The list of functions we constructed earlier\n",
    "            series_names=[\"number_sold\"],\n",
    "        )\n",
    "    ]\n",
    ")\n",
    "\n",
    "\n",
    "grp_grouped_df = grp_feat_extr.calculate(df_grp, group_by=\"store\", return_df=True)\n",
    "\n",
    "grp_grouped_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Logging"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `FeatureCollection` can also log the duration of it's `Features`\n",
    "\n",
    "To do so, one needs to set the `logging_file_path` argumetn and then call the `get_feature_logs()` method with this corresponding path to see the output dataframe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/snil/Documents/tsflex/tsflex/utils/logging.py:81: RuntimeWarning: Logging file (example_feature_logs.log) already exists. This file will be overwritten!\n",
      "  warnings.warn(\n"
     ]
    }
   ],
   "source": [
    "multimodal_feature_extraction.calculate(out_data, logging_file_path=\"example_feature_logs.log\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "get_feature_logs(\"example_feature_logs.log\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is especially  useful for optimizing to see which features are the bottleneck"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Use case: batch-based feature extraction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tsflex.chunking import chunk_data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* maybe execute this on a highdimensional series, like the `sleep data`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "same_range_chunks = chunk_data(\n",
    "    data=[df_tmp],\n",
    "    fs_dict={\"EDA\": 4, \"TMP\": 4},\n",
    "    max_chunk_dur='10min'\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Serialization"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Serialization is mandatory to store and share your pipelines.\n",
    "`TODO`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "multimodal_feature_extraction.serialize(\"data/example_serialization.pkl\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Bonus - Get LAYD: Look At Your Data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And as a bonus, for running/reading this notebook, you get some nice visualization code, for\n",
    "ofcourse time-series."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# !pip install ipywidgets\n",
    "# !pip install plotly\n",
    "import ipywidgets as widgets\n",
    "import plotly.graph_objects as go\n",
    "from ipywidgets import interact_manual\n",
    "from plotly.subplots import make_subplots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_dict = {\"tmp\": df_tmp, \"gsr\": df_gsr}\n",
    "feat_widget = widgets.SelectMultiple(options=df_feat.columns)\n",
    "sig_widget = widgets.SelectMultiple(options=[\"gsr\", \"tmp\"])\n",
    "\n",
    "\n",
    "@interact_manual\n",
    "def visuzalize(features=feat_widget, signals=sig_widget):\n",
    "    row_titles = list(signals) + [\"features\"] if len(features) else []\n",
    "    fig = make_subplots(\n",
    "        rows=len(row_titles),\n",
    "        cols=1,\n",
    "        shared_xaxes=True,\n",
    "        vertical_spacing=0.1 / len(row_titles),\n",
    "        row_titles=row_titles,\n",
    "    )\n",
    "    fig.update_layout(height=300 * len(row_titles))\n",
    "\n",
    "    # first, visualize the \"raw\" signals\n",
    "    row_idx = 1\n",
    "    for sig in signals:\n",
    "        df_sig = df_dict[sig][10:].resample(\"1s\").mean()\n",
    "        for col in set(df_sig.columns).difference([\"index\", \"timestamp\"]):\n",
    "            fig.add_trace(\n",
    "                go.Scattergl(x=df_sig.index, y=df_sig[col], name=col, hoverinfo=\"skip\"),\n",
    "                row=row_idx,\n",
    "                col=1,\n",
    "            )\n",
    "        row_idx += 1\n",
    "\n",
    "    # then visualize the features\n",
    "    for feature in features:\n",
    "        df_ff = df_feat[feature].dropna()\n",
    "        fig.add_trace(\n",
    "            go.Scattergl(\n",
    "                connectgaps=True,\n",
    "                x=df_ff.index,\n",
    "                y=df_ff,\n",
    "                name=feature,\n",
    "                hoverinfo=\"skip\",\n",
    "                mode=\"markers\",\n",
    "                showlegend=True,\n",
    "            ),\n",
    "            row=row_idx,\n",
    "            col=1,\n",
    "        )\n",
    "\n",
    "    return fig.show()"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "bb9f799bd6e477ee22986cb3017f2b22764a696a803a513374640b5de3a6fdad"
  },
  "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.11.3"
  },
  "metadata": {
   "interpreter": {
    "hash": "11faeb0f6d59efecf80914f265bd27ce56a3bb8010c5ee7c0d3aa19a8ad9fdc4"
   }
  },
  "toc-autonumbering": true
 },
 "nbformat": 4,
 "nbformat_minor": 4
}