steps/03_transformer_api/transform_types.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Typing time series transformations\n",
    "\n",
    "Contributors: @mloning, @fkiraly\n",
    "\n",
    "## Problem statement\n",
    "Time series data comes in many different forms: univariate or multivariate, a single instances or multiple instances. \n",
    "\n",
    "Correspondingly, there are many different forms of transformations that can be applied to time series data. \n",
    "\n",
    "This is an attempt to organise these transformations into categories with common APIs.\n",
    "\n",
    "1. Find a taxonomy of time series transformations using scientific types based on input and output types\n",
    "2. Develop transformer class structure/hierarchies in Python based on scitype taxonomy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sktime.forecasting.all import *\n",
    "from sktime.forecasting.model_selection import temporal_train_test_split\n",
    "from sklearn.preprocessing import FunctionTransformer\n",
    "import typing\n",
    "from typing import Union, NewType\n",
    "import pandas as pd\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data types\n",
    "\n",
    "### Primitives\n",
    "* single or multiple primitives\n",
    "* primitive types or 1d array "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# single or mulitple primitives\n",
    "Primitive = Union[np.integer, int, np.float, float, str]\n",
    "Primitives = np.ndarray"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tabular\n",
    "* scikit-learn-like data\n",
    "* 2d arrays: rows represent instances, columns represent variables/features, cells contain Primitives"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "Tabular = Union[pd.DataFrame, np.ndarray]  # 2d arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Series\n",
    "* univariate or multivariate\n",
    "* 1d or 2d arrays: rows represent time points, columns represent variables, cells represent observations\n",
    "* observations are Primitives\n",
    "* observations are ordered (usually in time)\n",
    "* for multiple series, for now we only support time-homogenous series (all series are observed at the same time points)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# univariate or multivariate\n",
    "UnivariateSeries = Union[pd.Series, np.ndarray]\n",
    "MultivariateSeries = Union[pd.DataFrame, np.ndarray]\n",
    "Series = Union[UnivariateSeries, MultivariateSeries]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_series(n_timepoints=10, n_variables=1):\n",
    "    assert n_timepoints > 1\n",
    "    assert n_variables > 0\n",
    "    index = pd.date_range(\"2020-01-01\", periods=n_timepoints, freq=\"D\")\n",
    "    if n_variables == 1:\n",
    "        return pd.Series(np.random.lognormal(size=n_timepoints), index=index, name=\"Data\")\n",
    "    else:\n",
    "        return pd.DataFrame(np.random.lognormal(size=(n_timepoints, n_variables)), index=index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = make_series(n_timepoints=10)\n",
    "Y  = make_series(n_timepoints=10, n_variables=3)\n",
    "y_train, y_test = temporal_train_test_split(make_series(n_timepoints=20))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Series-as-features\n",
    "* panel/longitudinal data with multiple instances of univariate/multivariate Series (and potentially Primitives)\n",
    "* nested/3d arrays, potentially also awkward array: rows represent instances, columns represent variables/features, 3rd dimension represents time points"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "SeriesAsFeatures = Union[pd.DataFrame, np.ndarray]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Transformation types\n",
    "### Base abstract transformer type\n",
    "* implements default and empty fit method\n",
    "* implements default fit_transform method\n",
    "* inverse-transform is optional, not implemented as an abstract method and only implemented by concrete transformers if available"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sktime.base import BaseEstimator\n",
    "\n",
    "class BaseTransformer(BaseEstimator):\n",
    "\n",
    "    def fit(self, X, y=None):\n",
    "        self._is_fitted = True\n",
    "        return self\n",
    "\n",
    "    def transform(self, X, y=None):\n",
    "        raise NotImplementedError(\"abstract method\")\n",
    "\n",
    "    def fit_transform(self, X, y=None):\n",
    "        return self.fit(X, y).transform(X, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Series -> Primitives\n",
    "* encapsulated in functions - not classes - because not fittable, so no parameters have to be stored (not stateful)\n",
    "* may have tuneable arguments (e.g. which quantile to extract), which can be exposed in comopsitions via FunctionTransformer\n",
    "* optionally, wrapped in classes for convenience\n",
    "\n",
    "#### Examples:\n",
    "* mean\n",
    "* quantile"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def series_to_primitive(x: Series, **kwargs) -> Primitives:\n",
    "    # non-fittable\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# example\n",
    "def quantile(x, q=0.25):\n",
    "    # non-fittable\n",
    "    return np.quantile(x, q, axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7813275205674247"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "quantile(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.04070528, 0.41603632, 0.29292394])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "quantile(Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7813275205674247"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# turn functions into classes for model composition \n",
    "from sklearn.preprocessing import FunctionTransformer\n",
    "transformer = FunctionTransformer(quantile)\n",
    "transformer.fit_transform(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# alternatively, base class with __call__\n",
    "class _SeriesToPrimitivesTransformer(BaseTransformer):\n",
    "     \n",
    "    def transform(self, X: Series, y=None) -> Primitives:\n",
    "        raise NotImplementedError(\"abstract method\")\n",
    "    \n",
    "    def inverse_transform(self, X: Primitives, y=None) -> Series:\n",
    "        # any examples of inverse transform? \n",
    "        # all series -> primitive transforms seem lossy \n",
    "        raise NotImplementedError()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# example\n",
    "class QuantileTransformer(_SeriesToPrimitivesTransformer):\n",
    "    \n",
    "    def __init__(self, q=0.5):\n",
    "        self.q = q\n",
    "        \n",
    "    def transform(self, X, y=None):\n",
    "        return np.quantile(X, self.q, axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7813275205674247"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "transformer = QuantileTransformer(q=0.25)\n",
    "transformer.fit_transform(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Series -> Series\n",
    "* may be fittable (e.g. extract AR coefficients from series)\n",
    "* if not fittable, encapsulated as functions, composable via FunctionTransformer, optionally wrapped in classes for convenience\n",
    "* if fittable, encapsulated in classes\n",
    "* input and output of transform may have different number of time points and different index\n",
    "* input and output may have different domain (no longer on the same time line)\n",
    "* in a forecasting pipeline, fit_transform is called before call fit of the final forecaster, and inverse_transform is called after calling predict of the final forecaster\n",
    "\n",
    "#### Examples\n",
    "* Box-Cox transform\n",
    "* logarithm\n",
    "* smoothing, filters\n",
    "* detrender\n",
    "* deseasonalisation \n",
    "* Change point annotator (e.g. returns sequence of change point waiting times)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def series_to_series(x: Series, **kwargs) -> Series:\n",
    "    # non-fittable\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fourier_transform(x): \n",
    "    return np.fft.fft(x, axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(10,)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fourier_transform(y).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(10, 3)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fourier_transform(Y).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(10,)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# scikit-learn FunctionTransformer\n",
    "transformer = FunctionTransformer(fourier_transform)\n",
    "transformer.fit_transform(y).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# bespoke class implementations\n",
    "class _SeriesToSeriesTransformer(BaseTransformer):\n",
    "        \n",
    "    def transform(self, X: Series, y=None) -> Series:\n",
    "        raise NotImplementedError(\"abstract method\")\n",
    "        \n",
    "    def inverse_transform(self, X: Series, y=None) -> Series:\n",
    "        raise NotImplementedError(\"abstract method\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# example\n",
    "class LogTransformer(_SeriesToSeriesTransformer):\n",
    "    \n",
    "    def transform(self, X, y=None):\n",
    "        return np.log(X)\n",
    "    \n",
    "    def inverse_transform(self, X, y=None):\n",
    "        return np.exp(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "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>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2020-01-01</th>\n",
       "      <td>-0.709980</td>\n",
       "      <td>-0.849195</td>\n",
       "      <td>-0.421344</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-01-02</th>\n",
       "      <td>0.773121</td>\n",
       "      <td>-0.886420</td>\n",
       "      <td>0.354816</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-01-03</th>\n",
       "      <td>-1.381188</td>\n",
       "      <td>0.804638</td>\n",
       "      <td>0.459675</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-01-04</th>\n",
       "      <td>0.484280</td>\n",
       "      <td>-2.540949</td>\n",
       "      <td>1.912350</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-01-05</th>\n",
       "      <td>0.143293</td>\n",
       "      <td>-0.683043</td>\n",
       "      <td>-1.118489</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-01-06</th>\n",
       "      <td>0.705658</td>\n",
       "      <td>-0.317235</td>\n",
       "      <td>0.792401</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-01-07</th>\n",
       "      <td>0.690698</td>\n",
       "      <td>0.837039</td>\n",
       "      <td>-1.267123</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-01-08</th>\n",
       "      <td>0.476263</td>\n",
       "      <td>1.384217</td>\n",
       "      <td>0.628589</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-01-09</th>\n",
       "      <td>0.002913</td>\n",
       "      <td>-2.420879</td>\n",
       "      <td>-1.328232</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-01-10</th>\n",
       "      <td>0.637167</td>\n",
       "      <td>1.643708</td>\n",
       "      <td>-1.543461</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                   0         1         2\n",
       "2020-01-01 -0.709980 -0.849195 -0.421344\n",
       "2020-01-02  0.773121 -0.886420  0.354816\n",
       "2020-01-03 -1.381188  0.804638  0.459675\n",
       "2020-01-04  0.484280 -2.540949  1.912350\n",
       "2020-01-05  0.143293 -0.683043 -1.118489\n",
       "2020-01-06  0.705658 -0.317235  0.792401\n",
       "2020-01-07  0.690698  0.837039 -1.267123\n",
       "2020-01-08  0.476263  1.384217  0.628589\n",
       "2020-01-09  0.002913 -2.420879 -1.328232\n",
       "2020-01-10  0.637167  1.643708 -1.543461"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "transformer = LogTransformer()\n",
    "transformer.fit_transform(Y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Special case: Featurizer\n",
    "In a forecasting pipeline, fit_transform is called before calling fit of the final forecaster and transform is called *before* calling predict of the final forecaster. So, Featurizers need to be aware of the forecasting horizon and need to be able to return transformed data even when y (forecasted values) are not available yet.\n",
    "\n",
    "#### Examples:\n",
    "* Adding holiday dummies \n",
    "* Adding Fourier terms\n",
    "\n",
    "#### Option 1: Keep transformer API but change inner workings, adapt pipeline classes\n",
    "In this option, we treat Featurizer as series-to-series transformers, but change how input data is handled in transform, as transform has to work on time index only with no data. Additionally, this option requires to adjust the pipeline class.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# examples\n",
    "from pmdarima.preprocessing.exog.fourier import _fourier_terms\n",
    "\n",
    "def _get_index(X=None, y=None):\n",
    "        assert X is not None or y is not None\n",
    "        if X is None:\n",
    "            return y.index\n",
    "        else:\n",
    "            return X.index\n",
    "\n",
    "class HolidayFeaturizer(_SeriesToSeriesTransformer):\n",
    "    \n",
    "    def __init__(self, calendar=None):\n",
    "        self.calendar = calendar\n",
    "    \n",
    "    def transform(self, X, y=None):\n",
    "        index = _get_index(X, y)\n",
    "        start, end = index[0], index[-1]\n",
    "        holidays = self.calendar.holidays(start, end, return_name=True)\n",
    "        if holidays.empty:\n",
    "            return X\n",
    "        \n",
    "        Xt = pd.get_dummies(holidays.reindex(index))\n",
    "        return pd.concat([X, Xt], axis=1)\n",
    "    \n",
    "class FourierFeaturizer(_SeriesToSeriesTransformer):\n",
    "    \n",
    "    def __init__(self, sp=None, k=None):\n",
    "        self.sp = sp\n",
    "        self.k = k\n",
    "        \n",
    "    def fit(self, X, y=None):\n",
    "        index = _get_index(X, y)\n",
    "        assert self.sp is not None\n",
    "        if self.k is None:\n",
    "            k = self.sp // 2\n",
    "        else:\n",
    "            k = self.k\n",
    "            \n",
    "        if 2 * k > self.sp or k < 1:\n",
    "            raise ValueError(\"k must be a positive integer not greater \"\n",
    "                             \"than sp//2\")\n",
    "\n",
    "        # Compute the periods of all Fourier terms. Since R allows multiple\n",
    "        # seasonality and we do not, we can do this much more simply.\n",
    "        p = ((np.arange(k) + 1) / self.sp).astype(np.float64)  # 1:K / m\n",
    "\n",
    "        # If sinpi is 0... maybe blow up?\n",
    "        # if abs(2 * p - round(2 * p)) < np.finfo(y.dtype).eps:  # min eps\n",
    "\n",
    "        self.p_ = p\n",
    "        self.k_ = k\n",
    "        self.n_ = index.shape[0]\n",
    "        self._start = index[0]\n",
    "        self._cutoff = index[-1]\n",
    "        return self\n",
    "    \n",
    "    def transform(self, X, y=None):\n",
    "        index = _get_index(X, y)\n",
    "        # extrapolate fourier terms \n",
    "        fh = ForecastingHorizon(index, is_relative=False)\n",
    "        start = self._start\n",
    "        cutoff = self._cutoff\n",
    "        times = fh.to_absolute_int(start, cutoff).to_numpy(dtype=np.float64) + 1\n",
    "        Xt = pd.DataFrame(_fourier_terms(self.p_, times), index=index)\n",
    "        return pd.concat([X, Xt], axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "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>Martin Luther King Jr. Day</th>\n",
       "      <th>New Years Day</th>\n",
       "      <th>Presidents Day</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2020-01-01</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-01-02</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-01-03</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            Martin Luther King Jr. Day  New Years Day  Presidents Day\n",
       "2020-01-01                           0              1               0\n",
       "2020-01-02                           0              0               0\n",
       "2020-01-03                           0              0               0"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# fitting \n",
    "from pandas.tseries.holiday import USFederalHolidayCalendar\n",
    "y_train = make_series(100)\n",
    "transformer = HolidayFeaturizer(calendar=USFederalHolidayCalendar())\n",
    "transformer.fit_transform(None, y_train).head(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "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>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2020-04-07</th>\n",
       "      <td>0.866026</td>\n",
       "      <td>0.499999</td>\n",
       "      <td>0.866024</td>\n",
       "      <td>-0.500002</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-04-08</th>\n",
       "      <td>1.000000</td>\n",
       "      <td>-0.000001</td>\n",
       "      <td>-0.000003</td>\n",
       "      <td>-1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-04-09</th>\n",
       "      <td>0.866025</td>\n",
       "      <td>-0.500001</td>\n",
       "      <td>-0.866027</td>\n",
       "      <td>-0.499997</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                   0         1         2         3\n",
       "2020-04-07  0.866026  0.499999  0.866024 -0.500002\n",
       "2020-04-08  1.000000 -0.000001 -0.000003 -1.000000\n",
       "2020-04-09  0.866025 -0.500001 -0.866027 -0.499997"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# fitting \n",
    "X_train = None\n",
    "t = FourierFeaturizer(sp=12, k=2)\n",
    "Xt = t.fit_transform(X_train, y=y_train)\n",
    "Xt.tail(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(<Figure size 1152x288 with 1 Axes>, <AxesSubplot:ylabel='3'>)"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_series(*[Xt.iloc[:, i] for i in range(Xt.shape[1])])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "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>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2020-01-16</th>\n",
       "      <td>8.660253e-01</td>\n",
       "      <td>-0.500000</td>\n",
       "      <td>-8.660256e-01</td>\n",
       "      <td>-0.500000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-01-17</th>\n",
       "      <td>4.999998e-01</td>\n",
       "      <td>-0.866026</td>\n",
       "      <td>-8.660252e-01</td>\n",
       "      <td>0.500000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-01-18</th>\n",
       "      <td>-2.622683e-07</td>\n",
       "      <td>-1.000000</td>\n",
       "      <td>5.245367e-07</td>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-01-19</th>\n",
       "      <td>-5.000002e-01</td>\n",
       "      <td>-0.866025</td>\n",
       "      <td>8.660257e-01</td>\n",
       "      <td>0.500000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-01-20</th>\n",
       "      <td>-8.660255e-01</td>\n",
       "      <td>-0.500000</td>\n",
       "      <td>8.660251e-01</td>\n",
       "      <td>-0.500001</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                       0         1             2         3\n",
       "2020-01-16  8.660253e-01 -0.500000 -8.660256e-01 -0.500000\n",
       "2020-01-17  4.999998e-01 -0.866026 -8.660252e-01  0.500000\n",
       "2020-01-18 -2.622683e-07 -1.000000  5.245367e-07  1.000000\n",
       "2020-01-19 -5.000002e-01 -0.866025  8.660257e-01  0.500000\n",
       "2020-01-20 -8.660255e-01 -0.500000  8.660251e-01 -0.500001"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# predicting\n",
    "X_test = None\n",
    "fh = ForecastingHorizon(y_test.index, is_relative=False)\n",
    "\n",
    "# pre-initialised empty y_pred with fh as index\n",
    "if X_test is None:\n",
    "    X_test = pd.DataFrame(index=fh.to_absolute(t._cutoff).to_pandas(), dtype=np.float)\n",
    "X_test = t.transform(X_test)\n",
    "X_test.head(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Option 2: Add new Featurizer type and composition class\n",
    "In this option, we treat Featurizers as their own distinct estimator type. This allows us to align their API with their scientific type, taking in data in fit and predicting values for a given time index (or forecasting horizon). In contrast to forecasters, they do not predict values in the same domain as the training data. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sktime.forecasting.base._sktime import OptionalForecastingHorizonMixin\n",
    "from sktime.forecasting.base._sktime import BaseSktimeForecaster\n",
    "\n",
    "class _Featurizer(OptionalForecastingHorizonMixin, BaseSktimeForecaster):\n",
    "    \n",
    "    def fit(self, y, fh=None, X=None):\n",
    "        self._set_fh(fh)\n",
    "        self._set_y_X(y, X)\n",
    "        self._is_fitted = True\n",
    "        return self\n",
    "        \n",
    "    def predict(self, fh=None, X=None) -> Series:\n",
    "        raise NotImplementedError(\"abstract method\")\n",
    "        \n",
    "    def fit_predict(self, y, fh=None, X=None) -> Series:\n",
    "        return self.fit(y, fh, X).predict(fh, X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "class HolidayFeaturizer(_Featurizer):\n",
    "    \n",
    "    def __init__(self, calendar=None):\n",
    "        self.calendar = calendar\n",
    "        self._features = None\n",
    "        super(HolidayFeaturizer, self).__init__()\n",
    "        \n",
    "    def fit(self, y, fh=None, X=None):\n",
    "        super(HolidayFeaturizer, self).fit(y, fh, X)\n",
    "        assert self.calendar is not None\n",
    "        assert isinstance(y.index, pd.DatetimeIndex)\n",
    "    \n",
    "    def predict(self, fh=None, X=None):\n",
    "        self.check_is_fitted()\n",
    "        self._set_fh(fh)\n",
    "        fh = self.fh.to_absolute(self.cutoff).to_pandas()\n",
    "        holidays = self.calendar.holidays(fh[0], fh[-1], return_name=True)\n",
    "        \n",
    "        return pd.get_dummies(holidays.reindex(fh, axis=0)).reindex(self._features, axis=1, fill_value=0)\n",
    "    \n",
    "    def fit_predict(self, y, fh=None, X=None):\n",
    "        # additionally keeps track of holiday names, so that we generate the same features in fit and predict in pipeline\n",
    "        self.fit(y, fh, X)\n",
    "        X_pred = self.predict(fh, X)\n",
    "        self._features = X_pred.columns\n",
    "        return X_pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "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>Martin Luther King Jr. Day</th>\n",
       "      <th>New Years Day</th>\n",
       "      <th>Presidents Day</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2020-01-01</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-01-02</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-01-03</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-01-04</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-01-05</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            Martin Luther King Jr. Day  New Years Day  Presidents Day\n",
       "2020-01-01                           0              1               0\n",
       "2020-01-02                           0              0               0\n",
       "2020-01-03                           0              0               0\n",
       "2020-01-04                           0              0               0\n",
       "2020-01-05                           0              0               0"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from pandas.tseries.holiday import USFederalHolidayCalendar\n",
    "y_train = make_series(100)\n",
    "featurizer = HolidayFeaturizer(calendar=USFederalHolidayCalendar())\n",
    "featurizer.fit(y_train)\n",
    "fh = ForecastingHorizon(y_train.index, is_relative=False)\n",
    "X_pred = featurizer.predict(fh)\n",
    "X_pred.head() # may return empty data frame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.base import clone\n",
    "\n",
    "def _clone_estimators(estimators):\n",
    "    return [(name, clone(estimator)) for name, estimator in estimators]\n",
    "\n",
    "class FeaturizedForecaster(OptionalForecastingHorizonMixin, BaseSktimeForecaster):\n",
    "    \"\"\"Composition class for forecasting with featurizers\"\"\"\n",
    "    \n",
    "    def __init__(self, estimators):\n",
    "        self.estimators = estimators\n",
    "        super(FeaturizedForecaster, self).__init__()\n",
    "        \n",
    "    def fit(self, y, fh=None, X=None):\n",
    "        self._set_y_X(y, X)\n",
    "        \n",
    "        _check_estimators(self.estimators)\n",
    "        self.estimators_ = _clone_estimators(self.estimators)\n",
    "        \n",
    "        xs = []\n",
    "        # use in-sample forecasting horizon\n",
    "        h = ForecastingHorizon(self._y.index, is_relative=False)\n",
    "        for i, (name, featurizer) in self.featurizers_():\n",
    "            # 1. fit featurizer\n",
    "            x = featurizer.fit_predict(y, h, X)\n",
    "            xs.append(x)\n",
    "            self.estimators_[i] = (name, featurizer)\n",
    "            \n",
    "        X = pd.concat([X, *xs], axis=1)\n",
    "        \n",
    "        # 3. fit final forecaster\n",
    "        name, forecaster = self.forecaster_\n",
    "        forecaster.fit(y, fh, X)\n",
    "        self.estimators_[-1] = (name, forecaster)\n",
    "        \n",
    "        self._is_fitted = True\n",
    "        return self\n",
    "    \n",
    "    def predict(self, fh=None, X=None):\n",
    "        self.check_is_fitted()\n",
    "        \n",
    "        xs = []\n",
    "        for _, (_, featurizer) in self.featurizers_():\n",
    "            # 3. generate features\n",
    "            x = featurizer.predict(fh, X=X)\n",
    "            xs.append(x)\n",
    "        \n",
    "        X = pd.concat([X, *xs], axis=1)\n",
    "        \n",
    "        # 3. fit final forecaster\n",
    "        _, forecaster = self.forecaster_\n",
    "        y_pred = forecaster.predict(fh, X)\n",
    "        return y_pred\n",
    "    \n",
    "    @property\n",
    "    def forecaster_(self):\n",
    "        return self.estimators_[-1]\n",
    "    \n",
    "    def featurizers_(self):\n",
    "        yield from enumerate(self.estimators_[:-1])\n",
    "\n",
    "\n",
    "def _get_name(estimator):\n",
    "    return estimator.__class__.__name__\n",
    "\n",
    "def _check_estimators(estimators):\n",
    "    assert isinstance(estimators, list)\n",
    "    assert len(estimators) > 0\n",
    "    \n",
    "    for estimator in estimators:\n",
    "        assert isinstance(estimator, tuple)\n",
    "    \n",
    "    names = [name for name, _ in estimators]\n",
    "    assert len(set(names)) == len(names)\n",
    "    \n",
    "    return estimators\n",
    "        \n",
    "def make_featurized_forecaster(*estimators):\n",
    "    \"\"\"Convenience function for creating a FeaturizedForecaster\"\"\"\n",
    "    return FeaturizedForecaster([(_get_name(estimator), estimator) for estimator in estimators])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2020-12-21    1.698375\n",
       "2020-12-22    1.698375\n",
       "2020-12-23    1.698375\n",
       "2020-12-24    1.698375\n",
       "2020-12-25    1.698375\n",
       "dtype: float64"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = make_series(n_timepoints=365)\n",
    "y_train, y_test = temporal_train_test_split(y, test_size=10)\n",
    "forecaster = make_featurized_forecaster(\n",
    "    HolidayFeaturizer(USFederalHolidayCalendar()), \n",
    "    AutoARIMA(suppress_warnings=True)\n",
    ")\n",
    "forecaster.fit(y_train)\n",
    "fh = ForecastingHorizon(y_test.index, is_relative=False)\n",
    "y_pred = forecaster.predict(fh)\n",
    "y_pred.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "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>Columbus Day</th>\n",
       "      <th>July 4th</th>\n",
       "      <th>Labor Day</th>\n",
       "      <th>Martin Luther King Jr. Day</th>\n",
       "      <th>Memorial Day</th>\n",
       "      <th>New Years Day</th>\n",
       "      <th>Presidents Day</th>\n",
       "      <th>Thanksgiving</th>\n",
       "      <th>Veterans Day</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2020-01-01</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-01-02</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-01-03</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-01-04</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-01-05</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            Columbus Day  July 4th  Labor Day  Martin Luther King Jr. Day  \\\n",
       "2020-01-01             0         0          0                           0   \n",
       "2020-01-02             0         0          0                           0   \n",
       "2020-01-03             0         0          0                           0   \n",
       "2020-01-04             0         0          0                           0   \n",
       "2020-01-05             0         0          0                           0   \n",
       "\n",
       "            Memorial Day  New Years Day  Presidents Day  Thanksgiving  \\\n",
       "2020-01-01             0              1               0             0   \n",
       "2020-01-02             0              0               0             0   \n",
       "2020-01-03             0              0               0             0   \n",
       "2020-01-04             0              0               0             0   \n",
       "2020-01-05             0              0               0             0   \n",
       "\n",
       "            Veterans Day  \n",
       "2020-01-01             0  \n",
       "2020-01-02             0  \n",
       "2020-01-03             0  \n",
       "2020-01-04             0  \n",
       "2020-01-05             0  "
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check if features have been passed to final forecaster\n",
    "_X = forecaster.forecaster_[-1]._X\n",
    "assert _X.shape[0] == y_train.shape[0]\n",
    "assert _X.shape[1] > 1\n",
    "_X.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Series-as-features -> Tabular\n",
    "* usually fittable and encapsualted in classes\n",
    "* input of fit and transform always needs to have the same number of columns and time points, but may have different number of instances\n",
    "* input and output of transform always has the same number of instances, but may have different numbers of columns and time points\n",
    "\n",
    "#### Examples\n",
    "* Shapelet transform (returns minimum distance of each instance to found shapelets as tabular matrix)\n",
    "* Feature extractors\n",
    "* Tabularizer/TimeBinner\n",
    "* composite transformers, e.g. applying series-to-primitives transform iteratively over instances/rows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "class _SeriesAsFeaturesToTabularTransformer(BaseTransformer):\n",
    "\n",
    "    def transform(self, X: SeriesAsFeatures, y=None) -> Tabular:\n",
    "        raise NotImplementedError(\"abstract method\")\n",
    "\n",
    "    def inverse_transform(self, X: Tabular, y=None) -> SeriesAsFeatures:\n",
    "        raise NotImplementedError()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "# example\n",
    "from sktime.transformers.series_as_features.summarize import RandomIntervalFeatureExtractor\n",
    "from sktime.utils._testing import make_classification_problem"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "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>['col0']_6_18_mean</th>\n",
       "      <th>['col0']_2_19_mean</th>\n",
       "      <th>['col0']_8_14_mean</th>\n",
       "      <th>['col0']_4_19_mean</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>19.779415</td>\n",
       "      <td>19.792490</td>\n",
       "      <td>19.673205</td>\n",
       "      <td>19.813494</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>20.027158</td>\n",
       "      <td>20.053538</td>\n",
       "      <td>20.035181</td>\n",
       "      <td>20.108927</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.061686</td>\n",
       "      <td>0.010822</td>\n",
       "      <td>-0.171575</td>\n",
       "      <td>-0.012091</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>-0.068329</td>\n",
       "      <td>0.022553</td>\n",
       "      <td>0.041381</td>\n",
       "      <td>0.024526</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.062448</td>\n",
       "      <td>-0.074814</td>\n",
       "      <td>0.266883</td>\n",
       "      <td>-0.071736</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   ['col0']_6_18_mean  ['col0']_2_19_mean  ['col0']_8_14_mean  \\\n",
       "0           19.779415           19.792490           19.673205   \n",
       "1           20.027158           20.053538           20.035181   \n",
       "2            0.061686            0.010822           -0.171575   \n",
       "3           -0.068329            0.022553            0.041381   \n",
       "4            0.062448           -0.074814            0.266883   \n",
       "\n",
       "   ['col0']_4_19_mean  \n",
       "0           19.813494  \n",
       "1           20.108927  \n",
       "2           -0.012091  \n",
       "3            0.024526  \n",
       "4           -0.071736  "
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X, y = make_classification_problem()\n",
    "X.columns = [\"var\"]\n",
    "transformer = RandomIntervalFeatureExtractor()\n",
    "Xt = transformer.fit_transform(X)\n",
    "Xt.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. Series-as-features -> Series-as-features\n",
    "* usually fittable and encapsualted in classes\n",
    "* input of fit and transform always needs to have the same number of columns and time points, but may have different number of instances\n",
    "* input and output of transform always has same number of instances, but may have different numbers of columns and time points (including going from time-homogeneous data to time-heterogenous data)\n",
    "\n",
    "#### Examples\n",
    "* dictionary-based transforms \n",
    "* time series segmentation, e.g. splitting a time series columns into multiple ones, see IntervalSegmenter\n",
    "* time series concatenation, e.g. merging multiple time series columns into a single one, see ColumnConcatenator\n",
    "* composite transformers, e.g. applying series-to-series or series-to-primitive transforms iteratively over instances/rows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "class _SeriesAsFeaturesToSeriesAsFeaturesTransformer(BaseTransformer):\n",
    "\n",
    "    def transform(self, X: SeriesAsFeatures, y=None) -> SeriesAsFeatures:\n",
    "        raise NotImplementedError(\"abstract method\")\n",
    "\n",
    "    def inverse_transform(self, X: SeriesAsFeatures, y=None) -> SeriesAsFeatures:\n",
    "        raise NotImplementedError()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "# example\n",
    "from sktime.transformers.series_as_features.segment import RandomIntervalSegmenter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "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>col0_5_20</th>\n",
       "      <th>col0_15_19</th>\n",
       "      <th>col0_17_19</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>[[19.86233397545397, 19.864967801965697, 20.72...</td>\n",
       "      <td>[[18.987286129713375, 20.742747471985357, 19.3...</td>\n",
       "      <td>[[19.329443157204544, 20.24093553549599]]</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>[[20.331438842384333, 19.969120517067967, 19.7...</td>\n",
       "      <td>[[20.032039448276247, 19.464165435035873, 20.2...</td>\n",
       "      <td>[[20.266675247348957, 20.587064342632452]]</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>[[-0.23107544619966358, 0.8373550594930772, -1...</td>\n",
       "      <td>[[0.41094080818732914, 1.298057103693805, -0.0...</td>\n",
       "      <td>[[-0.0033612142720227966, -0.6614482023626087]]</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>[[0.11481317332859756, 0.7436124444770555, -0....</td>\n",
       "      <td>[[0.014322625147596859, -0.7027098515641493, -...</td>\n",
       "      <td>[[-1.1701279838472103, 0.48771395823287816]]</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>[[-0.8992995507772713, 0.22795118401838194, 0....</td>\n",
       "      <td>[[-0.7751881778710042, 0.15504225965866245, -0...</td>\n",
       "      <td>[[-0.14662550609036326, -0.6797114933494889]]</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                           col0_5_20  \\\n",
       "0  [[19.86233397545397, 19.864967801965697, 20.72...   \n",
       "1  [[20.331438842384333, 19.969120517067967, 19.7...   \n",
       "2  [[-0.23107544619966358, 0.8373550594930772, -1...   \n",
       "3  [[0.11481317332859756, 0.7436124444770555, -0....   \n",
       "4  [[-0.8992995507772713, 0.22795118401838194, 0....   \n",
       "\n",
       "                                          col0_15_19  \\\n",
       "0  [[18.987286129713375, 20.742747471985357, 19.3...   \n",
       "1  [[20.032039448276247, 19.464165435035873, 20.2...   \n",
       "2  [[0.41094080818732914, 1.298057103693805, -0.0...   \n",
       "3  [[0.014322625147596859, -0.7027098515641493, -...   \n",
       "4  [[-0.7751881778710042, 0.15504225965866245, -0...   \n",
       "\n",
       "                                        col0_17_19  \n",
       "0        [[19.329443157204544, 20.24093553549599]]  \n",
       "1       [[20.266675247348957, 20.587064342632452]]  \n",
       "2  [[-0.0033612142720227966, -0.6614482023626087]]  \n",
       "3     [[-1.1701279838472103, 0.48771395823287816]]  \n",
       "4    [[-0.14662550609036326, -0.6797114933494889]]  "
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "transformer = RandomIntervalSegmenter(n_intervals=3)\n",
    "Xt = transformer.fit_transform(X)\n",
    "Xt.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. Meta-transformers\n",
    "* Concatenators/chaining, e.g. pipelines\n",
    "* Appliers, e.g. InstanceTransformer (or RowTransformer)\n",
    "* Unions/Selectors, e.g. FeatureUnion, ColumnTransformer\n",
    "* Adaptors, e.g. applying scikit-learn like transformer to single series by making the series into a column vector "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "# example\n",
    "def make_instance_transformer(transformer, **kwargs):\n",
    "    \"\"\"Factory function for creating InstanceTransformer based on transform type\"\"\"\n",
    "    if isinstance(transformer, _SeriesToSeriesTransformer):\n",
    "        return SeriesToSeriesInstanceTransformer(transformer, **kwargs)\n",
    "    elif isinstance(transformer, _SeriesToPrimitivesTransformer):\n",
    "        return SeriesToPrimitivesInstanceTransformer(transformer, **kwargs)\n",
    "    else:\n",
    "        raise TypeError(\"transformer type not supported\")\n",
    "        \n",
    "from sklearn.base import clone\n",
    "from sktime.utils.data_container import from_2d_array_to_nested\n",
    "\n",
    "def _from_nested_to_series(x):\n",
    "    \"\"\"Helper function to un-nest series\"\"\"\n",
    "    if x.shape[0] == 1:\n",
    "        return x.iloc[0]\n",
    "    else: \n",
    "        return pd.DataFrame(x.tolist()).T\n",
    "\n",
    "def _make_column_names(columns, prefix):\n",
    "    \"\"\"Helper function to generate column names\"\"\"\n",
    "    if len(prefix) > 0:\n",
    "        prefix = prefix + \"_\"\n",
    "    return [f\"{prefix}{column}\" for column in columns]\n",
    "    \n",
    "class _InstanceTransformer:\n",
    "    \"\"\"Base class for InstanceTransformer\"\"\"\n",
    "    \n",
    "    def __init__(self, transformer, prefix=\"\", check_transformer=True):\n",
    "        self.transformer = transformer\n",
    "        self.check_transformer = check_transformer\n",
    "        self.prefix = prefix\n",
    "        \n",
    "    def _check_transformer(self):\n",
    "        \"\"\"Check transformer type compatibility\"\"\"\n",
    "        assert hasattr(self, \"_supported_transformer_type\")\n",
    "        if self.check_transformer and not isinstance(self.transformer, self._supported_transformer_type):\n",
    "            raise TypeError(f\"transformer must be a {self._supported_transformer_type.__class__.__name__}\")\n",
    "        \n",
    "    def fit(self, X, y=None):\n",
    "        self._check_transformer()\n",
    "        transformer = clone(self.transformer)\n",
    "        self.transformer_ = transformer.fit(X, y)\n",
    "        return self\n",
    "\n",
    "class SeriesToPrimitivesInstanceTransformer(_InstanceTransformer, _SeriesAsFeaturesToTabularTransformer):\n",
    "    _supported_transformer_type = _SeriesToPrimitivesTransformer\n",
    "    \n",
    "    def transform(self, X, y=None):\n",
    "        Xt = np.zeros(X.shape)\n",
    "        for i, (_, x) in enumerate(X.iterrows()):\n",
    "            x = _from_nested_to_series(x)\n",
    "            Xt[i] = self.transformer_.transform(x)\n",
    "        return pd.DataFrame(Xt, columns=_make_column_names(X.columns, self.prefix))\n",
    "    \n",
    "class SeriesToSeriesInstanceTransformer(_InstanceTransformer, _SeriesAsFeaturesToSeriesAsFeaturesTransformer):\n",
    "    _supported_transformer_type = _SeriesToSeriesTransformer\n",
    "    \n",
    "    def transform(self, X, y=None):\n",
    "        Xt = None\n",
    "        for i, (_, x) in enumerate(X.iterrows()):\n",
    "            x = _from_nested_to_series(x)\n",
    "            xt = self.transformer_.transform(x)\n",
    "            Xt = pd.concat([Xt, from_2d_array_to_nested(xt.T)], axis=1)\n",
    "        Xt = Xt.T\n",
    "        Xt.columns = _make_column_names(X.columns, self.prefix)\n",
    "        return Xt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sktime.datasets import load_basic_motions\n",
    "X, _ = load_basic_motions(return_X_y=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class '__main__.SeriesToPrimitivesInstanceTransformer'>\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>q25_dim_0</th>\n",
       "      <th>q25_dim_1</th>\n",
       "      <th>q25_dim_2</th>\n",
       "      <th>q25_dim_3</th>\n",
       "      <th>q25_dim_4</th>\n",
       "      <th>q25_dim_5</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>-0.229348</td>\n",
       "      <td>-0.170838</td>\n",
       "      <td>-0.146205</td>\n",
       "      <td>-0.093884</td>\n",
       "      <td>-0.050604</td>\n",
       "      <td>-0.191763</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>-0.342918</td>\n",
       "      <td>-0.352173</td>\n",
       "      <td>-0.040077</td>\n",
       "      <td>-0.049272</td>\n",
       "      <td>-0.029297</td>\n",
       "      <td>-0.167792</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>-0.219758</td>\n",
       "      <td>-0.786313</td>\n",
       "      <td>-0.003134</td>\n",
       "      <td>-0.125179</td>\n",
       "      <td>-0.128508</td>\n",
       "      <td>-0.380197</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>-0.280183</td>\n",
       "      <td>-0.201187</td>\n",
       "      <td>-0.269531</td>\n",
       "      <td>-0.091886</td>\n",
       "      <td>-0.117188</td>\n",
       "      <td>-0.104537</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>-0.348184</td>\n",
       "      <td>-0.265133</td>\n",
       "      <td>-0.056743</td>\n",
       "      <td>-0.058594</td>\n",
       "      <td>-0.015980</td>\n",
       "      <td>-0.123847</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   q25_dim_0  q25_dim_1  q25_dim_2  q25_dim_3  q25_dim_4  q25_dim_5\n",
       "0  -0.229348  -0.170838  -0.146205  -0.093884  -0.050604  -0.191763\n",
       "1  -0.342918  -0.352173  -0.040077  -0.049272  -0.029297  -0.167792\n",
       "2  -0.219758  -0.786313  -0.003134  -0.125179  -0.128508  -0.380197\n",
       "3  -0.280183  -0.201187  -0.269531  -0.091886  -0.117188  -0.104537\n",
       "4  -0.348184  -0.265133  -0.056743  -0.058594  -0.015980  -0.123847"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "transformer = make_instance_transformer(QuantileTransformer(q=.25), prefix=\"q25\")\n",
    "print(type(transformer))\n",
    "Xt = transformer.fit_transform(X)\n",
    "Xt.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class '__main__.SeriesToSeriesInstanceTransformer'>\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/mloning/.conda/envs/sktime-dev/lib/python3.7/site-packages/ipykernel_launcher.py:5: RuntimeWarning: divide by zero encountered in log\n",
      "  \"\"\"\n",
      "/Users/mloning/.conda/envs/sktime-dev/lib/python3.7/site-packages/ipykernel_launcher.py:5: RuntimeWarning: invalid value encountered in log\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>log_dim_0</th>\n",
       "      <th>log_dim_1</th>\n",
       "      <th>log_dim_2</th>\n",
       "      <th>log_dim_3</th>\n",
       "      <th>log_dim_4</th>\n",
       "      <th>log_dim_5</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0    -2.536967\n",
       "1    -2.536967\n",
       "2          NaN\n",
       "3...</td>\n",
       "      <td>0    -0.931323\n",
       "1    -0.931323\n",
       "2          NaN\n",
       "3...</td>\n",
       "      <td>0    -0.595215\n",
       "1    -0.595215\n",
       "2          NaN\n",
       "3...</td>\n",
       "      <td>0    -1.045361\n",
       "1    -1.045361\n",
       "2          NaN\n",
       "3...</td>\n",
       "      <td>0    -3.730952\n",
       "1    -3.730952\n",
       "2          NaN\n",
       "3...</td>\n",
       "      <td>0    -0.455891\n",
       "1    -0.455891\n",
       "2    -0.028265\n",
       "3...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0    -0.973520\n",
       "1    -0.973520\n",
       "2     1.082810\n",
       "3...</td>\n",
       "      <td>0          NaN\n",
       "1          NaN\n",
       "2    -0.029720\n",
       "3...</td>\n",
       "      <td>0          NaN\n",
       "1          NaN\n",
       "2          NaN\n",
       "3...</td>\n",
       "      <td>0    NaN\n",
       "1    NaN\n",
       "2    NaN\n",
       "3    NaN\n",
       "4    NaN\n",
       " ...</td>\n",
       "      <td>0          NaN\n",
       "1          NaN\n",
       "2          NaN\n",
       "3...</td>\n",
       "      <td>0          NaN\n",
       "1          NaN\n",
       "2          NaN\n",
       "3...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0          NaN\n",
       "1          NaN\n",
       "2          NaN\n",
       "3...</td>\n",
       "      <td>0    -0.191565\n",
       "1    -0.191565\n",
       "2          NaN\n",
       "3...</td>\n",
       "      <td>0    -3.420013\n",
       "1    -3.420013\n",
       "2    -0.190955\n",
       "3...</td>\n",
       "      <td>0    -3.848720\n",
       "1    -3.848720\n",
       "2          NaN\n",
       "3...</td>\n",
       "      <td>0    -2.099522\n",
       "1    -2.099522\n",
       "2          NaN\n",
       "3...</td>\n",
       "      <td>0    -0.254839\n",
       "1    -0.254839\n",
       "2    -0.958348\n",
       "3...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0    -1.238374\n",
       "1    -1.238374\n",
       "2          NaN\n",
       "3...</td>\n",
       "      <td>0    -1.258323\n",
       "1    -1.258323\n",
       "2          NaN\n",
       "3...</td>\n",
       "      <td>0    -1.543276\n",
       "1    -1.543276\n",
       "2    -1.377267\n",
       "3...</td>\n",
       "      <td>0          NaN\n",
       "1          NaN\n",
       "2    -3.982231\n",
       "3...</td>\n",
       "      <td>0    -2.595963\n",
       "1    -2.595963\n",
       "2    -4.829565\n",
       "3...</td>\n",
       "      <td>0          NaN\n",
       "1          NaN\n",
       "2    -1.439526\n",
       "3...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0    NaN\n",
       "1    NaN\n",
       "2    NaN\n",
       "3    NaN\n",
       "4    NaN\n",
       " ...</td>\n",
       "      <td>0    -0.969320\n",
       "1    -0.969320\n",
       "2    -0.613410\n",
       "3...</td>\n",
       "      <td>0          NaN\n",
       "1          NaN\n",
       "2    -1.568200\n",
       "3...</td>\n",
       "      <td>0          NaN\n",
       "1          NaN\n",
       "2          NaN\n",
       "3...</td>\n",
       "      <td>0    -2.837123\n",
       "1    -2.837123\n",
       "2    -1.738505\n",
       "3...</td>\n",
       "      <td>0          NaN\n",
       "1          NaN\n",
       "2    -2.166962\n",
       "3...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                           log_dim_0  \\\n",
       "0  0    -2.536967\n",
       "1    -2.536967\n",
       "2          NaN\n",
       "3...   \n",
       "0  0    -0.973520\n",
       "1    -0.973520\n",
       "2     1.082810\n",
       "3...   \n",
       "0  0          NaN\n",
       "1          NaN\n",
       "2          NaN\n",
       "3...   \n",
       "0  0    -1.238374\n",
       "1    -1.238374\n",
       "2          NaN\n",
       "3...   \n",
       "0  0    NaN\n",
       "1    NaN\n",
       "2    NaN\n",
       "3    NaN\n",
       "4    NaN\n",
       " ...   \n",
       "\n",
       "                                           log_dim_1  \\\n",
       "0  0    -0.931323\n",
       "1    -0.931323\n",
       "2          NaN\n",
       "3...   \n",
       "0  0          NaN\n",
       "1          NaN\n",
       "2    -0.029720\n",
       "3...   \n",
       "0  0    -0.191565\n",
       "1    -0.191565\n",
       "2          NaN\n",
       "3...   \n",
       "0  0    -1.258323\n",
       "1    -1.258323\n",
       "2          NaN\n",
       "3...   \n",
       "0  0    -0.969320\n",
       "1    -0.969320\n",
       "2    -0.613410\n",
       "3...   \n",
       "\n",
       "                                           log_dim_2  \\\n",
       "0  0    -0.595215\n",
       "1    -0.595215\n",
       "2          NaN\n",
       "3...   \n",
       "0  0          NaN\n",
       "1          NaN\n",
       "2          NaN\n",
       "3...   \n",
       "0  0    -3.420013\n",
       "1    -3.420013\n",
       "2    -0.190955\n",
       "3...   \n",
       "0  0    -1.543276\n",
       "1    -1.543276\n",
       "2    -1.377267\n",
       "3...   \n",
       "0  0          NaN\n",
       "1          NaN\n",
       "2    -1.568200\n",
       "3...   \n",
       "\n",
       "                                           log_dim_3  \\\n",
       "0  0    -1.045361\n",
       "1    -1.045361\n",
       "2          NaN\n",
       "3...   \n",
       "0  0    NaN\n",
       "1    NaN\n",
       "2    NaN\n",
       "3    NaN\n",
       "4    NaN\n",
       " ...   \n",
       "0  0    -3.848720\n",
       "1    -3.848720\n",
       "2          NaN\n",
       "3...   \n",
       "0  0          NaN\n",
       "1          NaN\n",
       "2    -3.982231\n",
       "3...   \n",
       "0  0          NaN\n",
       "1          NaN\n",
       "2          NaN\n",
       "3...   \n",
       "\n",
       "                                           log_dim_4  \\\n",
       "0  0    -3.730952\n",
       "1    -3.730952\n",
       "2          NaN\n",
       "3...   \n",
       "0  0          NaN\n",
       "1          NaN\n",
       "2          NaN\n",
       "3...   \n",
       "0  0    -2.099522\n",
       "1    -2.099522\n",
       "2          NaN\n",
       "3...   \n",
       "0  0    -2.595963\n",
       "1    -2.595963\n",
       "2    -4.829565\n",
       "3...   \n",
       "0  0    -2.837123\n",
       "1    -2.837123\n",
       "2    -1.738505\n",
       "3...   \n",
       "\n",
       "                                           log_dim_5  \n",
       "0  0    -0.455891\n",
       "1    -0.455891\n",
       "2    -0.028265\n",
       "3...  \n",
       "0  0          NaN\n",
       "1          NaN\n",
       "2          NaN\n",
       "3...  \n",
       "0  0    -0.254839\n",
       "1    -0.254839\n",
       "2    -0.958348\n",
       "3...  \n",
       "0  0          NaN\n",
       "1          NaN\n",
       "2    -1.439526\n",
       "3...  \n",
       "0  0          NaN\n",
       "1          NaN\n",
       "2    -2.166962\n",
       "3...  "
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "transformer = make_instance_transformer(LogTransformer(), prefix=\"log\")\n",
    "print(type(transformer))\n",
    "Xt = transformer.fit_transform(X)\n",
    "Xt.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pipelining\n",
    "\n",
    "### Forecasting\n",
    "* pipeline for exogenous transformations with Featurizer as in option 1\n",
    "* separate pipeline class for transforming the target series"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sktime.forecasting.base._base import BaseForecaster\n",
    "from sktime.forecasting.base._sktime import BaseSktimeForecaster\n",
    "from sktime.forecasting.base._sktime import OptionalForecastingHorizonMixin"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ForecastingPipeline(OptionalForecastingHorizonMixin, BaseSktimeForecaster):\n",
    "    \n",
    "    def __init__(self, estimators):\n",
    "        self.estimators = estimators\n",
    "        super(ForecastingPipeline, self).__init__()\n",
    "        \n",
    "    def fit(self, y, X=None, fh=None):\n",
    "        # even though this is a meta-estimator, we need to keep track of fh\n",
    "        # and the cutoff to pre-initialise X in predict if no X is given\n",
    "        self._set_y_X(y, X)\n",
    "        self._set_fh(fh) \n",
    "        \n",
    "        _check_estimators(self.estimators)\n",
    "        \n",
    "        # check and clone estimators \n",
    "        self.estimators_ = [(name, clone(estimator)) for name, estimator in self.estimators]\n",
    "        \n",
    "        # 1. transformations\n",
    "        for i, name, transformer in self.transformers_():\n",
    "            X = transformer.fit_transform(X, y)\n",
    "            self.estimators_[i] = (name, transformer)\n",
    "\n",
    "        # 2. fit final forecaster\n",
    "        name, forecaster = self.forecaster_\n",
    "        forecaster.fit(y, fh=fh, X_train=X)\n",
    "        self.estimators_[-1] = (name, forecaster)\n",
    "        \n",
    "        self._is_fitted = True\n",
    "        return self\n",
    "    \n",
    "    def predict(self, fh=None, X=None):\n",
    "        self.check_is_fitted()\n",
    "        self._set_fh(fh)\n",
    "        \n",
    "        # if no exogneous variables are given, we need to pre-initialise \n",
    "        if X is None:\n",
    "            y_pred = pd.Series(index=self.fh.to_absolute(self.cutoff).to_pandas(), dtype=np.float)\n",
    "        \n",
    "        # 1. exogeneous transformations\n",
    "        for _, _, transformer in self.transformers_():\n",
    "            X = transformer.transform(X, y_pred)\n",
    "        \n",
    "        # 2. prediction\n",
    "        _, forecaster = self.forecaster_\n",
    "        y_pred = forecaster.predict(self.fh, X)\n",
    "            \n",
    "        return y_pred\n",
    "    \n",
    "    def transform(self, y=None, X=None):\n",
    "        self.check_is_fitted()\n",
    "        for i, name, transformer in self.transformers_():\n",
    "            X = transformer.transform(X, y)\n",
    "        return X\n",
    "        \n",
    "    @property\n",
    "    def forecaster_(self):\n",
    "        return self.estimators_[-1]\n",
    "        \n",
    "    def transformers_(self):\n",
    "        transformers = self.estimators_[:-1]\n",
    "        for i, (name, transformer) in enumerate(transformers):\n",
    "            yield i, name, transformer\n",
    "        \n",
    "def make_pipeline(*estimators): \n",
    "    estimators = [(_get_name(estimator), estimator) for estimator in estimators]\n",
    "    return ForecastingPipeline(estimators)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "y = load_airline()\n",
    "k = 6\n",
    "y_train, y_test = temporal_train_test_split(y, test_size=10)\n",
    "fh = ForecastingHorizon(y_test.index, is_relative=False)\n",
    "forecaster = make_pipeline(FourierFeaturizer(sp=12, k=k), AutoARIMA(seasonal=False, max_p=2, max_q=2, max_d=1, suppress_warnings=True))\n",
    "forecaster.fit(y_train)\n",
    "\n",
    "# tests\n",
    "_data = forecaster.forecaster_[-1]._forecaster.model_.arima_res_.data\n",
    "_X = _data.exog\n",
    "assert _X.shape == (y_train.shape[0], k * 2), print(_X.shape)\n",
    "_y = _data.endog\n",
    "np.testing.assert_array_equal(_y, y_train)\n",
    "\n",
    "y_pred = forecaster.predict(fh)\n",
    "plot_series(y_train, y_test, y_pred, labels=[\"y_train\", \"y_test\", \"y_pred\"]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "class TransformedTargetForecaster(BaseSktimeForecaster):\n",
    "    \n",
    "    def __init__(self, estimators):\n",
    "        self.estimators = estimators\n",
    "        \n",
    "    def fit(self, y, fh=None, X=None):\n",
    "        _check_estimators(self.estimators)\n",
    "        self.estimators_ = [(name, clone(estimator)) for name, estimator in self.estimators]\n",
    "        \n",
    "        # 1. transform\n",
    "        for i, name, transformer in self.transformers_():\n",
    "            y = transformer.fit_transform(y)\n",
    "            self.estimators_[i] = (name, transformer)\n",
    "            \n",
    "        # 2. fit final forecaster\n",
    "        name, forecaster = self.forecaster_\n",
    "        forecaster.fit(y, fh, X)\n",
    "        self.estimators_[-1] = (name, forecaster)\n",
    "        \n",
    "        self._is_fitted = True\n",
    "        return self\n",
    "    \n",
    "    def predict(self, fh=None, X=None):\n",
    "        self.check_is_fitted()\n",
    "        \n",
    "        # 1. predict\n",
    "        _, forecaster = self.forecaster_\n",
    "        y_pred = forecaster.predict(fh, X)\n",
    "        \n",
    "        # 2. inverse-transform \n",
    "        for _, _, transformer in self.transformers_(reverse=True):\n",
    "            y_pred = transformer.inverse_transform(y_pred)\n",
    "            \n",
    "        return y_pred\n",
    "    \n",
    "    def transformers_(self, reverse=False):\n",
    "        transformers = self.estimators_[:-1]\n",
    "        if reverse:\n",
    "            transformers = reversed(transformers)\n",
    "        for i, (name, transformer) in enumerate(transformers):\n",
    "            yield i, name, transformer        \n",
    "    \n",
    "    @property\n",
    "    def forecaster_(self):\n",
    "        return self.estimators_[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "pipe = TransformedTargetForecaster([(\"log\", LogTransformer()), (\"forecaster\", forecaster)])\n",
    "pipe.fit(y_train)\n",
    "\n",
    "# tests\n",
    "_data = pipe.forecaster_[-1].forecaster_[-1]._forecaster.model_.arima_res_.data\n",
    "_X = _data.exog\n",
    "assert _X.shape == (y_train.shape[0], k * 2), print(_X.shape)\n",
    "_y = _data.endog\n",
    "np.testing.assert_array_equal(_y, np.log(y_train))\n",
    "\n",
    "y_pred = forecaster.predict(fh)\n",
    "plot_series(y_train, y_test, y_pred, labels=[\"y_train\", \"y_test\", \"y_pred\"]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Series-as-features setting\n",
    "* use scikit-learn pipeline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.pipeline import make_pipeline as make_pipeline\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import confusion_matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[62,  0],\n",
       "       [ 0, 63]])"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X, y = make_classification_problem(n_instances=500, n_columns=2)\n",
    "X += 100\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y)\n",
    "classifier = make_pipeline(\n",
    "    make_instance_transformer(LogTransformer()),\n",
    "    make_instance_transformer(QuantileTransformer()), \n",
    "    DecisionTreeClassifier())\n",
    "classifier.fit(X_train, y_train)\n",
    "y_pred = classifier.predict(X_test)\n",
    "confusion_matrix(y_test, y_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}