diff --git a/cbm/CBM.py b/cbm/CBM.py
index 77d2678..000362f 100644
--- a/cbm/CBM.py
+++ b/cbm/CBM.py
@@ -22,8 +22,6 @@ class CBM(BaseEstimator):
         min_iterations_early_stopping:int = 20,
         epsilon_early_stopping:float = 1e-3,
         single_update_per_iteration:bool = True,
-        date_features: Union[str, List[str]] = 'day,month',
-        binning: Union[int, lambda x: int] = 10,
         metric: str = 'rmse',
         enable_bin_count: bool = False
         ) -> None:
@@ -48,88 +46,13 @@ class CBM(BaseEstimator):
         self.single_update_per_iteration = single_update_per_iteration
         self.enable_bin_count = enable_bin_count
 
-        # lets make sure it's serializable
-        if isinstance(date_features, list):
-            date_features = ",".join(date_features)
-        self.date_features = date_features
-        self.binning = binning
         self.metric = metric
 
-    def get_date_features(self) -> List[str]:
-        return self.date_features.split(",")
-
     def fit(self,
             X: Union[np.ndarray, pd.DataFrame],
             y: np.ndarray
             ) -> "CBM":
 
-        # keep feature names around
-
-        if isinstance(X, pd.DataFrame):
-            self._feature_names = []
-            self._feature_categories = []
-            self._feature_bins = []
-
-            X_numeric = []
-
-            for col in X.columns:
-                col_dtype = X[col].dtype
-
-                if pd.api.types.is_datetime64_any_dtype(col_dtype):
-                    for expansion in self.get_date_features():
-                        import calendar
-
-                        if expansion == 'day':
-                            self._feature_names.append(f'{col}_day')
-                            self._feature_categories.append(calendar.day_abbr)
-                            self._feature_bins.append(None)
-
-                            X_numeric.append(X[col].dt.dayofweek.values)
-
-                        elif expansion == 'month':
-                            self._feature_names.append(f'{col}_month')
-                            self._feature_categories.append(calendar.month_abbr)
-                            self._feature_bins.append(None)
-
-                            X_numeric.append(X[col].dt.month.values)
-
-                elif pd.api.types.is_float_dtype(col_dtype):
-                    # deal with continuous features
-                    bin_num = self.binning if isinstance(self.binning, int) else self.binning(X[col])
-
-                    X_binned, bins  = pd.qcut(X[col].fillna(0), bin_num, duplicates='drop', retbins=True)
-
-                    self._feature_names.append(col)
-                    self._feature_categories.append(X_binned.cat.categories.astype(str).tolist())
-                    self._feature_bins.append(bins)
-
-                    X_numeric.append(pd.cut(X[col].fillna(0), bins, include_lowest=True).cat.codes)
-
-                elif not pd.api.types.is_integer_dtype(col_dtype):
-                    self._feature_names.append(col)
-
-                    # convert to categorical
-                    X_cat = (X[col]
-                        .fillna('CBM_UnknownCategory')
-                        .astype('category'))
-
-                    # keep track of categories
-                    self._feature_categories.append(X_cat.cat.categories.tolist())
-                    self._feature_bins.append(None)
-
-                    # convert to 0-based index
-                    X_numeric.append(X_cat.cat.codes)
-                else:
-                    self._feature_names.append(col)
-                    self._feature_categories.append(None)
-                    self._feature_bins.append(None)
-
-                    X_numeric.append(X[col])
-
-            X = np.column_stack(X_numeric)
-        else:
-            self._feature_names = None
-
         X, y = check_X_y(X, y, y_numeric=True)
 
         # pre-processing
@@ -170,43 +93,6 @@ class CBM(BaseEstimator):
         return self
 
     def predict(self, X: np.ndarray, explain: bool = False):
-        if isinstance(X, pd.DataFrame):
-            X_numeric = []
-
-            offset = 0 # correct for date expansion
-            for i, col in enumerate(X.columns):
-                col_dtype = X[col].dtype
-
-                if pd.api.types.is_datetime64_any_dtype(col_dtype):
-                    for expansion in self.get_date_features():
-                        if expansion == 'day':
-                            X_numeric.append(X[col].dt.dayofweek.values)
-                            offset += 1
-
-                        elif expansion == 'month':
-                            X_numeric.append(X[col].dt.month.values)
-                            offset += 1
-
-                    offset -= 1                           
-
-                elif pd.api.types.is_float_dtype(col_dtype):
-                    # re-use binning from training
-                    X_numeric.append(pd.cut(X[col].fillna(0), self._feature_bins[i + offset], include_lowest=True).cat.codes)
-
-                elif not pd.api.types.is_integer_dtype(col_dtype):
-                    # convert to categorical
-                    X_cat = (X[col]
-                        .fillna('CBM_UnknownCategory')
-                        # re-use categories from training
-                        .astype(CategoricalDtype(categories=self._feature_categories[i + offset], ordered=True)))
-
-                    # convert to 0-based index
-                    X_numeric.append(X_cat.cat.codes)
-                else:
-                    X_numeric.append(X[col])
-
-            X = np.column_stack(X_numeric)
-
         X = check_array(X)
         check_is_fitted(self, "is_fitted_")
 
@@ -231,126 +117,6 @@ class CBM(BaseEstimator):
 
         self.is_fitted_ = True
 
-    def _plot_importance_categorical(self, ax, feature_idx: int, vmin: float, vmax: float, is_continuous: bool):
-        import matplotlib.pyplot as plt
-
-        cmap = plt.get_cmap("RdYlGn")
-
-        # plot positive/negative impact (so 1.x to 0.x)
-        weights = np.array(self.weights[feature_idx]) - 1
-
-        alpha = 1
-        if self._feature_bins[feature_idx] is not None or is_continuous:
-            ax.plot(range(len(weights)), weights)
-            alpha = 0.3
-
-        weights_normalized = [x - vmin / (vmax - vmin) for x in weights]
-
-        ax.bar(range(len(weights)), weights, color=cmap(weights_normalized), edgecolor='black', alpha=alpha)
-        ax.set_ylim(vmin, vmax)
-
-        # ax.barh(range(len(weights)), weights, color=cmap(weights_normalized), edgecolor='black', alpha=0.3)
-        # ax.set_xlim(vmin, vmax)
-
-        # ax_sub.set_title(feature_names[feature_idx] if feature_names is not None else f'Feature {feature_idx}')
-        ax.set_ylabel('% change')
-
-        if self._feature_names is not None:
-            ax.set_xlabel(self._feature_names[feature_idx])
-
-        if self._feature_categories[feature_idx] is not None:
-            ax.set_xticks(range(len(self._feature_categories[feature_idx])))
-            ax.set_xticklabels(self._feature_categories[feature_idx], rotation=45)
-
-    def _plot_importance_interaction(self, ax, feature_idx: int, vmin: float, vmax: float):
-        import matplotlib.pyplot as plt
-
-        weights = np.array(self.weights[feature_idx]) - 1
-
-        cat_df = pd.DataFrame(
-            [(int(c.split('_')[0]), int(c.split('_')[1]), i) for i, c in enumerate(self._feature_categories[feature_idx])],
-            columns=['f0', 'f1', 'idx'])
-    
-        cat_df.sort_values(['f0', 'f1'], inplace=True)
-    
-        cat_df_2d = cat_df.pivot(index='f0', columns='f1', values='idx')
-
-        # resort index by mean weight value
-        zi = np.array(weights)[cat_df_2d.to_numpy()]
-
-        sort_order = np.argsort(np.max(zi, axis=1))
-        cat_df_2d = cat_df_2d.reindex(cat_df_2d.index[sort_order])
-
-        # construct data matrices
-        xi = cat_df_2d.columns
-        yi = cat_df_2d.index
-        zi =  np.array(weights)[cat_df_2d.to_numpy()]
-    
-        im = ax.imshow(zi, cmap=plt.get_cmap("RdYlGn"), aspect='auto', vmin=vmin, vmax=vmax)
-    
-        cbar = ax.figure.colorbar(im, ax=ax)
-        cbar.ax.set_ylabel('% change', rotation=-90, va="bottom")
-    
-        if self._feature_names is not None:
-            names = self._feature_names[feature_idx].split('_X_')
-            ax.set_ylabel(names[0])
-            ax.set_xlabel(names[1])
-
-        # Show all ticks and label them with the respective list entries
-        ax.set_xticks(np.arange(len(xi)), labels=xi)
-        ax.set_yticks(np.arange(len(yi)), labels=yi)
-
-    def plot_importance(self, feature_names: list = None, continuous_features: list = None, **kwargs):
-        """Plot feature importance.
-
-        Args:
-            feature_names (list, optional): [description]. If the model was trained using a pandas dataframe, the feature names are automatically
-                extracted from the dataframe. If the model was trained using a numpy array, the feature names need to supplied.
-            continuous_features (list, optional): [description]. Will change the plot accordingly.
-        """        
-        import matplotlib.pyplot as plt
-
-        check_is_fitted(self, "is_fitted_")
-
-        if feature_names is not None:
-            self._feature_names = feature_names
-
-        n_features = len(self.weights)
-
-        n_cols = int(np.ceil( np.sqrt(n_features)))
-        n_rows = int(np.floor(np.sqrt(n_features)))
-
-        if n_cols * n_rows < n_features:
-            n_rows += 1
-
-        fig, ax = plt.subplots(n_rows, n_cols, **kwargs)
-        for r in range(n_rows):
-            for c in range(n_cols):
-                ax[r, c].set_axis_off()
-
-        fig.suptitle(f'Response mean: {self.y_mean:0.4f} | Iterations {self.iterations}')
-
-        vmin = np.min([np.min(w) for w in self.weights]) - 1
-        vmax = np.max([np.max(w) for w in self.weights]) - 1
-
-        for feature_idx in range(n_features):
-            ax_sub = ax[feature_idx // n_cols, feature_idx % n_cols]
-            ax_sub.set_axis_on()
-
-            # ax_sub.set_title(feature_names[feature_idx] if feature_names is not None else f'Feature {feature_idx}')
-            if continuous_features is None:
-                is_continuous = False
-            else:
-                if self._feature_names is not None:
-                    is_continuous = self._feature_names[feature_idx] in continuous_features
-                else:
-                    is_continuous = feature_idx in continuous_features
-
-            if self._feature_names is not None and '_X_' in self._feature_names[feature_idx]:
-                self._plot_importance_interaction(ax_sub, feature_idx, vmin, vmax)
-            else:
-                self._plot_importance_categorical(ax_sub, feature_idx, vmin, vmax, is_continuous)
-
     @property
     def weights(self):
         return self._cpp.weights
diff --git a/cbm/CBMExplainer.py b/cbm/CBMExplainer.py
new file mode 100644
index 0000000..0b9743c
--- /dev/null
+++ b/cbm/CBMExplainer.py
@@ -0,0 +1,209 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+from multiprocessing.sharedctypes import Value
+import numpy as np
+import pandas as pd
+
+from argparse import ArgumentTypeError
+from sklearn.pipeline import Pipeline
+from sklearn.compose import ColumnTransformer
+from sklearn.preprocessing import OrdinalEncoder, KBinsDiscretizer
+from typing import List, Tuple, Union
+
+from .sklearn import DateEncoder
+from .CBM import CBM
+
+import matplotlib.pyplot as plt
+
+from abc import ABC, abstractmethod
+
+# convenience registry to extract x-axis category labels from fitted transformers
+TRANSFORMER_INVERTER_REGISTRY = {}
+
+def transformer_inverter(transformer_class):
+	def decorator(inverter_class):
+		TRANSFORMER_INVERTER_REGISTRY[transformer_class] = inverter_class()
+		return inverter_class
+
+	return decorator
+
+# return categories for each feature_names_in_
+class TransformerInverter(ABC):
+	@abstractmethod
+	def get_category_names(self, transformer):
+		pass
+
+@transformer_inverter(DateEncoder)
+class DateEncoderInverter(TransformerInverter):
+	def get_category_names(self, transformer):
+		# for each feature we return the set of category labels
+		return list(map(lambda _: transformer.categories_, transformer.feature_names_in_))
+
+@transformer_inverter(KBinsDiscretizer)
+class KBinsDiscretizerInverter(TransformerInverter):
+	def get_category_names(self, transformer):
+		if transformer.encode != "ordinal":
+			raise ValueError("Only ordinal encoding supported")
+
+		# bin_edges is feature x bins
+		def bin_edges_to_str(bin_edges: np.ndarray):
+			return pd.IntervalIndex(pd.arrays.IntervalArray.from_breaks(np.concatenate([[-np.inf], bin_edges, [np.inf]])))
+
+		return list(map(bin_edges_to_str, transformer.bin_edges_))
+
+@transformer_inverter(OrdinalEncoder)
+class OrdinalEncoderInverter(TransformerInverter):
+	def get_category_names(self, transformer):
+		return transformer.categories_
+
+class CBMExplainerPlot:
+	feature_index_: int
+	feature_plots: List[dict]
+
+	def __init__(self):
+		self.feature_index_ = 0
+		self.feature_plots_ = []
+
+	def add_feature_plot(self, col_name: str, x_axis: List):
+		self.feature_plots_.append({
+			"col_name": col_name,
+			"x_axis": x_axis,
+			"feature_index": self.feature_index_,
+		})
+
+		# increment feature index (assume they are added in order)
+		self.feature_index_ += 1
+
+	def _plot_categorical(self, ax: plt.Axes, vmin: float, vmax: float, weights: np.ndarray, col_name: str, x_axis, **kwargs):
+		cmap = plt.get_cmap("RdYlGn")
+
+		is_continuous = isinstance(x_axis, pd.IntervalIndex)
+
+		# plot positive/negative impact (so 1.x to 0.x)
+		weights -= 1
+
+		alpha = 1
+		if is_continuous:
+			ax.plot(range(len(weights)), weights)
+			alpha = 0.3
+
+		# normalize for color map
+		weights_normalized = (weights - vmin) / (vmax - vmin)
+
+		# draw bars
+		ax.bar(range(len(weights)), weights, color=cmap(weights_normalized), edgecolor='black', alpha=alpha)
+
+		ax.set_ylim(vmin-0.1, vmax+0.1)
+		
+		ax.set_ylabel('% change')
+
+		ax.set_xlabel(col_name)
+
+		if not is_continuous:
+			ax.set_xticks(range(len(x_axis)))
+			ax.set_xticklabels(x_axis, rotation=45)
+
+	# TODO: support 2D interaction plots
+	# def _plot_importance_interaction(self, ax, feature_idx: int, vmin: float, vmax: float):
+	# 	import matplotlib.pyplot as plt
+
+	# 	weights = np.array(self.weights[feature_idx]) - 0
+
+	# 	cat_df = pd.DataFrame(
+	# 	[(int(c.split('_')[-1]), int(c.split('_')[1]), i) for i, c in enumerate(self._feature_categories[feature_idx])],
+	# 	columns=['f-1', 'f1', 'idx'])
+	
+	# 	cat_df.sort_values(['f-1', 'f1'], inplace=True)
+	
+	# 	cat_df_1d = cat_df.pivot(index='f0', columns='f1', values='idx')
+
+	# 	# resort index by mean weight value
+	# 	zi = np.array(weights)[cat_df_1d.to_numpy()]
+
+	# 	sort_order = np.argsort(np.max(zi, axis=0))
+	# 	cat_df_1d = cat_df_2d.reindex(cat_df_2d.index[sort_order])
+
+	# 	# construct data matrices
+	# 	xi = cat_df_1d.columns
+	# 	yi = cat_df_1d.index
+	# 	zi =  np.array(weights)[cat_df_1d.to_numpy()]
+	
+	# 	im = ax.imshow(zi, cmap=plt.get_cmap("RdYlGn"), aspect='auto', vmin=vmin, vmax=vmax)
+	
+	# 	cbar = ax.figure.colorbar(im, ax=ax)
+	# 	cbar.ax.set_ylabel('% change', rotation=-91, va="bottom")
+	
+	# 	if self._feature_names is not None:
+	# 	names = self._feature_names[feature_idx].split('_X_')
+	# 	ax.set_ylabel(names[-1])
+	# 	ax.set_xlabel(names[0])
+
+	# 	# Show all ticks and label them with the respective list entries
+	# 	ax.set_xticks(np.arange(len(xi)), labels=xi)
+	# 	ax.set_yticks(np.arange(len(yi)), labels=yi)
+
+	def plot(self, model: CBM, **kwargs) -> Tuple[plt.Figure, plt.Axes]:
+		num_plots = max(self.feature_plots_, key=lambda d: d["feature_index"])["feature_index"] + 1
+		n_features = len(model.weights)
+
+		if num_plots != n_features:
+			raise ValueError(f"Missing plots for some features ({num_plots} vs {n_features})")
+
+		# setup plot
+		n_rows = num_plots
+		n_cols = 1
+
+		fig, ax = plt.subplots(n_rows, n_cols, **kwargs)
+
+		for i in range(num_plots):
+			ax[i].set_axis_off()
+
+		fig.suptitle(f'Response mean: {model.y_mean:0.2f} | Iterations {model.iterations}')
+
+		# extract weights from model
+		weights = model.weights
+
+		# find global min/max
+		vmin = np.min([np.min(w) for w in weights]) - 1
+		vmax = np.max([np.max(w) for w in weights]) - 1
+
+		for feature_idx in range(n_features):
+			ax_sub = ax[feature_idx]
+			ax_sub.set_axis_on()
+
+			feature_weights = np.array(weights[feature_idx])
+
+			self._plot_categorical(ax_sub, vmin, vmax, feature_weights, **self.feature_plots_[feature_idx])
+
+		plt.tight_layout()
+
+		return fig, ax
+
+class CBMExplainer:
+	def __init__(self, pipeline: Pipeline):
+		if not isinstance(pipeline, Pipeline):
+			raise ArgumentTypeError("pipeline must be of type sklearn.pipeline.Pipeline")
+
+		self.pipeline_ = pipeline
+
+	def _plot_column_transformer(self, transformer: ColumnTransformer, plot: CBMExplainerPlot):
+		# need to access transformers_ (vs transformers) to get the fitted transformer instance
+		for (name, transformer, cols) in transformer.transformers_:
+			# extension methods ;)
+			transformer_inverter = TRANSFORMER_INVERTER_REGISTRY[type(transformer)]
+			category_names = transformer_inverter.get_category_names(transformer)
+
+			for (col_name, cat) in zip(cols, category_names):
+				plot.add_feature_plot(col_name, cat)
+
+	def plot_importance(self, **kwargs) -> Tuple[plt.Figure, plt.Axes]:
+		plot = CBMExplainerPlot()
+
+		# iterate through pipeline
+		for (name, component) in self.pipeline_.steps[0:-1]:
+			if isinstance(component, ColumnTransformer):
+				self._plot_column_transformer(component, plot)
+
+		model = self.pipeline_.steps[-1][1]
+		return plot.plot(model, **kwargs)
diff --git a/cbm/__init__.py b/cbm/__init__.py
index 9713210..3622afc 100644
--- a/cbm/__init__.py
+++ b/cbm/__init__.py
@@ -2,6 +2,8 @@
 # Licensed under the MIT License.
 
 from .CBM import CBM
+from .sklearn import DateEncoder, TemporalSplit
+from .CBMExplainer import CBMExplainer
 from ._version import __version__
 
-__all__ = ['CBM', '__version__']
\ No newline at end of file
+__all__ = ['CBM', '__version__', 'DateEncoder', 'TemporalSplit']
\ No newline at end of file
diff --git a/cbm/sklearn.py b/cbm/sklearn.py
new file mode 100644
index 0000000..5ea6a02
--- /dev/null
+++ b/cbm/sklearn.py
@@ -0,0 +1,110 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+import calendar
+import numpy as np
+
+from sklearn.model_selection import TimeSeriesSplit
+from sklearn.utils import indexable
+from sklearn.base import BaseEstimator, TransformerMixin
+from sklearn.utils.validation import _check_feature_names_in
+
+from datetime import timedelta
+
+# TODO
+class TemporalSplit(TimeSeriesSplit):
+    def __init__(self, step=timedelta(days=1), n_splits=5, *, max_train_size=None, test_size=None, gap=0):
+        super().__init__(n_splits)
+        self.step = step
+        self.max_train_size = max_train_size
+        self.test_size = test_size
+        self.gap = gap
+
+    def _create_date_ranges(self, start, end, step):
+        start_ = start
+        while start_ < end:
+            end_ = start_ + step
+            yield start_
+            start_ = end_
+            
+    def split(self, X, y=None, groups=None):
+        """Generate indices to split data into training and test set.
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            Training data, where `n_samples` is the number of samples
+            and `n_features` is the number of features.
+        y : array-like of shape (n_samples,)
+            Always ignored, exists for compatibility.
+        groups : array-like of shape (n_samples,)
+            Always ignored, exists for compatibility.
+        Yields
+        ------
+        train : ndarray
+            The training set indices for that split.
+        test : ndarray
+            The testing set indices for that split.
+        """
+        X, y, groups = indexable(X, y, groups)
+        
+        date_range = list(self._create_date_ranges(X.index.min(), X.index.max(), self.step))
+        n_samples =  len(date_range)
+        n_splits = self.n_splits
+        n_folds = n_splits + 1
+        gap = self.gap
+        test_size = (
+            self.test_size if self.test_size is not None else n_samples // n_folds
+        )
+
+        # Make sure we have enough samples for the given split parameters
+        if n_folds > n_samples:
+            raise ValueError(
+                f"Cannot have number of folds={n_folds} greater"
+                f" than the number of samples={n_samples}."
+            )
+        if n_samples - gap - (test_size * n_splits) <= 0:
+            raise ValueError(
+                f"Too many splits={n_splits} for number of samples"
+                f"={n_samples} with test_size={test_size} and gap={gap}."
+            )
+
+        test_starts = range(n_samples - n_splits * test_size, n_samples, test_size)
+
+        for test_start in test_starts:
+            train_end = test_start - gap
+            if self.max_train_size and self.max_train_size < train_end:
+                yield (
+                    np.where(np.logical_and(X.index >= date_range[train_end - self.max_train_size], X.index <= date_range[train_end - 1]))[0],
+                    np.where(np.logical_and(X.index >= date_range[test_start], X.index <= date_range[test_start + test_size - 1]))[0]
+                )
+            else:
+                yield (
+                    np.where(X.index < date_range[train_end])[0],
+                    np.where(np.logical_and(X.index >= date_range[test_start], X.index <= date_range[test_start + test_size - 1]))[0]
+		)
+
+
+# TODO: add unit test
+class DateEncoder(BaseEstimator, TransformerMixin):
+    def __init__(self, component = 'month' ):
+        if component == 'weekday':
+            self.categories_ = list(calendar.day_abbr)
+            self.column_to_ordinal_ = lambda col: col.dt.weekday.values
+        elif component == 'dayofyear':
+            self.categories_ = list(range(1, 366))
+            self.column_to_ordinal_ = lambda col: col.dt.dayofyear.values
+        elif component == 'month':
+            self.categories_ = list(calendar.month_abbr)
+            self.column_to_ordinal_ = lambda col: col.dt.month.values
+        else:
+            raise ValueError('component must be either day or month')
+        
+        self.component = component
+    
+    def fit(self, X, y = None):
+        self._validate_data(X, dtype="datetime64")
+
+        return self
+    
+    def transform(self, X, y = None):
+        return X.apply(self.column_to_ordinal_, axis=0)
diff --git a/kaggle/demand-forecasting-kernels-only/kaggle.ipynb b/kaggle/demand-forecasting-kernels-only/kaggle.ipynb
new file mode 100644
index 0000000..ad6fe91
--- /dev/null
+++ b/kaggle/demand-forecasting-kernels-only/kaggle.ipynb
@@ -0,0 +1,545 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "c2586260",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "from sklearn.model_selection import TimeSeriesSplit\n",
+    "from sklearn.metrics import mean_squared_error\n",
+    "\n",
+    "%load_ext autoreload\n",
+    "%autoreload 2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "9e675d3d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train      = pd.read_csv('data/train.csv', parse_dates=['date'])\n",
+    "test       = pd.read_csv('data/test.csv', parse_dates=['date']) # Reading test data\n",
+    "sample_sub = pd.read_csv('data/sample_submission.csv') # Reading the sample submission that is provided by Kaggle\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "181136e0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def smape(preds, target):\n",
+    "    n = len(preds)\n",
+    "    masked_arr = ~((preds == 0) & (target == 0))\n",
+    "    preds, target = preds[masked_arr], target[masked_arr]\n",
+    "    num = np.abs(preds - target)\n",
+    "    denom = np.abs(preds) + np.abs(target)\n",
+    "    smape_val = (200 * np.sum(num / denom)) / n\n",
+    "    return smape_val"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 94,
+   "id": "f1a59255",
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "RMSE 7.269014341615695\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x1440 with 7 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import cbm\n",
+    "from sklearn.metrics import mean_squared_error\n",
+    "\n",
+    "# load data\n",
+    "train = pd.read_csv('data/train.csv', parse_dates=['date'])\n",
+    "test  = pd.read_csv('data/test.csv',  parse_dates=['date']) \n",
+    "\n",
+    "# feature engineering\n",
+    "min_date = train['date'].min()\n",
+    "\n",
+    "def featurize(df):\n",
+    "    out = pd.DataFrame({\n",
+    "        'seasonal' : (df['date'] - min_date).dt.days // 60, # TODO: for prediction such features need seperate modelling\n",
+    "        'store'    : df['store'], \n",
+    "        'item'     : df['item'], \n",
+    "        'date'     : df['date'],\n",
+    "        # <name-1> _X_ <name-2> to mark interaction features\n",
+    "        'item_X_month': df['item'].astype(str) + '_' + df['date'].dt.month.astype(str)\n",
+    "    })\n",
+    "    \n",
+    "    return out\n",
+    "\n",
+    "x_train_df = featurize(train)\n",
+    "x_test_df  = featurize(test)\n",
+    "y_train = train['sales']\n",
+    "\n",
+    "# model training\n",
+    "model = cbm.CBM()\n",
+    "model.fit(x_train_df, y_train)\n",
+    "\n",
+    "# test on train error\n",
+    "y_pred_train = model.predict(x_train_df).flatten()\n",
+    "print('RMSE', mean_squared_error(y_pred_train, y_train, squared=False))\n",
+    "\n",
+    "# plotting\n",
+    "model.plot_importance(figsize=(20, 20), continuous_features=['seasonal'])\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c9e1da68",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Random Noise\n",
+    "def random_noise(dataframe):\n",
+    "    return np.random.normal(scale=1.6, size=(len(dataframe),))\n",
+    "\n",
+    "# Lag/Shifted Features\n",
+    "def lag_features(dataframe, lags):\n",
+    "    for lag in lags:\n",
+    "        dataframe['sales_lag_' + str(lag)] = dataframe.groupby([\"store\", \"item\"])['sales'].transform(\n",
+    "            lambda x: x.shift(lag)) + random_noise(dataframe)\n",
+    "    return dataframe\n",
+    "\n",
+    "# Rolling Mean Features\n",
+    "def roll_mean_features(dataframe, windows):\n",
+    "    for window in windows:\n",
+    "        dataframe['sales_roll_mean_' + str(window)] = dataframe.groupby([\"store\", \"item\"])['sales']. \\\n",
+    "                                                          transform(\n",
+    "            lambda x: x.shift(1).rolling(window=window, min_periods=10, win_type=\"triang\").mean()) + random_noise(dataframe)\n",
+    "    return dataframe\n",
+    "\n",
+    "# Exponentially Weighted Mean Features\n",
+    "def ewm_features(dataframe, alphas, lags):\n",
+    "    for alpha in alphas:\n",
+    "        for lag in lags:\n",
+    "            dataframe['sales_ewm_alpha_' + str(alpha).replace(\".\", \"\") + \"_lag_\" + str(lag)] = \\\n",
+    "                dataframe.groupby([\"store\", \"item\"])['sales'].transform(lambda x: x.shift(lag).ewm(alpha=alpha).mean())\n",
+    "    return dataframe"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "785178cd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Validation set including first 3 months of 2017 (as we will forecast the first 3 months of 2018)\n",
+    "# val = df.loc[(df[\"date\"] >= \"2017-01-01\") & (df[\"date\"] < \"2017-04-01\"), :]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6545bfba",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train      = pd.read_csv('data/train.csv', parse_dates=['date'])\n",
+    "\n",
+    "# train.sort_values(by=['store', 'item', 'date'], axis=0, inplace=True)\n",
+    "\n",
+    "# train = roll_mean_features(train, [365, 546])\n",
+    "# train = lag_features(train, [91, 98, 105, 112, 119, 126, 182, 364, 546, 728])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a79fc7a3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 95,
+   "id": "e360637f",
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Test on train: 12.798603868130076 51.037721330095835\n",
+      "Test on test:  13.267740258991692 46.09033508231243\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x1080 with 8 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "train_dt = train.pivot_table(index='date', columns=['store', 'item']).sort_index()\n",
+    "\n",
+    "def featurize(df):\n",
+    "    out = pd.DataFrame({\n",
+    "        'seasonal' : (df['date'] - min_date).dt.days // 50,\n",
+    "        # 'store'    : df['store'], \n",
+    "        # 'item'     : df['item'], \n",
+    "        # 'month_begin': df['date'].dt.is_month_start,\n",
+    "        # build interaction feature\n",
+    "        # 'store_item' : df['item'].astype(str) + '_' + df['store'].astype(str),\n",
+    "        'date'        : df['date'],\n",
+    "        # 'sales_lag_364': df['sales_lag_364'],\n",
+    "        # 'sales_roll_mean_365': df['sales_roll_mean_365'],\n",
+    "        # 'sales_roll_mean_546': df['sales_roll_mean_546'],\n",
+    "        # 'dayofyear'   : df['date'].dt.dayofyear,\n",
+    "        'store_X_month'     : df['store'].astype(str) + '_' + df['date'].dt.month.astype(str),\n",
+    "        # 'store_dayofweek' : df['store'].astype(str) + '_' + df['date'].dt.dayofweek.astype(str),\n",
+    "        'item_X_month'      : df['item'].astype(str) + '_' + df['date'].dt.month.astype(str),\n",
+    "        # 'item_dayofweek'    : df['item'].astype(str) + '_' + df['date'].dt.dayofweek.astype(str),\n",
+    "        # 'weekofmonth_month' : df['date'].dt.weekofmonth.astype(str) + '_' + df['date'].dt.month.astype(str),\n",
+    "        # 'weekofmonth_month' : df['date'].dt.weekofmonth.astype(str) + '_' + df['store'].astype(str),\n",
+    "    })\n",
+    "    \n",
+    "    return out\n",
+    "\n",
+    "train_Xy = train.loc[(train[\"date\"] < \"2017-01-01\"), :].dropna()\n",
+    "\n",
+    "# Validation set including first 3 months of 2017 (as we will forecast the first 3 months of 2018)\n",
+    "test_Xy = train.loc[(train[\"date\"] >= \"2017-01-01\") & (train[\"date\"] < \"2017-04-01\"), :]\n",
+    "if True:    \n",
+    "    \n",
+    "# tscv = TimeSeriesSplit(n_splits=5, test_size=90)\n",
+    "# for train_idx, test_idx in tscv.split(train_dt):\n",
+    "#     train_Xy = train_dt.iloc[train_idx,].unstack().reset_index().rename({0: 'sales'}, axis=1)\n",
+    "#     test_Xy =  train_dt.iloc[test_idx, ].unstack().reset_index().rename({0: 'sales'}, axis=1)\n",
+    "\n",
+    "    # print(f'Setup {len(train_idx)}: {min(test_idx)} to {max(test_idx)}')\n",
+    "    # print(sum(train_idx))\n",
+    "    \n",
+    "    train_df = featurize(train_Xy)\n",
+    "    test_df  = featurize(test_Xy)\n",
+    "    \n",
+    "    model = cbm.CBM() # binning=40) # learning_rate_step_size=1/400) #epsilon_early_stopping=1e-7) # metric='smape') # learning_rate_step_size=1/400)\n",
+    "    model.fit(train_df, train_Xy['sales'])\n",
+    "\n",
+    "    y_pred = model.predict(train_df).flatten()\n",
+    "    print('Test on train:', smape(y_pred, train_Xy['sales']), mean_squared_error(y_pred, train_Xy['sales']))\n",
+    "    \n",
+    "    # forward\n",
+    "    from sktime.forecasting.exp_smoothing import ExponentialSmoothing\n",
+    "    from sktime.utils.plotting import plot_series\n",
+    "\n",
+    "    y_dummy = np.array(model.weights[0])\n",
+    "    y_dummy_ts = pd.Series(y_dummy)\n",
+    "\n",
+    "    fh = np.arange(-len(y_dummy_ts)+1, # cover the training period\n",
+    "                   test_df['seasonal'].max() + 2 - len(y_dummy_ts) # cover the test period\n",
+    "                  )\n",
+    "\n",
+    "    forecaster = ExponentialSmoothing(trend=\"add\", seasonal=\"additive\", sp=5)\n",
+    "    forecaster.fit(y_dummy_ts)\n",
+    "    y_pred = forecaster.predict(fh=fh)    \n",
+    "    \n",
+    "    w = model.weights\n",
+    "    w[0] = y_pred\n",
+    "    model.update(w, model.y_mean)\n",
+    "    \n",
+    "    # test n\n",
+    "    y_pred = model.predict(test_df).flatten()\n",
+    "    \n",
+    "    print('Test on test: ', smape(y_pred, test_Xy['sales']), mean_squared_error(y_pred, test_Xy['sales']))\n",
+    "    \n",
+    "model.plot_importance(figsize=(20, 15), continuous_features=['seasonal'])\n",
+    "# 13.589953604669455\n",
+    "# 13.449736631731762\n",
+    "# 13.267740258991692"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "id": "aa8f6a42",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(0.6547481737793157, 0.007381776239907728, 0.14917339484813533, 1.0)"
+      ]
+     },
+     "execution_count": 37,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "plt.get_cmap(\"RdYlGn\")(1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 175,
+   "id": "1860e61e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "90"
+      ]
+     },
+     "execution_count": 175,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "test['date'].nunique()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 153,
+   "id": "0d6665a6",
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.6519865732958832"
+      ]
+     },
+     "execution_count": 153,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 67,
+   "id": "58414a16",
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "IndexError",
+     "evalue": "list index out of range",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
+      "\u001b[0;32m/tmp/ipykernel_24869/433266724.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     39\u001b[0m \u001b[0mcrossing\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'store_month'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'store_dayofweek'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'item_month'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'item_dayofweek'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     40\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 41\u001b[0;31m \u001b[0mvmin\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mweights\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m10\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     42\u001b[0m \u001b[0mvmax\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmax\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmax\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mweights\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m10\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     43\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m/tmp/ipykernel_24869/433266724.py\u001b[0m in \u001b[0;36m<listcomp>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     39\u001b[0m \u001b[0mcrossing\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'store_month'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'store_dayofweek'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'item_month'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'item_dayofweek'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     40\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 41\u001b[0;31m \u001b[0mvmin\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mweights\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m10\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     42\u001b[0m \u001b[0mvmax\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmax\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmax\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mweights\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m10\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     43\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;31mIndexError\u001b[0m: list index out of range"
+     ]
+    }
+   ],
+   "source": [
+    "def plot_heatmap(data_series, weights, ax=None, vmin=None, vmax=None):\n",
+    "    story_month_cat = data_series.astype('category')\n",
+    "    # # train_df['store_month'].astype('category')\n",
+    "\n",
+    "    cat_df = pd.DataFrame(\n",
+    "        [(int(c.split('_')[0]), int(c.split('_')[1]), i) for i, c in enumerate(story_month_cat.cat.categories)],\n",
+    "        columns=['f0', 'f1', 'idx'])\n",
+    "\n",
+    "    cat_df.sort_values(['f0', 'f1'], inplace=True)\n",
+    "\n",
+    "    cat_df_2d = cat_df.pivot(index='f0', columns='f1', values='idx')\n",
+    "    \n",
+    "    # resort index by mean weight value\n",
+    "    zi = np.array(weights)[cat_df_2d.to_numpy()]\n",
+    "    \n",
+    "    sort_order = np.argsort(np.max(zi, axis=1))\n",
+    "    cat_df_2d = cat_df_2d.reindex(cat_df_2d.index[sort_order])\n",
+    "    \n",
+    "    xi = cat_df_2d.columns\n",
+    "    yi = cat_df_2d.index\n",
+    "    zi =  np.array(weights)[cat_df_2d.to_numpy()]\n",
+    "\n",
+    "    # CS = plt.contourf(xi, yi, zi, 15, cmap=plt.get_cmap(\"RdYlGn\"))\n",
+    "\n",
+    "    if ax is None:\n",
+    "        fig, ax = plt.subplots()\n",
+    "        \n",
+    "    im = ax.imshow(zi, cmap=plt.get_cmap(\"RdYlGn\"), aspect='auto', vmin=vmin, vmax=vmax)\n",
+    "\n",
+    "    cbar = ax.figure.colorbar(im, ax=ax)\n",
+    "    cbar.ax.set_ylabel(data_series.name, rotation=-90, va=\"bottom\")\n",
+    "\n",
+    "    # Show all ticks and label them with the respective list entries\n",
+    "    ax.set_xticks(np.arange(len(xi)), labels=xi)\n",
+    "    ax.set_yticks(np.arange(len(yi)), labels=yi)\n",
+    "    \n",
+    "# plt.colorbar()  \n",
+    "# plt.show()\n",
+    "crossing = ['store_month', 'store_dayofweek', 'item_month', 'item_dayofweek']\n",
+    "\n",
+    "vmin = np.min([np.min(model.weights[i]) for i in range(6, 10)])\n",
+    "vmax = np.max([np.max(model.weights[i]) for i in range(6, 10)])\n",
+    "\n",
+    "fig, ax = plt.subplots(2, 2, figsize=(20, 20))\n",
+    "for i, f in enumerate(crossing):\n",
+    "    plot_heatmap(train_df[f], model.weights[6+i], ax = ax[i//2, i%2], vmin=vmin, vmax=vmax)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "f4bba7e2",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x720 with 6 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "model.plot_importance(figsize=(15, 10))    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "2d22ce11",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<AxesSubplot:xlabel='item'>"
+      ]
+     },
+     "execution_count": 28,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "eval_df = pd.concat([test_Xy, pd.Series(y_pred, name='pred')], axis=1)\n",
+    "\n",
+    "(eval_df.groupby('item')\n",
+    "     .apply(lambda g: smape(g['pred'], g['sales']))\n",
+    "     .sort_values()\n",
+    "     .plot.bar(figsize=(15, 5)))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "37883061",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<AxesSubplot:xlabel='store'>"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "(eval_df.groupby('store')\n",
+    "     .apply(lambda g: smape(g['pred'], g['sales']))\n",
+    "     .sort_values()\n",
+    "     .plot.bar(figsize=(15, 5)))"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/kaggle/favorita-grocery-sales-forecasting/kaggle.ipynb b/kaggle/favorita-grocery-sales-forecasting/kaggle.ipynb
new file mode 100644
index 0000000..6c7b041
--- /dev/null
+++ b/kaggle/favorita-grocery-sales-forecasting/kaggle.ipynb
@@ -0,0 +1,2164 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "2a36103a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<style>.container { width:100% !important; }</style>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<style>.output_result { max-width:100% !important; }</style>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<style>.prompt { display:none !important; }</style>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%load_ext autoreload\n",
+    "%autoreload 2\n",
+    "\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "from IPython.core.display import display, HTML\n",
+    "display(HTML(\"<style>.container { width:100% !important; }</style>\"))\n",
+    "display(HTML(\"<style>.output_result { max-width:100% !important; }</style>\"))\n",
+    "display(HTML(\"<style>.prompt { display:none !important; }</style>\"))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "04b0763f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# \n",
+    "# train = pd.read_csv('data/train.csv', \n",
+    "#                     parse_dates=['date'], \n",
+    "#                     index_col='id', \n",
+    "#                     dtype={\n",
+    "#                         # 'date': np.datetime64, \n",
+    "#                         'store_nbr': np.short,\n",
+    "#                         'item_nbr': np.int64,\n",
+    "#                         'unit_sales': np.float64\n",
+    "#                     },\n",
+    "#                     converters={'onpromotion': lambda x: 'T' if x == 'True' else ('F' if x == 'False' else 'U')}\n",
+    "#                    )\n",
+    "#\n",
+    "# train.merge(items).to_parquet('data/train_items.parquet')\n",
+    "# train['class'] = train['class'].astype('str')\n",
+    "# train['item_nbr'] = train['item_nbr'].astype('str')\n",
+    "# train.to_parquet('data/train.parquet')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "7412ac39",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>date</th>\n",
+       "      <th>store_nbr</th>\n",
+       "      <th>item_nbr</th>\n",
+       "      <th>unit_sales</th>\n",
+       "      <th>onpromotion</th>\n",
+       "      <th>family</th>\n",
+       "      <th>class</th>\n",
+       "      <th>perishable</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>2013-01-01</td>\n",
+       "      <td>25</td>\n",
+       "      <td>103665</td>\n",
+       "      <td>7.0</td>\n",
+       "      <td>U</td>\n",
+       "      <td>BREAD/BAKERY</td>\n",
+       "      <td>2712</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>2013-01-02</td>\n",
+       "      <td>1</td>\n",
+       "      <td>103665</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>U</td>\n",
+       "      <td>BREAD/BAKERY</td>\n",
+       "      <td>2712</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>2013-01-02</td>\n",
+       "      <td>2</td>\n",
+       "      <td>103665</td>\n",
+       "      <td>5.0</td>\n",
+       "      <td>U</td>\n",
+       "      <td>BREAD/BAKERY</td>\n",
+       "      <td>2712</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>2013-01-02</td>\n",
+       "      <td>3</td>\n",
+       "      <td>103665</td>\n",
+       "      <td>6.0</td>\n",
+       "      <td>U</td>\n",
+       "      <td>BREAD/BAKERY</td>\n",
+       "      <td>2712</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>2013-01-02</td>\n",
+       "      <td>4</td>\n",
+       "      <td>103665</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>U</td>\n",
+       "      <td>BREAD/BAKERY</td>\n",
+       "      <td>2712</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "        date  store_nbr  item_nbr  unit_sales onpromotion        family  \\\n",
+       "0 2013-01-01         25    103665         7.0           U  BREAD/BAKERY   \n",
+       "1 2013-01-02          1    103665         2.0           U  BREAD/BAKERY   \n",
+       "2 2013-01-02          2    103665         5.0           U  BREAD/BAKERY   \n",
+       "3 2013-01-02          3    103665         6.0           U  BREAD/BAKERY   \n",
+       "4 2013-01-02          4    103665         2.0           U  BREAD/BAKERY   \n",
+       "\n",
+       "   class  perishable  \n",
+       "0   2712           1  \n",
+       "1   2712           1  \n",
+       "2   2712           1  \n",
+       "3   2712           1  \n",
+       "4   2712           1  "
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# scikit-based\n",
+    "\n",
+    "train_all = pd.read_parquet('data/train_items.parquet')\n",
+    "train_all.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "9400687b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(125497040, 8)"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "train_all.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "c62e0a47",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0    1\n",
+       "1    2\n",
+       "2    2\n",
+       "3    2\n",
+       "4    2\n",
+       "Name: date, dtype: int64"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# train['Weekday'] = train['date'].dt.dayofweek_str\n",
+    "train.head()['date'].dt.dayofweek"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "dad0788e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sklearn.model_selection import TimeSeriesSplit\n",
+    "from sklearn.utils import indexable\n",
+    "\n",
+    "from datetime import datetime, timedelta\n",
+    "\n",
+    "# TODO\n",
+    "class TemporalSplit(TimeSeriesSplit):\n",
+    "    def __init__(self, step=timedelta(days=1), n_splits=5, *, max_train_size=None, test_size=None, gap=0):\n",
+    "        super().__init__(n_splits)\n",
+    "        self.step = step\n",
+    "        self.max_train_size = max_train_size\n",
+    "        self.test_size = test_size\n",
+    "        self.gap = gap\n",
+    "\n",
+    "    def _create_date_ranges(self, start, end, step):\n",
+    "        start_ = start\n",
+    "        while start_ < end:\n",
+    "            end_ = start_ + step\n",
+    "            yield start_\n",
+    "            start_ = end_\n",
+    "            \n",
+    "    def split(self, X, y=None, groups=None):\n",
+    "        \"\"\"Generate indices to split data into training and test set.\n",
+    "        Parameters\n",
+    "        ----------\n",
+    "        X : array-like of shape (n_samples, n_features)\n",
+    "            Training data, where `n_samples` is the number of samples\n",
+    "            and `n_features` is the number of features.\n",
+    "        y : array-like of shape (n_samples,)\n",
+    "            Always ignored, exists for compatibility.\n",
+    "        groups : array-like of shape (n_samples,)\n",
+    "            Always ignored, exists for compatibility.\n",
+    "        Yields\n",
+    "        ------\n",
+    "        train : ndarray\n",
+    "            The training set indices for that split.\n",
+    "        test : ndarray\n",
+    "            The testing set indices for that split.\n",
+    "        \"\"\"\n",
+    "        X, y, groups = indexable(X, y, groups)\n",
+    "        \n",
+    "        date_range = list(self._create_date_ranges(X.index.min(), X.index.max(), self.step))\n",
+    "        n_samples =  len(date_range)\n",
+    "        n_splits = self.n_splits\n",
+    "        n_folds = n_splits + 1\n",
+    "        gap = self.gap\n",
+    "        test_size = (\n",
+    "            self.test_size if self.test_size is not None else n_samples // n_folds\n",
+    "        )\n",
+    "\n",
+    "        # Make sure we have enough samples for the given split parameters\n",
+    "        if n_folds > n_samples:\n",
+    "            raise ValueError(\n",
+    "                f\"Cannot have number of folds={n_folds} greater\"\n",
+    "                f\" than the number of samples={n_samples}.\"\n",
+    "            )\n",
+    "        if n_samples - gap - (test_size * n_splits) <= 0:\n",
+    "            raise ValueError(\n",
+    "                f\"Too many splits={n_splits} for number of samples\"\n",
+    "                f\"={n_samples} with test_size={test_size} and gap={gap}.\"\n",
+    "            )\n",
+    "\n",
+    "        # indices = np.arange(n_samples)\n",
+    "        test_starts = range(n_samples - n_splits * test_size, n_samples, test_size)\n",
+    "\n",
+    "        for test_start in test_starts:\n",
+    "            train_end = test_start - gap\n",
+    "            if self.max_train_size and self.max_train_size < train_end:\n",
+    "                yield (\n",
+    "                    # TODO: unit test\n",
+    "                    # TODO: not sure why np.where returns a tuple.\n",
+    "                    np.where(np.logical_and(X.index >= date_range[train_end - self.max_train_size], X.index <= date_range[train_end - 1]))[0],\n",
+    "                    np.where(np.logical_and(X.index >= date_range[test_start], X.index <= date_range[test_start + test_size - 1]))[0]\n",
+    "                    # indices[train_end - self.max_train_size : train_end],\n",
+    "                    # indices[test_start : test_start + test_size],\n",
+    "                )\n",
+    "            else:\n",
+    "                yield (\n",
+    "                    np.where(X.index < date_range[train_end])[0],\n",
+    "                    np.where(np.logical_and(X.index >= date_range[test_start], X.index <= date_range[test_start + test_size - 1]))[0]\n",
+    "                    # indices[:train_end],\n",
+    "                    # indices[test_start : test_start + test_size],\n",
+    "                )\n",
+    "\n",
+    "# cv = list(TemporalSplit(n_splits=3, test_size=100).split(train_idx))\n",
+    "# for s in cv:\n",
+    "#     print(s[0])\n",
+    "#     print(s[0][0])\n",
+    "#     print(f'Train: {train_idx.iloc[s[0]].index.min()} - {train_idx.iloc[s[0]].index.max()}')\n",
+    "#     print(f'Test:  {train_idx.iloc[s[1]].index.min()} - {train_idx.iloc[s[1]].index.max()}')\n",
+    "#     print()\n",
+    "    \n",
+    "# cv = list(TimeSeriesSplit(n_splits=3, test_size=100).split(train_idx))\n",
+    "# for s in cv:\n",
+    "#     print(s[0])\n",
+    "#     print(s[0][0])\n",
+    "#     print(f'Train: {train_idx.iloc[s[0]].index.min()} - {train_idx.iloc[s[0]].index.max()}')\n",
+    "#     print(f'Test:  {train_idx.iloc[s[1]].index.min()} - {train_idx.iloc[s[1]].index.max()}')\n",
+    "#     print()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 101,
+   "id": "c807d974",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>date</th>\n",
+       "      <th>store_nbr</th>\n",
+       "      <th>item_nbr</th>\n",
+       "      <th>unit_sales</th>\n",
+       "      <th>onpromotion</th>\n",
+       "      <th>family</th>\n",
+       "      <th>class</th>\n",
+       "      <th>perishable</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>date</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>2013-01-01</th>\n",
+       "      <td>2013-01-01</td>\n",
+       "      <td>25</td>\n",
+       "      <td>638327</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>U</td>\n",
+       "      <td>GROCERY I</td>\n",
+       "      <td>1084</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2013-01-01</th>\n",
+       "      <td>2013-01-01</td>\n",
+       "      <td>25</td>\n",
+       "      <td>464385</td>\n",
+       "      <td>7.0</td>\n",
+       "      <td>U</td>\n",
+       "      <td>BREAD/BAKERY</td>\n",
+       "      <td>2718</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2013-01-01</th>\n",
+       "      <td>2013-01-01</td>\n",
+       "      <td>25</td>\n",
+       "      <td>360314</td>\n",
+       "      <td>5.0</td>\n",
+       "      <td>U</td>\n",
+       "      <td>BREAD/BAKERY</td>\n",
+       "      <td>2702</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2013-01-01</th>\n",
+       "      <td>2013-01-01</td>\n",
+       "      <td>25</td>\n",
+       "      <td>557256</td>\n",
+       "      <td>10.0</td>\n",
+       "      <td>U</td>\n",
+       "      <td>EGGS</td>\n",
+       "      <td>2502</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2013-01-01</th>\n",
+       "      <td>2013-01-01</td>\n",
+       "      <td>25</td>\n",
+       "      <td>358515</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>U</td>\n",
+       "      <td>GROCERY I</td>\n",
+       "      <td>1024</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                 date  store_nbr  item_nbr  unit_sales onpromotion  \\\n",
+       "date                                                                 \n",
+       "2013-01-01 2013-01-01         25    638327         2.0           U   \n",
+       "2013-01-01 2013-01-01         25    464385         7.0           U   \n",
+       "2013-01-01 2013-01-01         25    360314         5.0           U   \n",
+       "2013-01-01 2013-01-01         25    557256        10.0           U   \n",
+       "2013-01-01 2013-01-01         25    358515         2.0           U   \n",
+       "\n",
+       "                  family  class  perishable  \n",
+       "date                                         \n",
+       "2013-01-01     GROCERY I   1084           0  \n",
+       "2013-01-01  BREAD/BAKERY   2718           1  \n",
+       "2013-01-01  BREAD/BAKERY   2702           1  \n",
+       "2013-01-01          EGGS   2502           1  \n",
+       "2013-01-01     GROCERY I   1024           0  "
+      ]
+     },
+     "execution_count": 101,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "train = train_all.sample(int(10e6))\n",
+    "train = train.set_index('date', drop=False).sort_index()\n",
+    "train.loc[train['unit_sales'] < 0, 'unit_sales'] = 0\n",
+    "train.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 130,
+   "id": "890b23a1",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(10000000, 8)"
+      ]
+     },
+     "execution_count": 130,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# train = train_all.copy()\n",
+    "# train = train.set_index('date', drop=False).sort_index()\n",
+    "# train.loc[train['unit_sales'] < 0, 'unit_sales'] = 0\n",
+    "\n",
+    "train.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 134,
+   "id": "a6d28ce3",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "cross-val 53.315948724746704\n",
+      "[0.76249221 0.74114169 0.73643648]\n"
+     ]
+    }
+   ],
+   "source": [
+    "from sklearn.preprocessing import OrdinalEncoder, KBinsDiscretizer\n",
+    "from sklearn.pipeline import Pipeline, make_pipeline\n",
+    "from sklearn.compose import ColumnTransformer, make_column_transformer\n",
+    "import time\n",
+    "import cbm\n",
+    "from sklearn.metrics import mean_squared_error, make_scorer, mean_squared_log_error\n",
+    "from sklearn.model_selection import cross_val_score\n",
+    "from sklearn.base import BaseEstimator, TransformerMixin\n",
+    "import calendar\n",
+    "\n",
+    "class DateEncoder(BaseEstimator, TransformerMixin):\n",
+    "    def __init__(self, feature_name, component = 'month' ):\n",
+    "        self.feature_name = feature_name\n",
+    "        \n",
+    "        if component == 'day':\n",
+    "            self.categories = calendar.day_abbr\n",
+    "            self.column_to_ordinal = lambda col: col.dayofweek.values\n",
+    "        elif component == 'month':\n",
+    "            self.categories = calendar.month_abbr\n",
+    "            self.column_to_ordinal = lambda col: col.month.values\n",
+    "        else:\n",
+    "            raise ValueError('component must be either day or month')\n",
+    "        \n",
+    "        self.component = component\n",
+    "    \n",
+    "    def fit(self, X, y = None):\n",
+    "        return self\n",
+    "    \n",
+    "    def transform(self, X, y = None):\n",
+    "        return self.column_to_ordinal(X.iloc[:,0].dt)[:,np.newaxis]\n",
+    "\n",
+    "# Talk to Ilya about this use-case\n",
+    "cats = make_column_transformer(\n",
+    "    # TODO: pass pipeline to CBM model + inspect pipeline to correlate for plotting\n",
+    "    \n",
+    "    # https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.OrdinalEncoder.html\n",
+    "    (OrdinalEncoder(dtype='int', handle_unknown='use_encoded_value', unknown_value=-1), # +1 in CBM code\n",
+    "     ['store_nbr', 'item_nbr', 'onpromotion', 'family', 'class', 'perishable']),\n",
+    "       \n",
+    "    (DateEncoder('month', 'month'), ['date']),\n",
+    "    (DateEncoder('day', 'day'),     ['date'])\n",
+    "    # https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.KBinsDiscretizer.html\n",
+    "    # (KBinsDiscretizer(n_bins=10, encode='ordinal', dtype='int'),     [''])\n",
+    ")\n",
+    "\n",
+    "cbm = cbm.CBM(learning_rate_step_size=1/500, min_iterations_early_stopping=10)\n",
+    "\n",
+    "pipeline = make_pipeline(\n",
+    "        cats,\n",
+    "        cbm\n",
+    "    )\n",
+    "\n",
+    "# model.fit(x_train, train['unit_sales'])\n",
+    "# pipeline.fit(train.head(10), train['unit_sales'].head(10))\n",
+    "# pipeline.fit(train.head(100000), train['unit_sales'].head(100000))\n",
+    "\n",
+    "\n",
+    "# pipeline.fit(train, train['unit_sales'])\n",
+    "# \n",
+    "\n",
+    "# from sklearn.model_selection import cross_val_score\n",
+    "\n",
+    "start = time.time()\n",
+    "scores = cross_val_score(pipeline, train, train['unit_sales'], \n",
+    "                         scoring=make_scorer(mean_squared_log_error, squared=False), \n",
+    "                         cv=TemporalSplit(n_splits=3, test_size=90),\n",
+    "                         n_jobs=-1\n",
+    "                        )\n",
+    "\n",
+    "print(f'cross-val { time.time() - start}')\n",
+    "print(scores)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "id": "38c5c7be",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0"
+      ]
+     },
+     "execution_count": 31,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "(train['unit_sales'] < 0).sum()\n",
+    "\n",
+    "cross-val 53.586721658706665\n",
+    "[0.76333752 0.74206952 0.73735652]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "4d762437",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "pipeline.fit(train, train['unit_sales'])\n",
+    "1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "id": "82ab90f1",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Pipeline(steps=[('columntransformer',\n",
+       "                 ColumnTransformer(transformers=[('ordinalencoder',\n",
+       "                                                  OrdinalEncoder(dtype='int',\n",
+       "                                                                 handle_unknown='use_encoded_value',\n",
+       "                                                                 unknown_value=-1),\n",
+       "                                                  ['store_nbr', 'item_nbr',\n",
+       "                                                   'onpromotion', 'family',\n",
+       "                                                   'class', 'perishable']),\n",
+       "                                                 ('dateencoder-1',\n",
+       "                                                  DateEncoder(feature_name='month'),\n",
+       "                                                  ['date']),\n",
+       "                                                 ('dateencoder-2',\n",
+       "                                                  DateEncoder(component='day',\n",
+       "                                                              feature_name='day'),\n",
+       "                                                  ['date'])]))])"
+      ]
+     },
+     "execution_count": 42,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "train = train_all.copy()\n",
+    "train.loc[train['unit_sales'] < 0, 'unit_sales'] = 0\n",
+    "\n",
+    "pipeline_feat = make_pipeline(cats)\n",
+    "pipeline_feat.fit(train)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "id": "ccdf3418",
+   "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>item_nbr</th>\n",
+       "      <th>family</th>\n",
+       "      <th>class</th>\n",
+       "      <th>perishable</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>96995</td>\n",
+       "      <td>GROCERY I</td>\n",
+       "      <td>1093</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>99197</td>\n",
+       "      <td>GROCERY I</td>\n",
+       "      <td>1067</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>103501</td>\n",
+       "      <td>CLEANING</td>\n",
+       "      <td>3008</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>103520</td>\n",
+       "      <td>GROCERY I</td>\n",
+       "      <td>1028</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>103665</td>\n",
+       "      <td>BREAD/BAKERY</td>\n",
+       "      <td>2712</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4095</th>\n",
+       "      <td>2132318</td>\n",
+       "      <td>GROCERY I</td>\n",
+       "      <td>1002</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4096</th>\n",
+       "      <td>2132945</td>\n",
+       "      <td>GROCERY I</td>\n",
+       "      <td>1026</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4097</th>\n",
+       "      <td>2132957</td>\n",
+       "      <td>GROCERY I</td>\n",
+       "      <td>1068</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4098</th>\n",
+       "      <td>2134058</td>\n",
+       "      <td>BEVERAGES</td>\n",
+       "      <td>1124</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4099</th>\n",
+       "      <td>2134244</td>\n",
+       "      <td>LIQUOR,WINE,BEER</td>\n",
+       "      <td>1364</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>4100 rows × 4 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "      item_nbr            family  class  perishable\n",
+       "0        96995         GROCERY I   1093           0\n",
+       "1        99197         GROCERY I   1067           0\n",
+       "2       103501          CLEANING   3008           0\n",
+       "3       103520         GROCERY I   1028           0\n",
+       "4       103665      BREAD/BAKERY   2712           1\n",
+       "...        ...               ...    ...         ...\n",
+       "4095   2132318         GROCERY I   1002           0\n",
+       "4096   2132945         GROCERY I   1026           0\n",
+       "4097   2132957         GROCERY I   1068           0\n",
+       "4098   2134058         BEVERAGES   1124           0\n",
+       "4099   2134244  LIQUOR,WINE,BEER   1364           0\n",
+       "\n",
+       "[4100 rows x 4 columns]"
+      ]
+     },
+     "execution_count": 40,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "items"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 123,
+   "id": "f2856ba4",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(3370464, 8)\n",
+      "id                      int64\n",
+      "date           datetime64[ns]\n",
+      "store_nbr               int16\n",
+      "item_nbr                int64\n",
+      "onpromotion            object\n",
+      "family                 object\n",
+      "class                   int64\n",
+      "perishable              int64\n",
+      "dtype: object\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>id</th>\n",
+       "      <th>date</th>\n",
+       "      <th>store_nbr</th>\n",
+       "      <th>item_nbr</th>\n",
+       "      <th>onpromotion</th>\n",
+       "      <th>family</th>\n",
+       "      <th>class</th>\n",
+       "      <th>perishable</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>125497040</td>\n",
+       "      <td>2017-08-16</td>\n",
+       "      <td>1</td>\n",
+       "      <td>96995</td>\n",
+       "      <td>F</td>\n",
+       "      <td>GROCERY I</td>\n",
+       "      <td>1093</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>125497041</td>\n",
+       "      <td>2017-08-16</td>\n",
+       "      <td>1</td>\n",
+       "      <td>99197</td>\n",
+       "      <td>F</td>\n",
+       "      <td>GROCERY I</td>\n",
+       "      <td>1067</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>125497042</td>\n",
+       "      <td>2017-08-16</td>\n",
+       "      <td>1</td>\n",
+       "      <td>103501</td>\n",
+       "      <td>F</td>\n",
+       "      <td>CLEANING</td>\n",
+       "      <td>3008</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>125497043</td>\n",
+       "      <td>2017-08-16</td>\n",
+       "      <td>1</td>\n",
+       "      <td>103520</td>\n",
+       "      <td>F</td>\n",
+       "      <td>GROCERY I</td>\n",
+       "      <td>1028</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>125497044</td>\n",
+       "      <td>2017-08-16</td>\n",
+       "      <td>1</td>\n",
+       "      <td>103665</td>\n",
+       "      <td>F</td>\n",
+       "      <td>BREAD/BAKERY</td>\n",
+       "      <td>2712</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "          id       date  store_nbr  item_nbr onpromotion        family  class  \\\n",
+       "0  125497040 2017-08-16          1     96995           F     GROCERY I   1093   \n",
+       "1  125497041 2017-08-16          1     99197           F     GROCERY I   1067   \n",
+       "2  125497042 2017-08-16          1    103501           F      CLEANING   3008   \n",
+       "3  125497043 2017-08-16          1    103520           F     GROCERY I   1028   \n",
+       "4  125497044 2017-08-16          1    103665           F  BREAD/BAKERY   2712   \n",
+       "\n",
+       "   perishable  \n",
+       "0           0  \n",
+       "1           0  \n",
+       "2           0  \n",
+       "3           0  \n",
+       "4           1  "
+      ]
+     },
+     "execution_count": 123,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "items = pd.read_csv('data/items.csv')\n",
+    "\n",
+    "test = (pd.read_csv('data/test.csv', \n",
+    "                    parse_dates=['date'], \n",
+    "                    # index_col='id', \n",
+    "                    dtype={\n",
+    "                        'id':        np.int64,\n",
+    "                        'store_nbr': np.short,\n",
+    "                        'item_nbr': np.int64,\n",
+    "                        'unit_sales': np.float64\n",
+    "                    },\n",
+    "                    converters={'onpromotion': lambda x: 'T' if x == 'True' else ('F' if x == 'False' else 'U')}\n",
+    "                   )\n",
+    "    .merge(items, how='left'))\n",
+    "\n",
+    "# test['class']    = test['class'].astype('str')\n",
+    "# test['item_nbr'] = test['item_nbr'].astype('str')\n",
+    "\n",
+    "print(test.shape)\n",
+    "print(test.dtypes)\n",
+    "test.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "id": "33bfade4",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0"
+      ]
+     },
+     "execution_count": 45,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# pipeline_feat.transform(test)\n",
+    "test.isna().sum(axis=1).sum()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 124,
+   "id": "5019d5e0",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[ 0],\n",
+       "       [ 1],\n",
+       "       [ 2],\n",
+       "       ...,\n",
+       "       [-1],\n",
+       "       [-1],\n",
+       "       [-1]])"
+      ]
+     },
+     "execution_count": 124,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "pipeline_feat = make_pipeline(cats)\n",
+    "features = pipeline_feat.transform(test)\n",
+    "features"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 135,
+   "id": "d473f84e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Pipeline(steps=[('columntransformer',\n",
+       "                 ColumnTransformer(transformers=[('ordinalencoder',\n",
+       "                                                  OrdinalEncoder(dtype='int',\n",
+       "                                                                 handle_unknown='use_encoded_value',\n",
+       "                                                                 unknown_value=-1),\n",
+       "                                                  ['store_nbr', 'item_nbr',\n",
+       "                                                   'onpromotion', 'family',\n",
+       "                                                   'class', 'perishable']),\n",
+       "                                                 ('dateencoder-1',\n",
+       "                                                  DateEncoder(feature_name='month'),\n",
+       "                                                  ['date']),\n",
+       "                                                 ('dateencoder-2',\n",
+       "                                                  DateEncoder(component='day',\n",
+       "                                                              feature_name='day'),\n",
+       "                                                  ['date'])])),\n",
+       "                ('cbm',\n",
+       "                 CBM(learning_rate_step_size=0.002,\n",
+       "                     min_iterations_early_stopping=10))])"
+      ]
+     },
+     "execution_count": 135,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# training\n",
+    "\n",
+    "train_all_all = train_all.copy()\n",
+    "train_all_all.loc[train_all_all['unit_sales'] < 0, 'unit_sales'] = 0\n",
+    "\n",
+    "pipeline_all = make_pipeline(cats, cbm)\n",
+    "pipeline_all.fit(train_all_all, train_all_all['unit_sales'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 136,
+   "id": "2fb0eda4",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "count    3.370464e+06\n",
+       "mean     7.313644e+00\n",
+       "std      1.613676e+01\n",
+       "min      3.352459e-01\n",
+       "25%      2.642382e+00\n",
+       "50%      4.420249e+00\n",
+       "75%      7.781694e+00\n",
+       "max      2.224308e+03\n",
+       "dtype: float64"
+      ]
+     },
+     "execution_count": 136,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "y_pred_test = pipeline_all.predict(test)\n",
+    "\n",
+    "pd.Series(y_pred_test.flatten()).describe()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 137,
+   "id": "234be585",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "7.535582    21\n",
+       "7.772725    21\n",
+       "5.474212    21\n",
+       "5.866997    21\n",
+       "7.266502    21\n",
+       "            ..\n",
+       "2.044499     1\n",
+       "9.149783     1\n",
+       "6.819987     1\n",
+       "2.328584     1\n",
+       "8.180235     1\n",
+       "Length: 1539115, dtype: int64"
+      ]
+     },
+     "execution_count": 137,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "pd.Series(y_pred_test.flatten()).value_counts()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 138,
+   "id": "6c151939",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "submission = test.copy()\n",
+    "submission.loc[:, 'unit_sales'] = y_pred_test.flatten()\n",
+    "submission[['id', 'unit_sales']].to_csv('submission.csv', index=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 128,
+   "id": "abba959f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "id,unit_sales\r\n",
+      "125497040,2.5024013377093564\r\n",
+      "125497041,4.222599293880319\r\n",
+      "125497042,4.873269254461008\r\n",
+      "125497043,4.187582054240339\r\n",
+      "125497044,4.932258731082357\r\n",
+      "125497045,13.245315426347876\r\n",
+      "125497046,21.230761691507237\r\n",
+      "125497047,14.97772186798399\r\n",
+      "125497048,6.772408878599083\r\n"
+     ]
+    }
+   ],
+   "source": [
+    "!head submission.csv"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 139,
+   "id": "90c762f1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████████████████████████████████| 91.2M/91.2M [00:17<00:00, 5.61MB/s]\n",
+      "Successfully submitted to Corporación Favorita Grocery Sales Forecasting"
+     ]
+    }
+   ],
+   "source": [
+    "!kaggle competitions submit -c favorita-grocery-sales-forecasting -f submission.csv -m sklearn1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "523c44df",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3a0ddf3d",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "id": "5b8d18ac",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[9.46390226],\n",
+       "       [9.46412469],\n",
+       "       [9.48171461],\n",
+       "       [9.48268984],\n",
+       "       [9.46475154]])"
+      ]
+     },
+     "execution_count": 32,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "pipeline.predict(train.head())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "c6c389af",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(125497040, 8)"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "train.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 54,
+   "id": "61fca780",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "172197"
+      ]
+     },
+     "execution_count": 54,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from collections import defaultdict\n",
+    "\n",
+    "item_store_map = defaultdict(int)\n",
+    "\n",
+    "# have the first item as back-off\n",
+    "item_store_map.update({(row['item_nbr'], row['store_nbr']): idx + 1 for idx, row in train[['item_nbr','store_nbr']].value_counts(ascending=True).reset_index(name='count').query('count > 5').iterrows()})\n",
+    "\n",
+    "len(item_store_map)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "id": "3fe9b08f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train['item_store'] = train[['item_nbr','store_nbr']].apply(lambda x: item_store_map[tuple(x)], axis=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "c7a3237f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>date</th>\n",
+       "      <th>store_nbr</th>\n",
+       "      <th>item_nbr</th>\n",
+       "      <th>unit_sales</th>\n",
+       "      <th>onpromotion</th>\n",
+       "      <th>family</th>\n",
+       "      <th>class</th>\n",
+       "      <th>perishable</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>2013-01-01</td>\n",
+       "      <td>25</td>\n",
+       "      <td>4</td>\n",
+       "      <td>7.0</td>\n",
+       "      <td>U</td>\n",
+       "      <td>BREAD/BAKERY</td>\n",
+       "      <td>184</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>2013-01-02</td>\n",
+       "      <td>1</td>\n",
+       "      <td>4</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>U</td>\n",
+       "      <td>BREAD/BAKERY</td>\n",
+       "      <td>184</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>2013-01-02</td>\n",
+       "      <td>2</td>\n",
+       "      <td>4</td>\n",
+       "      <td>5.0</td>\n",
+       "      <td>U</td>\n",
+       "      <td>BREAD/BAKERY</td>\n",
+       "      <td>184</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>2013-01-02</td>\n",
+       "      <td>3</td>\n",
+       "      <td>4</td>\n",
+       "      <td>6.0</td>\n",
+       "      <td>U</td>\n",
+       "      <td>BREAD/BAKERY</td>\n",
+       "      <td>184</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>2013-01-02</td>\n",
+       "      <td>4</td>\n",
+       "      <td>4</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>U</td>\n",
+       "      <td>BREAD/BAKERY</td>\n",
+       "      <td>184</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "        date  store_nbr  item_nbr  unit_sales onpromotion        family  \\\n",
+       "0 2013-01-01         25         4         7.0           U  BREAD/BAKERY   \n",
+       "1 2013-01-02          1         4         2.0           U  BREAD/BAKERY   \n",
+       "2 2013-01-02          2         4         5.0           U  BREAD/BAKERY   \n",
+       "3 2013-01-02          3         4         6.0           U  BREAD/BAKERY   \n",
+       "4 2013-01-02          4         4         2.0           U  BREAD/BAKERY   \n",
+       "\n",
+       "   class  perishable  \n",
+       "0    184           1  \n",
+       "1    184           1  \n",
+       "2    184           1  \n",
+       "3    184           1  \n",
+       "4    184           1  "
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "train = pd.read_parquet('data/train_items.parquet')\n",
+    "\n",
+    "class_map = {x: i for i, x in enumerate(np.sort(train['class'].unique()))}\n",
+    "item_nbr_map = {x: i for i, x in enumerate(np.sort(train['item_nbr'].unique()))}\n",
+    "\n",
+    "train['class']    = train['class'].map(class_map)\n",
+    "train['item_nbr'] = train['item_nbr'].map(item_nbr_map)\n",
+    "\n",
+    "train.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "8b7b478c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "# # train['unit_sales'] = train['unit_sales'].astype(np.int32)\n",
+    "# train[['unit_sales']].to_parquet('data/train_unit_sales.parquet')\n",
+    "\n",
+    "# x_train = pd.read_parquet('data/train_items_featurized.parquet')\n",
+    "# x_train_unit_sales = pd.read_parquet('data/train_unit_sales.parquet')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7c852782",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "785a97c4",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "5e7fc02a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "8191095"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "(((train['unit_sales'] * 10) % 10  ) > 0).sum()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a8534d07",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "e8f9d08e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.06526922866069192"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "8191095 / len(train)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "adfe5485",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "featurize 1.988840103149414\n",
+      "train      59.32568883895874\n",
+      "iterations 3\n",
+      "23.605482539271893\n"
+     ]
+    }
+   ],
+   "source": [
+    "import cbm\n",
+    "import time\n",
+    "from sklearn.model_selection import TimeSeriesSplit\n",
+    "from sklearn.metrics import mean_squared_error\n",
+    "\n",
+    "def featurize(df):\n",
+    "   return pd.DataFrame({\n",
+    "       'store_nbr'    : df['store_nbr'],\n",
+    "       'item_nbr'     : df['item_nbr'],\n",
+    "       'onpromotion'  : df['onpromotion'],\n",
+    "       'family'       : df['family'],\n",
+    "       'class'        : df['class'],\n",
+    "       'perishable'   : df['perishable'],\n",
+    "       'date'         : df['date'],\n",
+    "    })\n",
+    "\n",
+    "start = time.time()\n",
+    "\n",
+    "x_train = featurize(train)\n",
+    "\n",
+    "print(f'featurize { time.time() - start}')\n",
+    "\n",
+    "# enable_bin_count=True) # \n",
+    "model = cbm.CBM(learning_rate_step_size=1/64000, min_iterations_early_stopping=2)\n",
+    "model.fit(x_train, train['unit_sales'])\n",
+    "\n",
+    "print(f'train      {time.time() - start}')\n",
+    "print(f'iterations {model.iterations}')\n",
+    "\n",
+    "y_pred_train = model.predict(x_train).flatten()\n",
+    "\n",
+    "rmsle = mean_squared_error(train['unit_sales'], y_pred_train, squared=False)\n",
+    "print(rmsle)\n",
+    "\n",
+    "# 29sec - for store/item\n",
+    "# 76sec - for store/onprom/family/class/perishable - 612k\n",
+    "# 589k w/  1/2000 learning rate\n",
+    "# 612k w/   1/200\n",
+    "# 132  w/  1/4000\n",
+    "# 37   w/  1/8000\n",
+    "# 25   w/ 1/16000 \n",
+    "# 23   w  1/32000 it>=15\n",
+    "# 23   w  1/32000 it>=5\n",
+    "# 23   w  1/64000 it>=2\n",
+    "# 23.60 w 1/64000 it>=2 + item_nbr\n",
+    "# 23.60 w 1/64000 it>=2 + item_nbr + date"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "b672d0c7",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "333"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "x_train['class'].max()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "33d38059",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "4035"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "x_train['item_nbr'].max()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "09310633",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# model.plot_importance(figsize=(20, 20))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "id": "052d4c10",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/marcozo/miniconda3/envs/cbm/lib/python3.7/site-packages/numpy/lib/arraysetops.py:583: FutureWarning: elementwise comparison failed; returning scalar instead, but in the future will perform elementwise comparison\n",
+      "  mask |= (ar1 == a)\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>date</th>\n",
+       "      <th>store_nbr</th>\n",
+       "      <th>item_nbr</th>\n",
+       "      <th>onpromotion</th>\n",
+       "      <th>family</th>\n",
+       "      <th>class</th>\n",
+       "      <th>perishable</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>2017-08-16</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>F</td>\n",
+       "      <td>GROCERY I</td>\n",
+       "      <td>63.0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>2017-08-16</td>\n",
+       "      <td>2</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>F</td>\n",
+       "      <td>GROCERY I</td>\n",
+       "      <td>63.0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>2017-08-16</td>\n",
+       "      <td>3</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>F</td>\n",
+       "      <td>GROCERY I</td>\n",
+       "      <td>63.0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>2017-08-16</td>\n",
+       "      <td>4</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>F</td>\n",
+       "      <td>GROCERY I</td>\n",
+       "      <td>63.0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>2017-08-16</td>\n",
+       "      <td>5</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>F</td>\n",
+       "      <td>GROCERY I</td>\n",
+       "      <td>63.0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "        date  store_nbr  item_nbr onpromotion     family  class  perishable\n",
+       "0 2017-08-16          1       0.0           F  GROCERY I   63.0           0\n",
+       "1 2017-08-16          2       0.0           F  GROCERY I   63.0           0\n",
+       "2 2017-08-16          3       0.0           F  GROCERY I   63.0           0\n",
+       "3 2017-08-16          4       0.0           F  GROCERY I   63.0           0\n",
+       "4 2017-08-16          5       0.0           F  GROCERY I   63.0           0"
+      ]
+     },
+     "execution_count": 45,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "items = pd.read_csv('data/items.csv')\n",
+    "\n",
+    "test = pd.read_csv('data/test.csv',\n",
+    "            parse_dates=['date'], \n",
+    "            index_col='id', \n",
+    "            dtype={\n",
+    "                # 'date': np.datetime64, \n",
+    "                'store_nbr': np.short,\n",
+    "                'item_nbr': np.int64,\n",
+    "                'unit_sales': np.float64\n",
+    "            },\n",
+    ").merge(items)\n",
+    "\n",
+    "test['onpromotion'] = test['onpromotion'].map({True: 'T', False: 'F'})\n",
+    "test['class']       = test['class'].map(class_map)\n",
+    "test['item_nbr']    = test['item_nbr'].map(item_nbr_map)\n",
+    "\n",
+    "test.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "id": "c4a482dc",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>date</th>\n",
+       "      <th>store_nbr</th>\n",
+       "      <th>item_nbr</th>\n",
+       "      <th>onpromotion</th>\n",
+       "      <th>family</th>\n",
+       "      <th>class</th>\n",
+       "      <th>perishable</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "Empty DataFrame\n",
+       "Columns: [date, store_nbr, item_nbr, onpromotion, family, class, perishable]\n",
+       "Index: []"
+      ]
+     },
+     "execution_count": 53,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# TODO: handle NA by multiplying by 1\n",
+    "test['item_nbr'] = test['item_nbr'].fillna(0).astype(int)\n",
+    "test['class']    = test['class']   .fillna(0).astype(int)\n",
+    "test[test.isna().any(axis=1)]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "78377989",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# class_cats = train_raw['class'].astype('category').cat.categories.tolist()\n",
+    "\n",
+    "# test['class'] = test['class'].astype(pd.CategoricalDtype(categories=class_cats, ordered=True)).cat.codes\n",
+    "# test.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 54,
+   "id": "288bb676",
+   "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_nbr</th>\n",
+       "      <th>item_nbr</th>\n",
+       "      <th>onpromotion</th>\n",
+       "      <th>family</th>\n",
+       "      <th>class</th>\n",
+       "      <th>perishable</th>\n",
+       "      <th>date</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>F</td>\n",
+       "      <td>GROCERY I</td>\n",
+       "      <td>63</td>\n",
+       "      <td>0</td>\n",
+       "      <td>2017-08-16</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>2</td>\n",
+       "      <td>0</td>\n",
+       "      <td>F</td>\n",
+       "      <td>GROCERY I</td>\n",
+       "      <td>63</td>\n",
+       "      <td>0</td>\n",
+       "      <td>2017-08-16</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>3</td>\n",
+       "      <td>0</td>\n",
+       "      <td>F</td>\n",
+       "      <td>GROCERY I</td>\n",
+       "      <td>63</td>\n",
+       "      <td>0</td>\n",
+       "      <td>2017-08-16</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>4</td>\n",
+       "      <td>0</td>\n",
+       "      <td>F</td>\n",
+       "      <td>GROCERY I</td>\n",
+       "      <td>63</td>\n",
+       "      <td>0</td>\n",
+       "      <td>2017-08-16</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>5</td>\n",
+       "      <td>0</td>\n",
+       "      <td>F</td>\n",
+       "      <td>GROCERY I</td>\n",
+       "      <td>63</td>\n",
+       "      <td>0</td>\n",
+       "      <td>2017-08-16</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   store_nbr  item_nbr onpromotion     family  class  perishable       date\n",
+       "0          1         0           F  GROCERY I     63           0 2017-08-16\n",
+       "1          2         0           F  GROCERY I     63           0 2017-08-16\n",
+       "2          3         0           F  GROCERY I     63           0 2017-08-16\n",
+       "3          4         0           F  GROCERY I     63           0 2017-08-16\n",
+       "4          5         0           F  GROCERY I     63           0 2017-08-16"
+      ]
+     },
+     "execution_count": 54,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "x_test = featurize(test)\n",
+    "x_test.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "id": "e2f2f2e7",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[8.67074847, 1.00170424, 1.00180464, ..., 1.00164436, 1.00164009,\n",
+       "        1.00161252],\n",
+       "       [8.67054548, 1.00168079, 1.00180464, ..., 1.00164436, 1.00164009,\n",
+       "        1.00161252],\n",
+       "       [8.67063081, 1.00169065, 1.00180464, ..., 1.00164436, 1.00164009,\n",
+       "        1.00161252],\n",
+       "       ...,\n",
+       "       [8.67042574, 1.00148041, 1.00180464, ..., 1.00164436, 1.0016697 ,\n",
+       "        1.00161252],\n",
+       "       [8.67126881, 1.00157779, 1.00180464, ..., 1.00164436, 1.0016697 ,\n",
+       "        1.00161252],\n",
+       "       [8.67073749, 1.00151642, 1.00180464, ..., 1.00164436, 1.0016697 ,\n",
+       "        1.00161252]])"
+      ]
+     },
+     "execution_count": 55,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "y_pred_test = model.predict(x_test, explain=True) #.flatten()\n",
+    "y_pred_test"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 57,
+   "id": "6483a859",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "8.666806    21\n",
+       "8.666954    21\n",
+       "8.666864    21\n",
+       "8.667392    21\n",
+       "8.666751    21\n",
+       "            ..\n",
+       "8.656977     1\n",
+       "8.659257     1\n",
+       "8.656693     1\n",
+       "8.656806     1\n",
+       "8.641494     1\n",
+       "Length: 1538737, dtype: int64"
+      ]
+     },
+     "execution_count": 57,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "pd.Series(y_pred_test[:,0].flatten()).value_counts()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 58,
+   "id": "2798c44f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "y_pred_test = model.predict(x_test)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 64,
+   "id": "d3d53829",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "test[['unit_sales']].index.rename('id', inplace=True)\n",
+    "test['unit_sales'] = y_pred_test\n",
+    "test[['unit_sales']].to_csv('submission.csv', index=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 65,
+   "id": "5ae1ac1b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "test['unit_sales'] = y_pred_test\n",
+    "test[['unit_sales']].to_csv('submission.csv', index=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 66,
+   "id": "1f3c2e53",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "id,unit_sales\r\n",
+      "0,8.670748466911578\r\n",
+      "1,8.670545482030695\r\n",
+      "2,8.670630814956288\r\n",
+      "3,8.67052676822758\r\n",
+      "4,8.66955171527891\r\n",
+      "5,8.670202952780572\r\n",
+      "6,8.670841233962294\r\n",
+      "7,8.670437318412505\r\n",
+      "8,8.669850978368242\r\n"
+     ]
+    }
+   ],
+   "source": [
+    "!head submission.csv"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "db2247b6",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "8.665899    28\n",
+       "8.649263    26\n",
+       "8.649260    26\n",
+       "8.649381    24\n",
+       "8.649342    22\n",
+       "            ..\n",
+       "8.652211     1\n",
+       "8.659009     1\n",
+       "8.664719     1\n",
+       "8.652154     1\n",
+       "8.634132     1\n",
+       "Length: 20537444, dtype: int64"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "pd.Series(y_pred_train).value_counts()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 67,
+   "id": "6c9e45a5",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████████████████████████████████| 81.9M/81.9M [00:21<00:00, 3.94MB/s]\n",
+      "Successfully submitted to Corporación Favorita Grocery Sales Forecasting"
+     ]
+    }
+   ],
+   "source": [
+    "!kaggle competitions submit -c favorita-grocery-sales-forecasting -f submission.csv -m v1"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/kaggle/store-sales-time-series-forecasting/kaggle.ipynb b/kaggle/store-sales-time-series-forecasting/kaggle.ipynb
new file mode 100644
index 0000000..fc9a379
--- /dev/null
+++ b/kaggle/store-sales-time-series-forecasting/kaggle.ipynb
@@ -0,0 +1,4475 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 59,
+   "id": "2a36103a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "The autoreload extension is already loaded. To reload it, use:\n",
+      "  %reload_ext autoreload\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<style>.container { width:100% !important; }</style>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<style>.output_result { max-width:100% !important; }</style>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<style>.prompt { display:none !important; }</style>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%load_ext autoreload\n",
+    "%autoreload 2\n",
+    "\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "from IPython.core.display import display, HTML\n",
+    "display(HTML(\"<style>.container { width:100% !important; }</style>\"))\n",
+    "display(HTML(\"<style>.output_result { max-width:100% !important; }</style>\"))\n",
+    "display(HTML(\"<style>.prompt { display:none !important; }</style>\"))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 239,
+   "id": "40221e37",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# data prep from https://www.kaggle.com/adityasharma01/ts-ridge-rf-by-as\n",
+    "path = 'data/'\n",
+    "calendar = pd.DataFrame(index=pd.date_range('2013-01-01', '2017-08-31'))\n",
+    "\n",
+    "# Oil moving average\n",
+    "\n",
+    "data_oil = pd.read_csv(path + 'oil.csv', parse_dates=['date'], infer_datetime_format=True, index_col='date')\n",
+    "data_oil['ma_oil'] = data_oil['dcoilwtico'].rolling(7).mean()\n",
+    "\n",
+    "calendar = calendar.merge(data_oil, how='left', left_index=True, right_index=True)\n",
+    "calendar['ma_oil'].fillna(method='ffill', inplace=True)\n",
+    "\n",
+    "# Day of week\n",
+    "\n",
+    "calendar['dofw'] = calendar.index.dayofweek\n",
+    "\n",
+    "# Events\n",
+    "\n",
+    "df_hev = pd.read_csv(path + 'holidays_events.csv', parse_dates=['date'], infer_datetime_format=True)\n",
+    "df_hev['date'] = df_hev['date'].replace({'2013-04-29' : \n",
+    "                                         pd.to_datetime('2013-03-29')}) # 'Good Friday' mistake correction\n",
+    "\n",
+    "df_hev = df_hev.set_index('date').sort_index()\n",
+    "df_hev = df_hev[df_hev.locale == 'National'] # National level only for simplicity\n",
+    "df_hev = df_hev.groupby(df_hev.index).first() # Keep one event only\n",
+    "\n",
+    "# Work days\n",
+    "\n",
+    "calendar['wd'] = True\n",
+    "calendar.loc[calendar.dofw > 4, 'wd'] = False\n",
+    "\n",
+    "calendar = calendar.merge(df_hev, how='left', left_index=True, right_index=True)\n",
+    "\n",
+    "calendar.loc[calendar.type == 'Bridge'  , 'wd'] = False\n",
+    "calendar.loc[calendar.type == 'Work Day', 'wd'] = True\n",
+    "calendar.loc[calendar.type == 'Transfer', 'wd'] = False\n",
+    "calendar.loc[(calendar.type == 'Holiday') & (calendar.transferred == False), 'wd'] = False\n",
+    "calendar.loc[(calendar.type == 'Holiday') & (calendar.transferred == True ), 'wd'] = True\n",
+    "                                         \n",
+    "df_train = pd.read_csv(path + 'train.csv',\n",
+    "                       usecols=['store_nbr', 'family', 'date', 'sales', 'onpromotion'],\n",
+    "                       # dtype={'store_nbr': 'category', 'family': 'category', 'sales': 'float32'},\n",
+    "                       dtype={'sales': 'float32'},\n",
+    "                       parse_dates=['date'], infer_datetime_format=True)\n",
+    "\n",
+    "df_train = df_train.merge(calendar.reset_index().rename({'index': 'date'}, axis=1), on='date')\n",
+    "# df_train.date = df_train.date.dt.to_period('D')\n",
+    "# df_train = df_train.set_index(['store_nbr', 'family', 'date']).sort_index()\n",
+    "                                         \n",
+    "df_test = pd.read_csv(path + 'test.csv',\n",
+    "                      usecols=['store_nbr', 'family', 'date', 'id', 'onpromotion'],\n",
+    "                      # dtype={'store_nbr': 'category', 'family': 'category'},\n",
+    "                      parse_dates=['date'], infer_datetime_format=True)\n",
+    "\n",
+    "df_test = df_test.merge(calendar.reset_index().rename({'index': 'date'}, axis=1), on='date')\n",
+    "# df_test.date = df_test.date.dt.to_period('D')\n",
+    "# df_test = df_test.set_index(['store_nbr', 'family', 'date']).sort_index()\n",
+    "                                         \n",
+    "sdate = '2017-04-01'\n",
+    "edate = '2017-08-15'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "eb5b0ccf",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "holidays_events.csv  sample_submission.csv  test.csv   transactions.csv\r\n",
+      "oil.csv\t\t     stores.csv\t\t    train.csv\r\n"
+     ]
+    }
+   ],
+   "source": [
+    "!ls data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 195,
+   "id": "9d240f2c",
+   "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>id</th>\n",
+       "      <th>date</th>\n",
+       "      <th>store_nbr</th>\n",
+       "      <th>family</th>\n",
+       "      <th>sales</th>\n",
+       "      <th>onpromotion</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>0</td>\n",
+       "      <td>2013-01-01</td>\n",
+       "      <td>1</td>\n",
+       "      <td>AUTOMOTIVE</td>\n",
+       "      <td>0.000</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>1</td>\n",
+       "      <td>2013-01-01</td>\n",
+       "      <td>1</td>\n",
+       "      <td>BABY CARE</td>\n",
+       "      <td>0.000</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>2</td>\n",
+       "      <td>2013-01-01</td>\n",
+       "      <td>1</td>\n",
+       "      <td>BEAUTY</td>\n",
+       "      <td>0.000</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>3</td>\n",
+       "      <td>2013-01-01</td>\n",
+       "      <td>1</td>\n",
+       "      <td>BEVERAGES</td>\n",
+       "      <td>0.000</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>4</td>\n",
+       "      <td>2013-01-01</td>\n",
+       "      <td>1</td>\n",
+       "      <td>BOOKS</td>\n",
+       "      <td>0.000</td>\n",
+       "      <td>0</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",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3000883</th>\n",
+       "      <td>3000883</td>\n",
+       "      <td>2017-08-15</td>\n",
+       "      <td>9</td>\n",
+       "      <td>POULTRY</td>\n",
+       "      <td>438.133</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3000884</th>\n",
+       "      <td>3000884</td>\n",
+       "      <td>2017-08-15</td>\n",
+       "      <td>9</td>\n",
+       "      <td>PREPARED FOODS</td>\n",
+       "      <td>154.553</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3000885</th>\n",
+       "      <td>3000885</td>\n",
+       "      <td>2017-08-15</td>\n",
+       "      <td>9</td>\n",
+       "      <td>PRODUCE</td>\n",
+       "      <td>2419.729</td>\n",
+       "      <td>148</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3000886</th>\n",
+       "      <td>3000886</td>\n",
+       "      <td>2017-08-15</td>\n",
+       "      <td>9</td>\n",
+       "      <td>SCHOOL AND OFFICE SUPPLIES</td>\n",
+       "      <td>121.000</td>\n",
+       "      <td>8</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3000887</th>\n",
+       "      <td>3000887</td>\n",
+       "      <td>2017-08-15</td>\n",
+       "      <td>9</td>\n",
+       "      <td>SEAFOOD</td>\n",
+       "      <td>16.000</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>3000888 rows × 6 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "              id        date  store_nbr                      family     sales  \\\n",
+       "0              0  2013-01-01          1                  AUTOMOTIVE     0.000   \n",
+       "1              1  2013-01-01          1                   BABY CARE     0.000   \n",
+       "2              2  2013-01-01          1                      BEAUTY     0.000   \n",
+       "3              3  2013-01-01          1                   BEVERAGES     0.000   \n",
+       "4              4  2013-01-01          1                       BOOKS     0.000   \n",
+       "...          ...         ...        ...                         ...       ...   \n",
+       "3000883  3000883  2017-08-15          9                     POULTRY   438.133   \n",
+       "3000884  3000884  2017-08-15          9              PREPARED FOODS   154.553   \n",
+       "3000885  3000885  2017-08-15          9                     PRODUCE  2419.729   \n",
+       "3000886  3000886  2017-08-15          9  SCHOOL AND OFFICE SUPPLIES   121.000   \n",
+       "3000887  3000887  2017-08-15          9                     SEAFOOD    16.000   \n",
+       "\n",
+       "         onpromotion  \n",
+       "0                  0  \n",
+       "1                  0  \n",
+       "2                  0  \n",
+       "3                  0  \n",
+       "4                  0  \n",
+       "...              ...  \n",
+       "3000883            0  \n",
+       "3000884            1  \n",
+       "3000885          148  \n",
+       "3000886            8  \n",
+       "3000887            0  \n",
+       "\n",
+       "[3000888 rows x 6 columns]"
+      ]
+     },
+     "execution_count": 195,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "pd.read_csv('data/train.csv')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "57fcfd94",
+   "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_nbr</th>\n",
+       "      <th>city</th>\n",
+       "      <th>state</th>\n",
+       "      <th>type</th>\n",
+       "      <th>cluster</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>1</td>\n",
+       "      <td>Quito</td>\n",
+       "      <td>Pichincha</td>\n",
+       "      <td>D</td>\n",
+       "      <td>13</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>2</td>\n",
+       "      <td>Quito</td>\n",
+       "      <td>Pichincha</td>\n",
+       "      <td>D</td>\n",
+       "      <td>13</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>3</td>\n",
+       "      <td>Quito</td>\n",
+       "      <td>Pichincha</td>\n",
+       "      <td>D</td>\n",
+       "      <td>8</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>4</td>\n",
+       "      <td>Quito</td>\n",
+       "      <td>Pichincha</td>\n",
+       "      <td>D</td>\n",
+       "      <td>9</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>5</td>\n",
+       "      <td>Santo Domingo</td>\n",
+       "      <td>Santo Domingo de los Tsachilas</td>\n",
+       "      <td>D</td>\n",
+       "      <td>4</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   store_nbr           city                           state type  cluster\n",
+       "0          1          Quito                       Pichincha    D       13\n",
+       "1          2          Quito                       Pichincha    D       13\n",
+       "2          3          Quito                       Pichincha    D        8\n",
+       "3          4          Quito                       Pichincha    D        9\n",
+       "4          5  Santo Domingo  Santo Domingo de los Tsachilas    D        4"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df_store = pd.read_csv('data/stores.csv')\n",
+    "df_store.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "d4abd961",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "store_nbr: 54\n",
+      "family:    33\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(f'store_nbr: {df_train[\"store_nbr\"].nunique()}')\n",
+    "print(f'family:    {df_train[\"family\"].nunique()}')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "60050c34",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_train['sales'].describe()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "55a715b3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "calendar"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5370c691",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# ma_oil_bins"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "64d95a18",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "_, ma_oil_bins = pd.qcut(df_train['ma_oil'].fillna(0), 10, retbins=True)\n",
+    "\n",
+    "pd.cut(df_train['ma_oil'].fillna(0), ma_oil_bins, include_lowest=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 204,
+   "id": "74544ec7",
+   "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 tr th {\n",
+       "        text-align: left;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead tr:last-of-type th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr>\n",
+       "      <th></th>\n",
+       "      <th colspan=\"10\" halign=\"left\">sales</th>\n",
+       "      <th>...</th>\n",
+       "      <th colspan=\"10\" halign=\"left\">onpromotion</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>store_nbr</th>\n",
+       "      <th colspan=\"10\" halign=\"left\">1</th>\n",
+       "      <th>...</th>\n",
+       "      <th colspan=\"10\" halign=\"left\">9</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>family</th>\n",
+       "      <th>AUTOMOTIVE</th>\n",
+       "      <th>BABY CARE</th>\n",
+       "      <th>BEAUTY</th>\n",
+       "      <th>BEVERAGES</th>\n",
+       "      <th>BOOKS</th>\n",
+       "      <th>BREAD/BAKERY</th>\n",
+       "      <th>CELEBRATION</th>\n",
+       "      <th>CLEANING</th>\n",
+       "      <th>DAIRY</th>\n",
+       "      <th>DELI</th>\n",
+       "      <th>...</th>\n",
+       "      <th>MAGAZINES</th>\n",
+       "      <th>MEATS</th>\n",
+       "      <th>PERSONAL CARE</th>\n",
+       "      <th>PET SUPPLIES</th>\n",
+       "      <th>PLAYERS AND ELECTRONICS</th>\n",
+       "      <th>POULTRY</th>\n",
+       "      <th>PREPARED FOODS</th>\n",
+       "      <th>PRODUCE</th>\n",
+       "      <th>SCHOOL AND OFFICE SUPPLIES</th>\n",
+       "      <th>SEAFOOD</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>date</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>2013-01-01</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2013-01-02</th>\n",
+       "      <td>2.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>1091.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>470.652008</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1060.0</td>\n",
+       "      <td>579.0</td>\n",
+       "      <td>164.069000</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2013-01-03</th>\n",
+       "      <td>3.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>919.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>310.654999</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>836.0</td>\n",
+       "      <td>453.0</td>\n",
+       "      <td>151.582001</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2013-01-04</th>\n",
+       "      <td>3.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>953.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>198.365997</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>827.0</td>\n",
+       "      <td>460.0</td>\n",
+       "      <td>131.410995</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2013-01-05</th>\n",
+       "      <td>5.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>1160.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>301.057007</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>811.0</td>\n",
+       "      <td>464.0</td>\n",
+       "      <td>118.612999</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</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",
+       "      <td>...</td>\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",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2017-08-11</th>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1006.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>145.606995</td>\n",
+       "      <td>4.0</td>\n",
+       "      <td>341.0</td>\n",
+       "      <td>343.0</td>\n",
+       "      <td>64.302002</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>11.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>22.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>6.0</td>\n",
+       "      <td>7.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2017-08-12</th>\n",
+       "      <td>6.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>1659.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>243.220001</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>351.0</td>\n",
+       "      <td>526.0</td>\n",
+       "      <td>99.487999</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>7.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>7.0</td>\n",
+       "      <td>10.0</td>\n",
+       "      <td>4.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2017-08-13</th>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>803.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>136.679001</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>169.0</td>\n",
+       "      <td>266.0</td>\n",
+       "      <td>47.770000</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>9.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>7.0</td>\n",
+       "      <td>8.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2017-08-14</th>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>6.0</td>\n",
+       "      <td>2201.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>346.037994</td>\n",
+       "      <td>4.0</td>\n",
+       "      <td>571.0</td>\n",
+       "      <td>699.0</td>\n",
+       "      <td>154.578003</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>10.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>7.0</td>\n",
+       "      <td>11.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2017-08-15</th>\n",
+       "      <td>4.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>4.0</td>\n",
+       "      <td>1942.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>329.541016</td>\n",
+       "      <td>21.0</td>\n",
+       "      <td>703.0</td>\n",
+       "      <td>602.0</td>\n",
+       "      <td>116.402000</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>11.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>148.0</td>\n",
+       "      <td>8.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>1684 rows × 3564 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                sales                                                \\\n",
+       "store_nbr           1                                                 \n",
+       "family     AUTOMOTIVE BABY CARE BEAUTY BEVERAGES BOOKS BREAD/BAKERY   \n",
+       "date                                                                  \n",
+       "2013-01-01        0.0       0.0    0.0       0.0   0.0     0.000000   \n",
+       "2013-01-02        2.0       0.0    2.0    1091.0   0.0   470.652008   \n",
+       "2013-01-03        3.0       0.0    0.0     919.0   0.0   310.654999   \n",
+       "2013-01-04        3.0       0.0    3.0     953.0   0.0   198.365997   \n",
+       "2013-01-05        5.0       0.0    3.0    1160.0   0.0   301.057007   \n",
+       "...               ...       ...    ...       ...   ...          ...   \n",
+       "2017-08-11        1.0       0.0    1.0    1006.0   0.0   145.606995   \n",
+       "2017-08-12        6.0       0.0    3.0    1659.0   0.0   243.220001   \n",
+       "2017-08-13        1.0       0.0    1.0     803.0   0.0   136.679001   \n",
+       "2017-08-14        1.0       0.0    6.0    2201.0   0.0   346.037994   \n",
+       "2017-08-15        4.0       0.0    4.0    1942.0   0.0   329.541016   \n",
+       "\n",
+       "                                                    ... onpromotion        \\\n",
+       "store_nbr                                           ...           9         \n",
+       "family     CELEBRATION CLEANING  DAIRY        DELI  ...   MAGAZINES MEATS   \n",
+       "date                                                ...                     \n",
+       "2013-01-01         0.0      0.0    0.0    0.000000  ...         0.0   0.0   \n",
+       "2013-01-02         0.0   1060.0  579.0  164.069000  ...         0.0   0.0   \n",
+       "2013-01-03         0.0    836.0  453.0  151.582001  ...         0.0   0.0   \n",
+       "2013-01-04         0.0    827.0  460.0  131.410995  ...         0.0   0.0   \n",
+       "2013-01-05         0.0    811.0  464.0  118.612999  ...         0.0   0.0   \n",
+       "...                ...      ...    ...         ...  ...         ...   ...   \n",
+       "2017-08-11         4.0    341.0  343.0   64.302002  ...         0.0   0.0   \n",
+       "2017-08-12         3.0    351.0  526.0   99.487999  ...         0.0   0.0   \n",
+       "2017-08-13         1.0    169.0  266.0   47.770000  ...         0.0   0.0   \n",
+       "2017-08-14         4.0    571.0  699.0  154.578003  ...         0.0   0.0   \n",
+       "2017-08-15        21.0    703.0  602.0  116.402000  ...         0.0   0.0   \n",
+       "\n",
+       "                                                                       \\\n",
+       "store_nbr                                                               \n",
+       "family     PERSONAL CARE PET SUPPLIES PLAYERS AND ELECTRONICS POULTRY   \n",
+       "date                                                                    \n",
+       "2013-01-01           0.0          0.0                     0.0     0.0   \n",
+       "2013-01-02           0.0          0.0                     0.0     0.0   \n",
+       "2013-01-03           0.0          0.0                     0.0     0.0   \n",
+       "2013-01-04           0.0          0.0                     0.0     0.0   \n",
+       "2013-01-05           0.0          0.0                     0.0     0.0   \n",
+       "...                  ...          ...                     ...     ...   \n",
+       "2017-08-11          11.0          0.0                     0.0    22.0   \n",
+       "2017-08-12           7.0          0.0                     0.0     0.0   \n",
+       "2017-08-13           9.0          0.0                     0.0     0.0   \n",
+       "2017-08-14          10.0          0.0                     0.0     0.0   \n",
+       "2017-08-15          11.0          0.0                     0.0     0.0   \n",
+       "\n",
+       "                                                                      \n",
+       "store_nbr                                                             \n",
+       "family     PREPARED FOODS PRODUCE SCHOOL AND OFFICE SUPPLIES SEAFOOD  \n",
+       "date                                                                  \n",
+       "2013-01-01            0.0     0.0                        0.0     0.0  \n",
+       "2013-01-02            0.0     0.0                        0.0     0.0  \n",
+       "2013-01-03            0.0     0.0                        0.0     0.0  \n",
+       "2013-01-04            0.0     0.0                        0.0     0.0  \n",
+       "2013-01-05            0.0     0.0                        0.0     0.0  \n",
+       "...                   ...     ...                        ...     ...  \n",
+       "2017-08-11            3.0     6.0                        7.0     0.0  \n",
+       "2017-08-12            1.0     7.0                       10.0     4.0  \n",
+       "2017-08-13            1.0     7.0                        8.0     0.0  \n",
+       "2017-08-14            0.0     7.0                       11.0     0.0  \n",
+       "2017-08-15            1.0   148.0                        8.0     0.0  \n",
+       "\n",
+       "[1684 rows x 3564 columns]"
+      ]
+     },
+     "execution_count": 204,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df_train_pvt = df_train.pivot(index='date', columns=['store_nbr', 'family'], values=['sales', 'onpromotion']).sort_index()\n",
+    "df_train_pvt\n",
+    "# from datetime import timedelta\n",
+    "# remove leading 0-sales\n",
+    "# df_train_pvt.columns\n",
+    "# for c in df_train_pvt.columns:\n",
+    "#     df_train_pvt[c].loc[:df_train_pvt[c].ne(0).idxmax()-timedelta(days=1)] = np.nan"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "79a1c2f5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def featurize_lgb(df):\n",
+    "   return pd.DataFrame({\n",
+    "        # 'seasonal' : (df['date'] - min_date).dt.days // 90,\n",
+    "        'store'    : df['store_nbr'].astype(\"category\"),\n",
+    "        'item'     : df['family'].astype(\"category\"),\n",
+    "        'date_weekday'   : df['date'].dt.month,\n",
+    "        'date_month'     : df['date'].dt.dayofweek,\n",
+    "        # 'onpromotion'    : df['onpromotion'],\n",
+    "#         'city'     : df['city'],\n",
+    "#         'state'    : df['state'],\n",
+    "#         'type'     : df['type'],\n",
+    "#         'cluster'  : df['cluster'],\n",
+    "        # NaNs\n",
+    "        # 'store_month'     : df['store_nbr'].astype(str) + '_' + df['date'].dt.month.astype(str),\n",
+    "        # 'item_month'      : df['family'].astype(str)    + '_' + df['date'].dt.month.astype(str),\n",
+    "        # 'store_X_dayofweek'     : df['store_nbr'].astype(\"category\").cat.codes.astype(str) + '_' + df['date'].dt.dayofweek.astype(str),\n",
+    "        # 'item_X_dayofweek'      : df['family'].astype(\"category\").cat.codes.astype(str)    + '_' + df['date'].dt.dayofweek.astype(str),\n",
+    "        # 'store_item' : df['family'].astype(str) + '_' + df['store_nbr'].astype(str),\n",
+    "       \n",
+    "        # 'dayofweek': df['date'].dt.dayofweek.values,\n",
+    "        # 'dayofyear': df['date'].dt.dayofyear.values,\n",
+    "        # 'month'    : df['date'].dt.month.values,\n",
+    "        # 'type'     : df['type'].fillna('Unknown').astype('category').cat.codes,\n",
+    "        # 'ma_oil'   : pd.cut(df['ma_oil'].fillna(0), ma_oil_bins, include_lowest=True).cat.codes\n",
+    "        # 'ma_oil'   : df['ma_oil'],\n",
+    "        # 'dofw'     : df['dofw'].fillna('Unknown').astype(\"category\").cat.codes,\n",
+    "    })\n",
+    "\n",
+    "#     # LightGBM\n",
+    "#     x_train = featurize_lgb(yX_train)\n",
+    "#     x_test  = featurize_lgb(yX_test)\n",
+    "    \n",
+    "#     train_data = lgb.Dataset(x_train, label=np.log1p(yX_train['sales']))\n",
+    "#     param = {'num_leaves': 31, 'objective': 'regression', 'metric': 'rmse'}\n",
+    "    \n",
+    "#     bst = lgb.train(param, train_data)\n",
+    "    \n",
+    "#     y_pred_test = np.expm1(bst.predict(x_test))\n",
+    "#     rmsle = mean_squared_log_error(yX_test['sales'], np.maximum(y_pred_test, 0), squared=False)\n",
+    "#     back_testing_lgb.append(rmsle)\n",
+    "    \n",
+    "#     print(f'rmsle: {rmsle}')\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 213,
+   "id": "8b103e37",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[   0    1    2 ... 1606 1607 1608]\n",
+      "[   0    1    2 ... 1621 1622 1623]\n",
+      "[   0    1    2 ... 1636 1637 1638]\n",
+      "[   0    1    2 ... 1651 1652 1653]\n",
+      "[   0    1    2 ... 1666 1667 1668]\n"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "    print(train_index)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 219,
+   "id": "43a35411",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>date</th>\n",
+       "      <th>store_nbr</th>\n",
+       "      <th>family</th>\n",
+       "      <th>sales</th>\n",
+       "      <th>onpromotion</th>\n",
+       "      <th>dcoilwtico</th>\n",
+       "      <th>ma_oil</th>\n",
+       "      <th>dofw</th>\n",
+       "      <th>wd</th>\n",
+       "      <th>type_x</th>\n",
+       "      <th>locale</th>\n",
+       "      <th>locale_name</th>\n",
+       "      <th>description</th>\n",
+       "      <th>transferred</th>\n",
+       "      <th>city</th>\n",
+       "      <th>state</th>\n",
+       "      <th>type_y</th>\n",
+       "      <th>cluster</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>2013-01-01</td>\n",
+       "      <td>1</td>\n",
+       "      <td>AUTOMOTIVE</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>1</td>\n",
+       "      <td>False</td>\n",
+       "      <td>Holiday</td>\n",
+       "      <td>National</td>\n",
+       "      <td>Ecuador</td>\n",
+       "      <td>Primer dia del ano</td>\n",
+       "      <td>False</td>\n",
+       "      <td>Quito</td>\n",
+       "      <td>Pichincha</td>\n",
+       "      <td>D</td>\n",
+       "      <td>13</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>2013-01-01</td>\n",
+       "      <td>1</td>\n",
+       "      <td>BABY CARE</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>1</td>\n",
+       "      <td>False</td>\n",
+       "      <td>Holiday</td>\n",
+       "      <td>National</td>\n",
+       "      <td>Ecuador</td>\n",
+       "      <td>Primer dia del ano</td>\n",
+       "      <td>False</td>\n",
+       "      <td>Quito</td>\n",
+       "      <td>Pichincha</td>\n",
+       "      <td>D</td>\n",
+       "      <td>13</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>2013-01-01</td>\n",
+       "      <td>1</td>\n",
+       "      <td>BEAUTY</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>1</td>\n",
+       "      <td>False</td>\n",
+       "      <td>Holiday</td>\n",
+       "      <td>National</td>\n",
+       "      <td>Ecuador</td>\n",
+       "      <td>Primer dia del ano</td>\n",
+       "      <td>False</td>\n",
+       "      <td>Quito</td>\n",
+       "      <td>Pichincha</td>\n",
+       "      <td>D</td>\n",
+       "      <td>13</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>2013-01-01</td>\n",
+       "      <td>1</td>\n",
+       "      <td>BEVERAGES</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>1</td>\n",
+       "      <td>False</td>\n",
+       "      <td>Holiday</td>\n",
+       "      <td>National</td>\n",
+       "      <td>Ecuador</td>\n",
+       "      <td>Primer dia del ano</td>\n",
+       "      <td>False</td>\n",
+       "      <td>Quito</td>\n",
+       "      <td>Pichincha</td>\n",
+       "      <td>D</td>\n",
+       "      <td>13</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>2013-01-01</td>\n",
+       "      <td>1</td>\n",
+       "      <td>BOOKS</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>1</td>\n",
+       "      <td>False</td>\n",
+       "      <td>Holiday</td>\n",
+       "      <td>National</td>\n",
+       "      <td>Ecuador</td>\n",
+       "      <td>Primer dia del ano</td>\n",
+       "      <td>False</td>\n",
+       "      <td>Quito</td>\n",
+       "      <td>Pichincha</td>\n",
+       "      <td>D</td>\n",
+       "      <td>13</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",
+       "      <td>...</td>\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",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2867233</th>\n",
+       "      <td>2017-06-01</td>\n",
+       "      <td>9</td>\n",
+       "      <td>POULTRY</td>\n",
+       "      <td>535.961975</td>\n",
+       "      <td>0</td>\n",
+       "      <td>48.32</td>\n",
+       "      <td>50.107143</td>\n",
+       "      <td>3</td>\n",
+       "      <td>True</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>Quito</td>\n",
+       "      <td>Pichincha</td>\n",
+       "      <td>B</td>\n",
+       "      <td>6</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2867234</th>\n",
+       "      <td>2017-06-01</td>\n",
+       "      <td>9</td>\n",
+       "      <td>PREPARED FOODS</td>\n",
+       "      <td>98.870003</td>\n",
+       "      <td>0</td>\n",
+       "      <td>48.32</td>\n",
+       "      <td>50.107143</td>\n",
+       "      <td>3</td>\n",
+       "      <td>True</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>Quito</td>\n",
+       "      <td>Pichincha</td>\n",
+       "      <td>B</td>\n",
+       "      <td>6</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2867235</th>\n",
+       "      <td>2017-06-01</td>\n",
+       "      <td>9</td>\n",
+       "      <td>PRODUCE</td>\n",
+       "      <td>1536.501953</td>\n",
+       "      <td>0</td>\n",
+       "      <td>48.32</td>\n",
+       "      <td>50.107143</td>\n",
+       "      <td>3</td>\n",
+       "      <td>True</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>Quito</td>\n",
+       "      <td>Pichincha</td>\n",
+       "      <td>B</td>\n",
+       "      <td>6</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2867236</th>\n",
+       "      <td>2017-06-01</td>\n",
+       "      <td>9</td>\n",
+       "      <td>SCHOOL AND OFFICE SUPPLIES</td>\n",
+       "      <td>3.000000</td>\n",
+       "      <td>0</td>\n",
+       "      <td>48.32</td>\n",
+       "      <td>50.107143</td>\n",
+       "      <td>3</td>\n",
+       "      <td>True</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>Quito</td>\n",
+       "      <td>Pichincha</td>\n",
+       "      <td>B</td>\n",
+       "      <td>6</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2867237</th>\n",
+       "      <td>2017-06-01</td>\n",
+       "      <td>9</td>\n",
+       "      <td>SEAFOOD</td>\n",
+       "      <td>32.474998</td>\n",
+       "      <td>0</td>\n",
+       "      <td>48.32</td>\n",
+       "      <td>50.107143</td>\n",
+       "      <td>3</td>\n",
+       "      <td>True</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>Quito</td>\n",
+       "      <td>Pichincha</td>\n",
+       "      <td>B</td>\n",
+       "      <td>6</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>2867238 rows × 18 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "              date  store_nbr                      family        sales  \\\n",
+       "0       2013-01-01          1                  AUTOMOTIVE     0.000000   \n",
+       "1       2013-01-01          1                   BABY CARE     0.000000   \n",
+       "2       2013-01-01          1                      BEAUTY     0.000000   \n",
+       "3       2013-01-01          1                   BEVERAGES     0.000000   \n",
+       "4       2013-01-01          1                       BOOKS     0.000000   \n",
+       "...            ...        ...                         ...          ...   \n",
+       "2867233 2017-06-01          9                     POULTRY   535.961975   \n",
+       "2867234 2017-06-01          9              PREPARED FOODS    98.870003   \n",
+       "2867235 2017-06-01          9                     PRODUCE  1536.501953   \n",
+       "2867236 2017-06-01          9  SCHOOL AND OFFICE SUPPLIES     3.000000   \n",
+       "2867237 2017-06-01          9                     SEAFOOD    32.474998   \n",
+       "\n",
+       "         onpromotion  dcoilwtico     ma_oil  dofw     wd   type_x    locale  \\\n",
+       "0                  0         NaN        NaN     1  False  Holiday  National   \n",
+       "1                  0         NaN        NaN     1  False  Holiday  National   \n",
+       "2                  0         NaN        NaN     1  False  Holiday  National   \n",
+       "3                  0         NaN        NaN     1  False  Holiday  National   \n",
+       "4                  0         NaN        NaN     1  False  Holiday  National   \n",
+       "...              ...         ...        ...   ...    ...      ...       ...   \n",
+       "2867233            0       48.32  50.107143     3   True      NaN       NaN   \n",
+       "2867234            0       48.32  50.107143     3   True      NaN       NaN   \n",
+       "2867235            0       48.32  50.107143     3   True      NaN       NaN   \n",
+       "2867236            0       48.32  50.107143     3   True      NaN       NaN   \n",
+       "2867237            0       48.32  50.107143     3   True      NaN       NaN   \n",
+       "\n",
+       "        locale_name         description transferred   city      state type_y  \\\n",
+       "0           Ecuador  Primer dia del ano       False  Quito  Pichincha      D   \n",
+       "1           Ecuador  Primer dia del ano       False  Quito  Pichincha      D   \n",
+       "2           Ecuador  Primer dia del ano       False  Quito  Pichincha      D   \n",
+       "3           Ecuador  Primer dia del ano       False  Quito  Pichincha      D   \n",
+       "4           Ecuador  Primer dia del ano       False  Quito  Pichincha      D   \n",
+       "...             ...                 ...         ...    ...        ...    ...   \n",
+       "2867233         NaN                 NaN         NaN  Quito  Pichincha      B   \n",
+       "2867234         NaN                 NaN         NaN  Quito  Pichincha      B   \n",
+       "2867235         NaN                 NaN         NaN  Quito  Pichincha      B   \n",
+       "2867236         NaN                 NaN         NaN  Quito  Pichincha      B   \n",
+       "2867237         NaN                 NaN         NaN  Quito  Pichincha      B   \n",
+       "\n",
+       "         cluster  \n",
+       "0             13  \n",
+       "1             13  \n",
+       "2             13  \n",
+       "3             13  \n",
+       "4             13  \n",
+       "...          ...  \n",
+       "2867233        6  \n",
+       "2867234        6  \n",
+       "2867235        6  \n",
+       "2867236        6  \n",
+       "2867237        6  \n",
+       "\n",
+       "[2867238 rows x 18 columns]"
+      ]
+     },
+     "execution_count": 219,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df_train[df_train['date'].isin(dates[train_index])].merge(df_store, on='store_nbr')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 228,
+   "id": "89aa2da7",
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "rmsle: 0.7205779117129867 in -0.00029991299379616976\n",
+      "rmsle: 0.7130693214699029 in -5.145899922354147e-05\n",
+      "rmsle: 0.7120638013826535 in -0.0007706760006840341\n",
+      "rmsle: 0.7257127048557661 in -2.473700442351401e-05\n",
+      "rmsle: 0.74898184875726 in -0.00011629299842752516\n",
+      "Median 0.7205779117129867\n",
+      "Avg    0.7240811176357138\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 6 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import lightgbm as lgb\n",
+    "import cbm\n",
+    "import timeit\n",
+    "from sklearn.model_selection import TimeSeriesSplit\n",
+    "from sklearn.metrics import mean_squared_log_error\n",
+    "from sktime.forecasting.exp_smoothing import ExponentialSmoothing\n",
+    "\n",
+    "min_date = df_train.date.min()\n",
+    "\n",
+    "def featurize(df):\n",
+    "   return pd.DataFrame({\n",
+    "#         'seasonal' : (df['date'] - min_date).dt.days // 90,\n",
+    "        # 'store'    : df['store_nbr'], #.astype(\"category\").cat.codes, \n",
+    "        'item'     : df['family'], # .astype(\"category\").cat.codes, \n",
+    "        'date'     : df['date'],\n",
+    "#         'city'     : df['city'],\n",
+    "#         'state'    : df['state'],\n",
+    "#         'type'     : df['type'],\n",
+    "       'cluster'  : df['cluster'],\n",
+    "       'onpromotion'    : df['onpromotion'].astype(float),\n",
+    "        # NaNs\n",
+    "        # 'store_month'     : df['store_nbr'].astype(str) + '_' + df['date'].dt.month.astype(str),\n",
+    "        # 'item_month'      : df['family'].astype(str)    + '_' + df['date'].dt.month.astype(str),\n",
+    "        # 'store_X_dayofweek'     : df['store_nbr'].astype(\"category\").cat.codes.astype(str) + '_' + df['date'].dt.dayofweek.astype(str),\n",
+    "        # 'item_X_dayofweek'      : df['family'].astype(\"category\").cat.codes.astype(str)    + '_' + df['date'].dt.dayofweek.astype(str),\n",
+    "        # 'store_item' : df['family'].astype(str) + '_' + df['store_nbr'].astype(str),\n",
+    "       \n",
+    "        # 'dayofweek': df['date'].dt.dayofweek.values,\n",
+    "        # 'dayofyear': df['date'].dt.dayofyear.values,\n",
+    "        # 'month'    : df['date'].dt.month.values,\n",
+    "        # 'type'     : df['type'].fillna('Unknown').astype('category').cat.codes,\n",
+    "        # 'ma_oil'   : pd.cut(df['ma_oil'].fillna(0), ma_oil_bins, include_lowest=True).cat.codes\n",
+    "        # 'ma_oil'   : df['ma_oil'],\n",
+    "        # 'dofw'     : df['dofw'].fillna('Unknown').astype(\"category\").cat.codes,\n",
+    "    })\n",
+    "\n",
+    "\n",
+    "tscv = TimeSeriesSplit(n_splits=5, test_size=15)\n",
+    "\n",
+    "# df_train_pvt\n",
+    "back_testing = []\n",
+    "back_testing_lgb = []\n",
+    "# for train_index, test_index in tscv.split(df_train_pvt):\n",
+    "dates = df_train['date'].unique()\n",
+    "for train_index, test_index in tscv.split(dates):\n",
+    "    start = timeit.timeit()\n",
+    "    # yX_train = df_train_pvt.iloc[train_index].unstack().reset_index().rename({0: 'sales'}, axis=1).merge(df_store)\n",
+    "    # yX_test  = df_train_pvt.iloc[test_index] .unstack().reset_index().rename({0: 'sales'}, axis=1).merge(df_store)\n",
+    "    yX_train = df_train[df_train['date'].isin(dates[train_index])].merge(df_store, on='store_nbr')\n",
+    "    yX_test  = df_train[df_train['date'].isin(dates[test_index])].merge(df_store, on='store_nbr')\n",
+    "\n",
+    "    \n",
+    "    # valid = ~yX_train['sales'].isna()\n",
+    "    \n",
+    "    # print(yX_train)\n",
+    "    # x_train = featurize(yX_train[valid])\n",
+    "    x_train = featurize(yX_train)\n",
+    "    x_test  = featurize(yX_test)\n",
+    "    \n",
+    "    \n",
+    "    model = cbm.CBM(binning=20) # metric='l1', min_iterations_early_stopping=40, epsilon_early_stopping=1e-5) #binning = lambda _: 3)\n",
+    "    # model.fit(x_train, yX_train['sales'][valid])\n",
+    "    model.fit(x_train, yX_train['sales'])\n",
+    "    \n",
+    "    # estimate seasonal effect\n",
+    "#     y_dummy = np.array(model.weights[0])\n",
+    "#     y_dummy_ts = pd.Series(y_dummy)\n",
+    "\n",
+    "#     fh = np.arange(-len(y_dummy_ts)+1, # cover the training period\n",
+    "#                    x_test['seasonal'].max() + 2 - len(y_dummy_ts) # cover the test period\n",
+    "#                   )\n",
+    "\n",
+    "#     forecaster = ExponentialSmoothing(trend=\"add\") #, seasonal=\"multiplicative\", sp=4)\n",
+    "#     forecaster.fit(y_dummy_ts)\n",
+    "#     y_pred = forecaster.predict(fh=fh)\n",
+    "    \n",
+    "#     plot_series(y_dummy_ts, y_pred)\n",
+    "    \n",
+    "#     w = model.weights\n",
+    "#     w[0] = y_pred\n",
+    "#     model.update(w, model.y_mean)\n",
+    "    \n",
+    "    y_pred_test = model.predict(x_test).flatten()\n",
+    "\n",
+    "    # test on train error\n",
+    "    rmsle = mean_squared_log_error(yX_test['sales'].fillna(0), y_pred_test, squared=False)\n",
+    "    back_testing.append(rmsle)\n",
+    "    end = timeit.timeit()\n",
+    "    \n",
+    "    print(f'rmsle: {rmsle} in {end - start}')\n",
+    "   \n",
+    "    \n",
+    "\n",
+    "print(f'Median {np.median(back_testing)}')\n",
+    "print(f'Avg    {np.mean(back_testing)}')\n",
+    "\n",
+    "# print(f'Median {np.median(back_testing_lgb)}')\n",
+    "\n",
+    "model.plot_importance(figsize=(20,10))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 230,
+   "id": "347de029",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>date</th>\n",
+       "      <th>store_nbr</th>\n",
+       "      <th>family</th>\n",
+       "      <th>sales</th>\n",
+       "      <th>onpromotion</th>\n",
+       "      <th>dcoilwtico</th>\n",
+       "      <th>ma_oil</th>\n",
+       "      <th>dofw</th>\n",
+       "      <th>wd</th>\n",
+       "      <th>type_x</th>\n",
+       "      <th>locale</th>\n",
+       "      <th>locale_name</th>\n",
+       "      <th>description</th>\n",
+       "      <th>transferred</th>\n",
+       "      <th>city</th>\n",
+       "      <th>state</th>\n",
+       "      <th>type_y</th>\n",
+       "      <th>cluster</th>\n",
+       "      <th>pred</th>\n",
+       "      <th>error</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>2017-08-01</td>\n",
+       "      <td>1</td>\n",
+       "      <td>AUTOMOTIVE</td>\n",
+       "      <td>5.000000</td>\n",
+       "      <td>0</td>\n",
+       "      <td>49.19</td>\n",
+       "      <td>48.675714</td>\n",
+       "      <td>1</td>\n",
+       "      <td>True</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>Quito</td>\n",
+       "      <td>Pichincha</td>\n",
+       "      <td>D</td>\n",
+       "      <td>13</td>\n",
+       "      <td>4.938130</td>\n",
+       "      <td>0.000107</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>2017-08-01</td>\n",
+       "      <td>1</td>\n",
+       "      <td>BABY CARE</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0</td>\n",
+       "      <td>49.19</td>\n",
+       "      <td>48.675714</td>\n",
+       "      <td>1</td>\n",
+       "      <td>True</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>Quito</td>\n",
+       "      <td>Pichincha</td>\n",
+       "      <td>D</td>\n",
+       "      <td>13</td>\n",
+       "      <td>0.419986</td>\n",
+       "      <td>0.122953</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>2017-08-01</td>\n",
+       "      <td>1</td>\n",
+       "      <td>BEAUTY</td>\n",
+       "      <td>4.000000</td>\n",
+       "      <td>0</td>\n",
+       "      <td>49.19</td>\n",
+       "      <td>48.675714</td>\n",
+       "      <td>1</td>\n",
+       "      <td>True</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>Quito</td>\n",
+       "      <td>Pichincha</td>\n",
+       "      <td>D</td>\n",
+       "      <td>13</td>\n",
+       "      <td>3.119056</td>\n",
+       "      <td>0.037564</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>2017-08-01</td>\n",
+       "      <td>1</td>\n",
+       "      <td>BEVERAGES</td>\n",
+       "      <td>2627.000000</td>\n",
+       "      <td>26</td>\n",
+       "      <td>49.19</td>\n",
+       "      <td>48.675714</td>\n",
+       "      <td>1</td>\n",
+       "      <td>True</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>Quito</td>\n",
+       "      <td>Pichincha</td>\n",
+       "      <td>D</td>\n",
+       "      <td>13</td>\n",
+       "      <td>2419.970533</td>\n",
+       "      <td>0.006733</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>2017-08-01</td>\n",
+       "      <td>1</td>\n",
+       "      <td>BOOKS</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0</td>\n",
+       "      <td>49.19</td>\n",
+       "      <td>48.675714</td>\n",
+       "      <td>1</td>\n",
+       "      <td>True</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>Quito</td>\n",
+       "      <td>Pichincha</td>\n",
+       "      <td>D</td>\n",
+       "      <td>13</td>\n",
+       "      <td>0.355890</td>\n",
+       "      <td>0.092694</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",
+       "      <td>...</td>\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",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>26725</th>\n",
+       "      <td>2017-08-15</td>\n",
+       "      <td>9</td>\n",
+       "      <td>POULTRY</td>\n",
+       "      <td>438.132996</td>\n",
+       "      <td>0</td>\n",
+       "      <td>47.57</td>\n",
+       "      <td>48.648571</td>\n",
+       "      <td>1</td>\n",
+       "      <td>True</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>Quito</td>\n",
+       "      <td>Pichincha</td>\n",
+       "      <td>B</td>\n",
+       "      <td>6</td>\n",
+       "      <td>252.535812</td>\n",
+       "      <td>0.301727</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>26726</th>\n",
+       "      <td>2017-08-15</td>\n",
+       "      <td>9</td>\n",
+       "      <td>PREPARED FOODS</td>\n",
+       "      <td>154.552994</td>\n",
+       "      <td>1</td>\n",
+       "      <td>47.57</td>\n",
+       "      <td>48.648571</td>\n",
+       "      <td>1</td>\n",
+       "      <td>True</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>Quito</td>\n",
+       "      <td>Pichincha</td>\n",
+       "      <td>B</td>\n",
+       "      <td>6</td>\n",
+       "      <td>75.716531</td>\n",
+       "      <td>0.499664</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>26727</th>\n",
+       "      <td>2017-08-15</td>\n",
+       "      <td>9</td>\n",
+       "      <td>PRODUCE</td>\n",
+       "      <td>2419.729004</td>\n",
+       "      <td>148</td>\n",
+       "      <td>47.57</td>\n",
+       "      <td>48.648571</td>\n",
+       "      <td>1</td>\n",
+       "      <td>True</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>Quito</td>\n",
+       "      <td>Pichincha</td>\n",
+       "      <td>B</td>\n",
+       "      <td>6</td>\n",
+       "      <td>1806.825929</td>\n",
+       "      <td>0.085231</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>26728</th>\n",
+       "      <td>2017-08-15</td>\n",
+       "      <td>9</td>\n",
+       "      <td>SCHOOL AND OFFICE SUPPLIES</td>\n",
+       "      <td>121.000000</td>\n",
+       "      <td>8</td>\n",
+       "      <td>47.57</td>\n",
+       "      <td>48.648571</td>\n",
+       "      <td>1</td>\n",
+       "      <td>True</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>Quito</td>\n",
+       "      <td>Pichincha</td>\n",
+       "      <td>B</td>\n",
+       "      <td>6</td>\n",
+       "      <td>3.980960</td>\n",
+       "      <td>10.229751</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>26729</th>\n",
+       "      <td>2017-08-15</td>\n",
+       "      <td>9</td>\n",
+       "      <td>SEAFOOD</td>\n",
+       "      <td>16.000000</td>\n",
+       "      <td>0</td>\n",
+       "      <td>47.57</td>\n",
+       "      <td>48.648571</td>\n",
+       "      <td>1</td>\n",
+       "      <td>True</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>Quito</td>\n",
+       "      <td>Pichincha</td>\n",
+       "      <td>B</td>\n",
+       "      <td>6</td>\n",
+       "      <td>17.102166</td>\n",
+       "      <td>0.003946</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>26730 rows × 20 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "            date  store_nbr                      family        sales  \\\n",
+       "0     2017-08-01          1                  AUTOMOTIVE     5.000000   \n",
+       "1     2017-08-01          1                   BABY CARE     0.000000   \n",
+       "2     2017-08-01          1                      BEAUTY     4.000000   \n",
+       "3     2017-08-01          1                   BEVERAGES  2627.000000   \n",
+       "4     2017-08-01          1                       BOOKS     0.000000   \n",
+       "...          ...        ...                         ...          ...   \n",
+       "26725 2017-08-15          9                     POULTRY   438.132996   \n",
+       "26726 2017-08-15          9              PREPARED FOODS   154.552994   \n",
+       "26727 2017-08-15          9                     PRODUCE  2419.729004   \n",
+       "26728 2017-08-15          9  SCHOOL AND OFFICE SUPPLIES   121.000000   \n",
+       "26729 2017-08-15          9                     SEAFOOD    16.000000   \n",
+       "\n",
+       "       onpromotion  dcoilwtico     ma_oil  dofw    wd type_x locale  \\\n",
+       "0                0       49.19  48.675714     1  True    NaN    NaN   \n",
+       "1                0       49.19  48.675714     1  True    NaN    NaN   \n",
+       "2                0       49.19  48.675714     1  True    NaN    NaN   \n",
+       "3               26       49.19  48.675714     1  True    NaN    NaN   \n",
+       "4                0       49.19  48.675714     1  True    NaN    NaN   \n",
+       "...            ...         ...        ...   ...   ...    ...    ...   \n",
+       "26725            0       47.57  48.648571     1  True    NaN    NaN   \n",
+       "26726            1       47.57  48.648571     1  True    NaN    NaN   \n",
+       "26727          148       47.57  48.648571     1  True    NaN    NaN   \n",
+       "26728            8       47.57  48.648571     1  True    NaN    NaN   \n",
+       "26729            0       47.57  48.648571     1  True    NaN    NaN   \n",
+       "\n",
+       "      locale_name description transferred   city      state type_y  cluster  \\\n",
+       "0             NaN         NaN         NaN  Quito  Pichincha      D       13   \n",
+       "1             NaN         NaN         NaN  Quito  Pichincha      D       13   \n",
+       "2             NaN         NaN         NaN  Quito  Pichincha      D       13   \n",
+       "3             NaN         NaN         NaN  Quito  Pichincha      D       13   \n",
+       "4             NaN         NaN         NaN  Quito  Pichincha      D       13   \n",
+       "...           ...         ...         ...    ...        ...    ...      ...   \n",
+       "26725         NaN         NaN         NaN  Quito  Pichincha      B        6   \n",
+       "26726         NaN         NaN         NaN  Quito  Pichincha      B        6   \n",
+       "26727         NaN         NaN         NaN  Quito  Pichincha      B        6   \n",
+       "26728         NaN         NaN         NaN  Quito  Pichincha      B        6   \n",
+       "26729         NaN         NaN         NaN  Quito  Pichincha      B        6   \n",
+       "\n",
+       "              pred      error  \n",
+       "0         4.938130   0.000107  \n",
+       "1         0.419986   0.122953  \n",
+       "2         3.119056   0.037564  \n",
+       "3      2419.970533   0.006733  \n",
+       "4         0.355890   0.092694  \n",
+       "...            ...        ...  \n",
+       "26725   252.535812   0.301727  \n",
+       "26726    75.716531   0.499664  \n",
+       "26727  1806.825929   0.085231  \n",
+       "26728     3.980960  10.229751  \n",
+       "26729    17.102166   0.003946  \n",
+       "\n",
+       "[26730 rows x 20 columns]"
+      ]
+     },
+     "execution_count": 230,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "yX_test['pred'] = y_pred_test\n",
+    "yX_test['error'] = np.square(np.log1p(yX_test['sales']) - np.log1p(yX_test['pred']))\n",
+    "yX_test"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 144,
+   "id": "c2de6ad4",
+   "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 tr th {\n",
+       "        text-align: left;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead tr:last-of-type th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr>\n",
+       "      <th></th>\n",
+       "      <th>median</th>\n",
+       "      <th>count</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th></th>\n",
+       "      <th>error</th>\n",
+       "      <th>error</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>store_nbr</th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>54</th>\n",
+       "      <td>0.302811</td>\n",
+       "      <td>495</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>14</th>\n",
+       "      <td>0.295256</td>\n",
+       "      <td>495</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>32</th>\n",
+       "      <td>0.282914</td>\n",
+       "      <td>495</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>13</th>\n",
+       "      <td>0.258926</td>\n",
+       "      <td>495</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>43</th>\n",
+       "      <td>0.247714</td>\n",
+       "      <td>495</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "             median count\n",
+       "              error error\n",
+       "store_nbr                \n",
+       "54         0.302811   495\n",
+       "14         0.295256   495\n",
+       "32         0.282914   495\n",
+       "13         0.258926   495\n",
+       "43         0.247714   495"
+      ]
+     },
+     "execution_count": 144,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "yX_test.pivot_table(index=['store_nbr'], columns=[], values=['error'], aggfunc=[np.median, 'count']).sort_values(('median', 'error'), ascending=False).head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 145,
+   "id": "df3d097e",
+   "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 tr th {\n",
+       "        text-align: left;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead tr:last-of-type th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr>\n",
+       "      <th></th>\n",
+       "      <th>median</th>\n",
+       "      <th>count</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th></th>\n",
+       "      <th>error</th>\n",
+       "      <th>error</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>family</th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>LAWN AND GARDEN</th>\n",
+       "      <td>2.198309</td>\n",
+       "      <td>15</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>SEAFOOD</th>\n",
+       "      <td>2.110656</td>\n",
+       "      <td>15</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>HOME APPLIANCES</th>\n",
+       "      <td>0.837816</td>\n",
+       "      <td>15</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>BOOKS</th>\n",
+       "      <td>0.556357</td>\n",
+       "      <td>15</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>PLAYERS AND ELECTRONICS</th>\n",
+       "      <td>0.407820</td>\n",
+       "      <td>15</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                           median count\n",
+       "                            error error\n",
+       "family                                 \n",
+       "LAWN AND GARDEN          2.198309    15\n",
+       "SEAFOOD                  2.110656    15\n",
+       "HOME APPLIANCES          0.837816    15\n",
+       "BOOKS                    0.556357    15\n",
+       "PLAYERS AND ELECTRONICS  0.407820    15"
+      ]
+     },
+     "execution_count": 145,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "yX_test.query('store_nbr == 52').pivot_table(index=['family'], columns=[], values=['error'], aggfunc=[np.median, 'count']).sort_values(('median', 'error'), ascending=False).head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 231,
+   "id": "50567d0f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>date</th>\n",
+       "      <th>store_nbr</th>\n",
+       "      <th>family</th>\n",
+       "      <th>sales</th>\n",
+       "      <th>onpromotion</th>\n",
+       "      <th>dcoilwtico</th>\n",
+       "      <th>ma_oil</th>\n",
+       "      <th>dofw</th>\n",
+       "      <th>wd</th>\n",
+       "      <th>type_x</th>\n",
+       "      <th>locale</th>\n",
+       "      <th>locale_name</th>\n",
+       "      <th>description</th>\n",
+       "      <th>transferred</th>\n",
+       "      <th>city</th>\n",
+       "      <th>state</th>\n",
+       "      <th>type_y</th>\n",
+       "      <th>cluster</th>\n",
+       "      <th>pred</th>\n",
+       "      <th>error</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>23285</th>\n",
+       "      <td>2017-08-01</td>\n",
+       "      <td>52</td>\n",
+       "      <td>LAWN AND GARDEN</td>\n",
+       "      <td>26.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>49.19</td>\n",
+       "      <td>48.675714</td>\n",
+       "      <td>1</td>\n",
+       "      <td>True</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>Manta</td>\n",
+       "      <td>Manabi</td>\n",
+       "      <td>A</td>\n",
+       "      <td>11</td>\n",
+       "      <td>9.551881</td>\n",
+       "      <td>0.882722</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>23318</th>\n",
+       "      <td>2017-08-02</td>\n",
+       "      <td>52</td>\n",
+       "      <td>LAWN AND GARDEN</td>\n",
+       "      <td>61.0</td>\n",
+       "      <td>9</td>\n",
+       "      <td>49.60</td>\n",
+       "      <td>49.160000</td>\n",
+       "      <td>2</td>\n",
+       "      <td>True</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>Manta</td>\n",
+       "      <td>Manabi</td>\n",
+       "      <td>A</td>\n",
+       "      <td>11</td>\n",
+       "      <td>16.737586</td>\n",
+       "      <td>1.566123</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>23351</th>\n",
+       "      <td>2017-08-03</td>\n",
+       "      <td>52</td>\n",
+       "      <td>LAWN AND GARDEN</td>\n",
+       "      <td>79.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>49.03</td>\n",
+       "      <td>49.340000</td>\n",
+       "      <td>3</td>\n",
+       "      <td>True</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>Manta</td>\n",
+       "      <td>Manabi</td>\n",
+       "      <td>A</td>\n",
+       "      <td>11</td>\n",
+       "      <td>8.594847</td>\n",
+       "      <td>4.497795</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>23384</th>\n",
+       "      <td>2017-08-04</td>\n",
+       "      <td>52</td>\n",
+       "      <td>LAWN AND GARDEN</td>\n",
+       "      <td>65.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>49.57</td>\n",
+       "      <td>49.481429</td>\n",
+       "      <td>4</td>\n",
+       "      <td>True</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>Manta</td>\n",
+       "      <td>Manabi</td>\n",
+       "      <td>A</td>\n",
+       "      <td>11</td>\n",
+       "      <td>9.462758</td>\n",
+       "      <td>3.392348</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>23417</th>\n",
+       "      <td>2017-08-05</td>\n",
+       "      <td>52</td>\n",
+       "      <td>LAWN AND GARDEN</td>\n",
+       "      <td>69.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>49.481429</td>\n",
+       "      <td>5</td>\n",
+       "      <td>False</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>Manta</td>\n",
+       "      <td>Manabi</td>\n",
+       "      <td>A</td>\n",
+       "      <td>11</td>\n",
+       "      <td>13.100172</td>\n",
+       "      <td>2.567391</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>23450</th>\n",
+       "      <td>2017-08-06</td>\n",
+       "      <td>52</td>\n",
+       "      <td>LAWN AND GARDEN</td>\n",
+       "      <td>45.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>49.481429</td>\n",
+       "      <td>6</td>\n",
+       "      <td>False</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>Manta</td>\n",
+       "      <td>Manabi</td>\n",
+       "      <td>A</td>\n",
+       "      <td>11</td>\n",
+       "      <td>14.040534</td>\n",
+       "      <td>1.249684</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>23483</th>\n",
+       "      <td>2017-08-07</td>\n",
+       "      <td>52</td>\n",
+       "      <td>LAWN AND GARDEN</td>\n",
+       "      <td>41.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>49.37</td>\n",
+       "      <td>49.527143</td>\n",
+       "      <td>0</td>\n",
+       "      <td>True</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>Manta</td>\n",
+       "      <td>Manabi</td>\n",
+       "      <td>A</td>\n",
+       "      <td>11</td>\n",
+       "      <td>10.537105</td>\n",
+       "      <td>1.669526</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>23516</th>\n",
+       "      <td>2017-08-08</td>\n",
+       "      <td>52</td>\n",
+       "      <td>LAWN AND GARDEN</td>\n",
+       "      <td>51.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>49.07</td>\n",
+       "      <td>49.434286</td>\n",
+       "      <td>1</td>\n",
+       "      <td>True</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>Manta</td>\n",
+       "      <td>Manabi</td>\n",
+       "      <td>A</td>\n",
+       "      <td>11</td>\n",
+       "      <td>9.551881</td>\n",
+       "      <td>2.543832</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>23549</th>\n",
+       "      <td>2017-08-09</td>\n",
+       "      <td>52</td>\n",
+       "      <td>LAWN AND GARDEN</td>\n",
+       "      <td>38.0</td>\n",
+       "      <td>9</td>\n",
+       "      <td>49.59</td>\n",
+       "      <td>49.345714</td>\n",
+       "      <td>2</td>\n",
+       "      <td>True</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>Manta</td>\n",
+       "      <td>Manabi</td>\n",
+       "      <td>A</td>\n",
+       "      <td>11</td>\n",
+       "      <td>16.737586</td>\n",
+       "      <td>0.620748</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>23582</th>\n",
+       "      <td>2017-08-10</td>\n",
+       "      <td>52</td>\n",
+       "      <td>LAWN AND GARDEN</td>\n",
+       "      <td>35.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>48.54</td>\n",
+       "      <td>49.252857</td>\n",
+       "      <td>3</td>\n",
+       "      <td>True</td>\n",
+       "      <td>Holiday</td>\n",
+       "      <td>National</td>\n",
+       "      <td>Ecuador</td>\n",
+       "      <td>Primer Grito de Independencia</td>\n",
+       "      <td>True</td>\n",
+       "      <td>Manta</td>\n",
+       "      <td>Manabi</td>\n",
+       "      <td>A</td>\n",
+       "      <td>11</td>\n",
+       "      <td>8.594847</td>\n",
+       "      <td>1.748458</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>23615</th>\n",
+       "      <td>2017-08-11</td>\n",
+       "      <td>52</td>\n",
+       "      <td>LAWN AND GARDEN</td>\n",
+       "      <td>78.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>48.81</td>\n",
+       "      <td>49.140000</td>\n",
+       "      <td>4</td>\n",
+       "      <td>False</td>\n",
+       "      <td>Transfer</td>\n",
+       "      <td>National</td>\n",
+       "      <td>Ecuador</td>\n",
+       "      <td>Traslado Primer Grito de Independencia</td>\n",
+       "      <td>False</td>\n",
+       "      <td>Manta</td>\n",
+       "      <td>Manabi</td>\n",
+       "      <td>A</td>\n",
+       "      <td>11</td>\n",
+       "      <td>9.462758</td>\n",
+       "      <td>4.086970</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>23648</th>\n",
+       "      <td>2017-08-12</td>\n",
+       "      <td>52</td>\n",
+       "      <td>LAWN AND GARDEN</td>\n",
+       "      <td>86.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>49.140000</td>\n",
+       "      <td>5</td>\n",
+       "      <td>False</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>Manta</td>\n",
+       "      <td>Manabi</td>\n",
+       "      <td>A</td>\n",
+       "      <td>11</td>\n",
+       "      <td>13.100172</td>\n",
+       "      <td>3.311385</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>23681</th>\n",
+       "      <td>2017-08-13</td>\n",
+       "      <td>52</td>\n",
+       "      <td>LAWN AND GARDEN</td>\n",
+       "      <td>59.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>49.140000</td>\n",
+       "      <td>6</td>\n",
+       "      <td>False</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>Manta</td>\n",
+       "      <td>Manabi</td>\n",
+       "      <td>A</td>\n",
+       "      <td>11</td>\n",
+       "      <td>14.040534</td>\n",
+       "      <td>1.914337</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>23714</th>\n",
+       "      <td>2017-08-14</td>\n",
+       "      <td>52</td>\n",
+       "      <td>LAWN AND GARDEN</td>\n",
+       "      <td>43.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>47.59</td>\n",
+       "      <td>48.934286</td>\n",
+       "      <td>0</td>\n",
+       "      <td>True</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>Manta</td>\n",
+       "      <td>Manabi</td>\n",
+       "      <td>A</td>\n",
+       "      <td>11</td>\n",
+       "      <td>10.537105</td>\n",
+       "      <td>1.791907</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>23747</th>\n",
+       "      <td>2017-08-15</td>\n",
+       "      <td>52</td>\n",
+       "      <td>LAWN AND GARDEN</td>\n",
+       "      <td>54.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>47.57</td>\n",
+       "      <td>48.648571</td>\n",
+       "      <td>1</td>\n",
+       "      <td>True</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>Manta</td>\n",
+       "      <td>Manabi</td>\n",
+       "      <td>A</td>\n",
+       "      <td>11</td>\n",
+       "      <td>9.551881</td>\n",
+       "      <td>2.725897</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "            date  store_nbr           family  sales  onpromotion  dcoilwtico  \\\n",
+       "23285 2017-08-01         52  LAWN AND GARDEN   26.0            0       49.19   \n",
+       "23318 2017-08-02         52  LAWN AND GARDEN   61.0            9       49.60   \n",
+       "23351 2017-08-03         52  LAWN AND GARDEN   79.0            0       49.03   \n",
+       "23384 2017-08-04         52  LAWN AND GARDEN   65.0            0       49.57   \n",
+       "23417 2017-08-05         52  LAWN AND GARDEN   69.0            0         NaN   \n",
+       "23450 2017-08-06         52  LAWN AND GARDEN   45.0            0         NaN   \n",
+       "23483 2017-08-07         52  LAWN AND GARDEN   41.0            1       49.37   \n",
+       "23516 2017-08-08         52  LAWN AND GARDEN   51.0            0       49.07   \n",
+       "23549 2017-08-09         52  LAWN AND GARDEN   38.0            9       49.59   \n",
+       "23582 2017-08-10         52  LAWN AND GARDEN   35.0            0       48.54   \n",
+       "23615 2017-08-11         52  LAWN AND GARDEN   78.0            0       48.81   \n",
+       "23648 2017-08-12         52  LAWN AND GARDEN   86.0            0         NaN   \n",
+       "23681 2017-08-13         52  LAWN AND GARDEN   59.0            0         NaN   \n",
+       "23714 2017-08-14         52  LAWN AND GARDEN   43.0            0       47.59   \n",
+       "23747 2017-08-15         52  LAWN AND GARDEN   54.0            0       47.57   \n",
+       "\n",
+       "          ma_oil  dofw     wd    type_x    locale locale_name  \\\n",
+       "23285  48.675714     1   True       NaN       NaN         NaN   \n",
+       "23318  49.160000     2   True       NaN       NaN         NaN   \n",
+       "23351  49.340000     3   True       NaN       NaN         NaN   \n",
+       "23384  49.481429     4   True       NaN       NaN         NaN   \n",
+       "23417  49.481429     5  False       NaN       NaN         NaN   \n",
+       "23450  49.481429     6  False       NaN       NaN         NaN   \n",
+       "23483  49.527143     0   True       NaN       NaN         NaN   \n",
+       "23516  49.434286     1   True       NaN       NaN         NaN   \n",
+       "23549  49.345714     2   True       NaN       NaN         NaN   \n",
+       "23582  49.252857     3   True   Holiday  National     Ecuador   \n",
+       "23615  49.140000     4  False  Transfer  National     Ecuador   \n",
+       "23648  49.140000     5  False       NaN       NaN         NaN   \n",
+       "23681  49.140000     6  False       NaN       NaN         NaN   \n",
+       "23714  48.934286     0   True       NaN       NaN         NaN   \n",
+       "23747  48.648571     1   True       NaN       NaN         NaN   \n",
+       "\n",
+       "                                  description transferred   city   state  \\\n",
+       "23285                                     NaN         NaN  Manta  Manabi   \n",
+       "23318                                     NaN         NaN  Manta  Manabi   \n",
+       "23351                                     NaN         NaN  Manta  Manabi   \n",
+       "23384                                     NaN         NaN  Manta  Manabi   \n",
+       "23417                                     NaN         NaN  Manta  Manabi   \n",
+       "23450                                     NaN         NaN  Manta  Manabi   \n",
+       "23483                                     NaN         NaN  Manta  Manabi   \n",
+       "23516                                     NaN         NaN  Manta  Manabi   \n",
+       "23549                                     NaN         NaN  Manta  Manabi   \n",
+       "23582           Primer Grito de Independencia        True  Manta  Manabi   \n",
+       "23615  Traslado Primer Grito de Independencia       False  Manta  Manabi   \n",
+       "23648                                     NaN         NaN  Manta  Manabi   \n",
+       "23681                                     NaN         NaN  Manta  Manabi   \n",
+       "23714                                     NaN         NaN  Manta  Manabi   \n",
+       "23747                                     NaN         NaN  Manta  Manabi   \n",
+       "\n",
+       "      type_y  cluster       pred     error  \n",
+       "23285      A       11   9.551881  0.882722  \n",
+       "23318      A       11  16.737586  1.566123  \n",
+       "23351      A       11   8.594847  4.497795  \n",
+       "23384      A       11   9.462758  3.392348  \n",
+       "23417      A       11  13.100172  2.567391  \n",
+       "23450      A       11  14.040534  1.249684  \n",
+       "23483      A       11  10.537105  1.669526  \n",
+       "23516      A       11   9.551881  2.543832  \n",
+       "23549      A       11  16.737586  0.620748  \n",
+       "23582      A       11   8.594847  1.748458  \n",
+       "23615      A       11   9.462758  4.086970  \n",
+       "23648      A       11  13.100172  3.311385  \n",
+       "23681      A       11  14.040534  1.914337  \n",
+       "23714      A       11  10.537105  1.791907  \n",
+       "23747      A       11   9.551881  2.725897  "
+      ]
+     },
+     "execution_count": 231,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "yX_test.query('store_nbr == 52 and family == \"LAWN AND GARDEN\"')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 188,
+   "id": "f63b16b1",
+   "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 tr th {\n",
+       "        text-align: left;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead tr:last-of-type th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th colspan=\"15\" halign=\"left\">sales</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th></th>\n",
+       "      <th>date</th>\n",
+       "      <th>2017-08-01</th>\n",
+       "      <th>2017-08-02</th>\n",
+       "      <th>2017-08-03</th>\n",
+       "      <th>2017-08-04</th>\n",
+       "      <th>2017-08-05</th>\n",
+       "      <th>2017-08-06</th>\n",
+       "      <th>2017-08-07</th>\n",
+       "      <th>2017-08-08</th>\n",
+       "      <th>2017-08-09</th>\n",
+       "      <th>2017-08-10</th>\n",
+       "      <th>2017-08-11</th>\n",
+       "      <th>2017-08-12</th>\n",
+       "      <th>2017-08-13</th>\n",
+       "      <th>2017-08-14</th>\n",
+       "      <th>2017-08-15</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>cluster</th>\n",
+       "      <th>store_nbr</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 rowspan=\"3\" valign=\"top\">1</th>\n",
+       "      <th>24</th>\n",
+       "      <td>30.0</td>\n",
+       "      <td>51.0</td>\n",
+       "      <td>26.0</td>\n",
+       "      <td>40.0</td>\n",
+       "      <td>60.0</td>\n",
+       "      <td>32.0</td>\n",
+       "      <td>34.0</td>\n",
+       "      <td>42.0</td>\n",
+       "      <td>52.0</td>\n",
+       "      <td>42.0</td>\n",
+       "      <td>34.0</td>\n",
+       "      <td>25.0</td>\n",
+       "      <td>20.0</td>\n",
+       "      <td>40.0</td>\n",
+       "      <td>21.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>25</th>\n",
+       "      <td>13.0</td>\n",
+       "      <td>35.0</td>\n",
+       "      <td>17.0</td>\n",
+       "      <td>15.0</td>\n",
+       "      <td>42.0</td>\n",
+       "      <td>18.0</td>\n",
+       "      <td>10.0</td>\n",
+       "      <td>8.0</td>\n",
+       "      <td>44.0</td>\n",
+       "      <td>31.0</td>\n",
+       "      <td>69.0</td>\n",
+       "      <td>40.0</td>\n",
+       "      <td>9.0</td>\n",
+       "      <td>13.0</td>\n",
+       "      <td>12.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>27</th>\n",
+       "      <td>34.0</td>\n",
+       "      <td>33.0</td>\n",
+       "      <td>28.0</td>\n",
+       "      <td>41.0</td>\n",
+       "      <td>40.0</td>\n",
+       "      <td>60.0</td>\n",
+       "      <td>41.0</td>\n",
+       "      <td>40.0</td>\n",
+       "      <td>22.0</td>\n",
+       "      <td>38.0</td>\n",
+       "      <td>69.0</td>\n",
+       "      <td>64.0</td>\n",
+       "      <td>45.0</td>\n",
+       "      <td>36.0</td>\n",
+       "      <td>27.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th rowspan=\"2\" valign=\"top\">2</th>\n",
+       "      <th>37</th>\n",
+       "      <td>19.0</td>\n",
+       "      <td>41.0</td>\n",
+       "      <td>29.0</td>\n",
+       "      <td>23.0</td>\n",
+       "      <td>27.0</td>\n",
+       "      <td>13.0</td>\n",
+       "      <td>26.0</td>\n",
+       "      <td>14.0</td>\n",
+       "      <td>28.0</td>\n",
+       "      <td>24.0</td>\n",
+       "      <td>16.0</td>\n",
+       "      <td>17.0</td>\n",
+       "      <td>16.0</td>\n",
+       "      <td>9.0</td>\n",
+       "      <td>25.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>42</th>\n",
+       "      <td>43.0</td>\n",
+       "      <td>31.0</td>\n",
+       "      <td>39.0</td>\n",
+       "      <td>36.0</td>\n",
+       "      <td>36.0</td>\n",
+       "      <td>33.0</td>\n",
+       "      <td>28.0</td>\n",
+       "      <td>33.0</td>\n",
+       "      <td>37.0</td>\n",
+       "      <td>27.0</td>\n",
+       "      <td>36.0</td>\n",
+       "      <td>66.0</td>\n",
+       "      <td>26.0</td>\n",
+       "      <td>33.0</td>\n",
+       "      <td>27.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th rowspan=\"7\" valign=\"top\">3</th>\n",
+       "      <th>16</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>30</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>32</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>33</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>35</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>40</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>54</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th rowspan=\"3\" valign=\"top\">4</th>\n",
+       "      <th>5</th>\n",
+       "      <td>5.0</td>\n",
+       "      <td>12.0</td>\n",
+       "      <td>6.0</td>\n",
+       "      <td>18.0</td>\n",
+       "      <td>11.0</td>\n",
+       "      <td>9.0</td>\n",
+       "      <td>7.0</td>\n",
+       "      <td>8.0</td>\n",
+       "      <td>6.0</td>\n",
+       "      <td>6.0</td>\n",
+       "      <td>16.0</td>\n",
+       "      <td>12.0</td>\n",
+       "      <td>6.0</td>\n",
+       "      <td>15.0</td>\n",
+       "      <td>2.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>38</th>\n",
+       "      <td>17.0</td>\n",
+       "      <td>29.0</td>\n",
+       "      <td>19.0</td>\n",
+       "      <td>17.0</td>\n",
+       "      <td>36.0</td>\n",
+       "      <td>21.0</td>\n",
+       "      <td>7.0</td>\n",
+       "      <td>18.0</td>\n",
+       "      <td>15.0</td>\n",
+       "      <td>22.0</td>\n",
+       "      <td>14.0</td>\n",
+       "      <td>24.0</td>\n",
+       "      <td>11.0</td>\n",
+       "      <td>8.0</td>\n",
+       "      <td>11.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>41</th>\n",
+       "      <td>18.0</td>\n",
+       "      <td>26.0</td>\n",
+       "      <td>17.0</td>\n",
+       "      <td>15.0</td>\n",
+       "      <td>20.0</td>\n",
+       "      <td>22.0</td>\n",
+       "      <td>9.0</td>\n",
+       "      <td>7.0</td>\n",
+       "      <td>20.0</td>\n",
+       "      <td>6.0</td>\n",
+       "      <td>45.0</td>\n",
+       "      <td>13.0</td>\n",
+       "      <td>21.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>6.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <th>44</th>\n",
+       "      <td>25.0</td>\n",
+       "      <td>42.0</td>\n",
+       "      <td>20.0</td>\n",
+       "      <td>26.0</td>\n",
+       "      <td>48.0</td>\n",
+       "      <td>20.0</td>\n",
+       "      <td>52.0</td>\n",
+       "      <td>16.0</td>\n",
+       "      <td>19.0</td>\n",
+       "      <td>29.0</td>\n",
+       "      <td>49.0</td>\n",
+       "      <td>37.0</td>\n",
+       "      <td>28.0</td>\n",
+       "      <td>18.0</td>\n",
+       "      <td>22.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th rowspan=\"6\" valign=\"top\">6</th>\n",
+       "      <th>9</th>\n",
+       "      <td>15.0</td>\n",
+       "      <td>5.0</td>\n",
+       "      <td>9.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>5.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>6.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>6.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>4.0</td>\n",
+       "      <td>6.0</td>\n",
+       "      <td>8.0</td>\n",
+       "      <td>11.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>11</th>\n",
+       "      <td>2.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>5.0</td>\n",
+       "      <td>5.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>6.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>4.0</td>\n",
+       "      <td>5.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>20</th>\n",
+       "      <td>14.0</td>\n",
+       "      <td>11.0</td>\n",
+       "      <td>8.0</td>\n",
+       "      <td>5.0</td>\n",
+       "      <td>5.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>5.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>4.0</td>\n",
+       "      <td>8.0</td>\n",
+       "      <td>10.0</td>\n",
+       "      <td>15.0</td>\n",
+       "      <td>8.0</td>\n",
+       "      <td>4.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21</th>\n",
+       "      <td>8.0</td>\n",
+       "      <td>5.0</td>\n",
+       "      <td>4.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>6.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>4.0</td>\n",
+       "      <td>4.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>6.0</td>\n",
+       "      <td>5.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>3.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>34</th>\n",
+       "      <td>4.0</td>\n",
+       "      <td>4.0</td>\n",
+       "      <td>7.0</td>\n",
+       "      <td>8.0</td>\n",
+       "      <td>11.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>6.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>7.0</td>\n",
+       "      <td>5.0</td>\n",
+       "      <td>5.0</td>\n",
+       "      <td>8.0</td>\n",
+       "      <td>2.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>39</th>\n",
+       "      <td>13.0</td>\n",
+       "      <td>9.0</td>\n",
+       "      <td>15.0</td>\n",
+       "      <td>25.0</td>\n",
+       "      <td>13.0</td>\n",
+       "      <td>14.0</td>\n",
+       "      <td>14.0</td>\n",
+       "      <td>18.0</td>\n",
+       "      <td>25.0</td>\n",
+       "      <td>14.0</td>\n",
+       "      <td>11.0</td>\n",
+       "      <td>11.0</td>\n",
+       "      <td>9.0</td>\n",
+       "      <td>11.0</td>\n",
+       "      <td>15.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th rowspan=\"2\" valign=\"top\">7</th>\n",
+       "      <th>14</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>22</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th rowspan=\"3\" valign=\"top\">8</th>\n",
+       "      <th>3</th>\n",
+       "      <td>71.0</td>\n",
+       "      <td>79.0</td>\n",
+       "      <td>32.0</td>\n",
+       "      <td>65.0</td>\n",
+       "      <td>65.0</td>\n",
+       "      <td>76.0</td>\n",
+       "      <td>39.0</td>\n",
+       "      <td>37.0</td>\n",
+       "      <td>72.0</td>\n",
+       "      <td>30.0</td>\n",
+       "      <td>62.0</td>\n",
+       "      <td>69.0</td>\n",
+       "      <td>42.0</td>\n",
+       "      <td>38.0</td>\n",
+       "      <td>43.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7</th>\n",
+       "      <td>42.0</td>\n",
+       "      <td>21.0</td>\n",
+       "      <td>38.0</td>\n",
+       "      <td>38.0</td>\n",
+       "      <td>67.0</td>\n",
+       "      <td>33.0</td>\n",
+       "      <td>41.0</td>\n",
+       "      <td>55.0</td>\n",
+       "      <td>35.0</td>\n",
+       "      <td>24.0</td>\n",
+       "      <td>39.0</td>\n",
+       "      <td>50.0</td>\n",
+       "      <td>28.0</td>\n",
+       "      <td>39.0</td>\n",
+       "      <td>43.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8</th>\n",
+       "      <td>26.0</td>\n",
+       "      <td>44.0</td>\n",
+       "      <td>16.0</td>\n",
+       "      <td>27.0</td>\n",
+       "      <td>53.0</td>\n",
+       "      <td>33.0</td>\n",
+       "      <td>26.0</td>\n",
+       "      <td>33.0</td>\n",
+       "      <td>48.0</td>\n",
+       "      <td>38.0</td>\n",
+       "      <td>35.0</td>\n",
+       "      <td>33.0</td>\n",
+       "      <td>39.0</td>\n",
+       "      <td>32.0</td>\n",
+       "      <td>38.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th rowspan=\"2\" valign=\"top\">9</th>\n",
+       "      <th>4</th>\n",
+       "      <td>19.0</td>\n",
+       "      <td>30.0</td>\n",
+       "      <td>10.0</td>\n",
+       "      <td>28.0</td>\n",
+       "      <td>24.0</td>\n",
+       "      <td>29.0</td>\n",
+       "      <td>10.0</td>\n",
+       "      <td>21.0</td>\n",
+       "      <td>36.0</td>\n",
+       "      <td>22.0</td>\n",
+       "      <td>34.0</td>\n",
+       "      <td>16.0</td>\n",
+       "      <td>27.0</td>\n",
+       "      <td>21.0</td>\n",
+       "      <td>14.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>23</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>4.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>7.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>6.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th rowspan=\"6\" valign=\"top\">10</th>\n",
+       "      <th>26</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>9.0</td>\n",
+       "      <td>5.0</td>\n",
+       "      <td>21.0</td>\n",
+       "      <td>10.0</td>\n",
+       "      <td>16.0</td>\n",
+       "      <td>10.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>13.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>12.0</td>\n",
+       "      <td>5.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>28</th>\n",
+       "      <td>9.0</td>\n",
+       "      <td>12.0</td>\n",
+       "      <td>5.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>4.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>6.0</td>\n",
+       "      <td>8.0</td>\n",
+       "      <td>4.0</td>\n",
+       "      <td>11.0</td>\n",
+       "      <td>10.0</td>\n",
+       "      <td>8.0</td>\n",
+       "      <td>9.0</td>\n",
+       "      <td>9.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>29</th>\n",
+       "      <td>9.0</td>\n",
+       "      <td>7.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>4.0</td>\n",
+       "      <td>20.0</td>\n",
+       "      <td>11.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>6.0</td>\n",
+       "      <td>14.0</td>\n",
+       "      <td>8.0</td>\n",
+       "      <td>4.0</td>\n",
+       "      <td>6.0</td>\n",
+       "      <td>8.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>6.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>31</th>\n",
+       "      <td>5.0</td>\n",
+       "      <td>6.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>9.0</td>\n",
+       "      <td>17.0</td>\n",
+       "      <td>10.0</td>\n",
+       "      <td>9.0</td>\n",
+       "      <td>7.0</td>\n",
+       "      <td>12.0</td>\n",
+       "      <td>10.0</td>\n",
+       "      <td>7.0</td>\n",
+       "      <td>7.0</td>\n",
+       "      <td>6.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>36</th>\n",
+       "      <td>22.0</td>\n",
+       "      <td>28.0</td>\n",
+       "      <td>35.0</td>\n",
+       "      <td>16.0</td>\n",
+       "      <td>60.0</td>\n",
+       "      <td>33.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>30.0</td>\n",
+       "      <td>18.0</td>\n",
+       "      <td>48.0</td>\n",
+       "      <td>56.0</td>\n",
+       "      <td>25.0</td>\n",
+       "      <td>15.0</td>\n",
+       "      <td>17.0</td>\n",
+       "      <td>22.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>43</th>\n",
+       "      <td>5.0</td>\n",
+       "      <td>11.0</td>\n",
+       "      <td>17.0</td>\n",
+       "      <td>11.0</td>\n",
+       "      <td>13.0</td>\n",
+       "      <td>13.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>8.0</td>\n",
+       "      <td>9.0</td>\n",
+       "      <td>8.0</td>\n",
+       "      <td>23.0</td>\n",
+       "      <td>9.0</td>\n",
+       "      <td>12.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>8.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th rowspan=\"3\" valign=\"top\">11</th>\n",
+       "      <th>45</th>\n",
+       "      <td>28.0</td>\n",
+       "      <td>36.0</td>\n",
+       "      <td>40.0</td>\n",
+       "      <td>58.0</td>\n",
+       "      <td>73.0</td>\n",
+       "      <td>55.0</td>\n",
+       "      <td>37.0</td>\n",
+       "      <td>15.0</td>\n",
+       "      <td>35.0</td>\n",
+       "      <td>23.0</td>\n",
+       "      <td>69.0</td>\n",
+       "      <td>37.0</td>\n",
+       "      <td>33.0</td>\n",
+       "      <td>16.0</td>\n",
+       "      <td>35.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>49</th>\n",
+       "      <td>28.0</td>\n",
+       "      <td>27.0</td>\n",
+       "      <td>21.0</td>\n",
+       "      <td>62.0</td>\n",
+       "      <td>34.0</td>\n",
+       "      <td>26.0</td>\n",
+       "      <td>25.0</td>\n",
+       "      <td>8.0</td>\n",
+       "      <td>58.0</td>\n",
+       "      <td>30.0</td>\n",
+       "      <td>49.0</td>\n",
+       "      <td>32.0</td>\n",
+       "      <td>35.0</td>\n",
+       "      <td>41.0</td>\n",
+       "      <td>16.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>52</th>\n",
+       "      <td>26.0</td>\n",
+       "      <td>61.0</td>\n",
+       "      <td>79.0</td>\n",
+       "      <td>65.0</td>\n",
+       "      <td>69.0</td>\n",
+       "      <td>45.0</td>\n",
+       "      <td>41.0</td>\n",
+       "      <td>51.0</td>\n",
+       "      <td>38.0</td>\n",
+       "      <td>35.0</td>\n",
+       "      <td>78.0</td>\n",
+       "      <td>86.0</td>\n",
+       "      <td>59.0</td>\n",
+       "      <td>43.0</td>\n",
+       "      <td>54.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>12</th>\n",
+       "      <th>17</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th rowspan=\"4\" valign=\"top\">13</th>\n",
+       "      <th>1</th>\n",
+       "      <td>22.0</td>\n",
+       "      <td>31.0</td>\n",
+       "      <td>10.0</td>\n",
+       "      <td>17.0</td>\n",
+       "      <td>17.0</td>\n",
+       "      <td>9.0</td>\n",
+       "      <td>10.0</td>\n",
+       "      <td>19.0</td>\n",
+       "      <td>20.0</td>\n",
+       "      <td>22.0</td>\n",
+       "      <td>15.0</td>\n",
+       "      <td>10.0</td>\n",
+       "      <td>8.0</td>\n",
+       "      <td>27.0</td>\n",
+       "      <td>17.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>18.0</td>\n",
+       "      <td>20.0</td>\n",
+       "      <td>15.0</td>\n",
+       "      <td>21.0</td>\n",
+       "      <td>13.0</td>\n",
+       "      <td>31.0</td>\n",
+       "      <td>11.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>14.0</td>\n",
+       "      <td>17.0</td>\n",
+       "      <td>10.0</td>\n",
+       "      <td>32.0</td>\n",
+       "      <td>23.0</td>\n",
+       "      <td>10.0</td>\n",
+       "      <td>21.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>5.0</td>\n",
+       "      <td>20.0</td>\n",
+       "      <td>13.0</td>\n",
+       "      <td>8.0</td>\n",
+       "      <td>26.0</td>\n",
+       "      <td>29.0</td>\n",
+       "      <td>14.0</td>\n",
+       "      <td>11.0</td>\n",
+       "      <td>23.0</td>\n",
+       "      <td>20.0</td>\n",
+       "      <td>23.0</td>\n",
+       "      <td>27.0</td>\n",
+       "      <td>23.0</td>\n",
+       "      <td>11.0</td>\n",
+       "      <td>18.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>53</th>\n",
+       "      <td>17.0</td>\n",
+       "      <td>16.0</td>\n",
+       "      <td>5.0</td>\n",
+       "      <td>7.0</td>\n",
+       "      <td>15.0</td>\n",
+       "      <td>17.0</td>\n",
+       "      <td>7.0</td>\n",
+       "      <td>13.0</td>\n",
+       "      <td>5.0</td>\n",
+       "      <td>10.0</td>\n",
+       "      <td>31.0</td>\n",
+       "      <td>18.0</td>\n",
+       "      <td>11.0</td>\n",
+       "      <td>10.0</td>\n",
+       "      <td>13.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th rowspan=\"4\" valign=\"top\">14</th>\n",
+       "      <th>46</th>\n",
+       "      <td>21.0</td>\n",
+       "      <td>24.0</td>\n",
+       "      <td>13.0</td>\n",
+       "      <td>33.0</td>\n",
+       "      <td>32.0</td>\n",
+       "      <td>28.0</td>\n",
+       "      <td>15.0</td>\n",
+       "      <td>14.0</td>\n",
+       "      <td>22.0</td>\n",
+       "      <td>15.0</td>\n",
+       "      <td>51.0</td>\n",
+       "      <td>43.0</td>\n",
+       "      <td>40.0</td>\n",
+       "      <td>13.0</td>\n",
+       "      <td>25.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>47</th>\n",
+       "      <td>15.0</td>\n",
+       "      <td>22.0</td>\n",
+       "      <td>27.0</td>\n",
+       "      <td>47.0</td>\n",
+       "      <td>31.0</td>\n",
+       "      <td>36.0</td>\n",
+       "      <td>32.0</td>\n",
+       "      <td>17.0</td>\n",
+       "      <td>28.0</td>\n",
+       "      <td>35.0</td>\n",
+       "      <td>66.0</td>\n",
+       "      <td>36.0</td>\n",
+       "      <td>21.0</td>\n",
+       "      <td>35.0</td>\n",
+       "      <td>34.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>48</th>\n",
+       "      <td>2.0</td>\n",
+       "      <td>15.0</td>\n",
+       "      <td>7.0</td>\n",
+       "      <td>15.0</td>\n",
+       "      <td>10.0</td>\n",
+       "      <td>33.0</td>\n",
+       "      <td>20.0</td>\n",
+       "      <td>5.0</td>\n",
+       "      <td>20.0</td>\n",
+       "      <td>14.0</td>\n",
+       "      <td>15.0</td>\n",
+       "      <td>15.0</td>\n",
+       "      <td>23.0</td>\n",
+       "      <td>5.0</td>\n",
+       "      <td>7.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>50</th>\n",
+       "      <td>5.0</td>\n",
+       "      <td>18.0</td>\n",
+       "      <td>8.0</td>\n",
+       "      <td>10.0</td>\n",
+       "      <td>13.0</td>\n",
+       "      <td>7.0</td>\n",
+       "      <td>16.0</td>\n",
+       "      <td>7.0</td>\n",
+       "      <td>15.0</td>\n",
+       "      <td>9.0</td>\n",
+       "      <td>10.0</td>\n",
+       "      <td>13.0</td>\n",
+       "      <td>11.0</td>\n",
+       "      <td>12.0</td>\n",
+       "      <td>5.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th rowspan=\"5\" valign=\"top\">15</th>\n",
+       "      <th>10</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>12</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>13</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>15</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>19</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>16</th>\n",
+       "      <th>18</th>\n",
+       "      <td>11.0</td>\n",
+       "      <td>5.0</td>\n",
+       "      <td>8.0</td>\n",
+       "      <td>9.0</td>\n",
+       "      <td>7.0</td>\n",
+       "      <td>4.0</td>\n",
+       "      <td>5.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>17</th>\n",
+       "      <th>51</th>\n",
+       "      <td>41.0</td>\n",
+       "      <td>50.0</td>\n",
+       "      <td>65.0</td>\n",
+       "      <td>68.0</td>\n",
+       "      <td>70.0</td>\n",
+       "      <td>38.0</td>\n",
+       "      <td>26.0</td>\n",
+       "      <td>40.0</td>\n",
+       "      <td>47.0</td>\n",
+       "      <td>57.0</td>\n",
+       "      <td>73.0</td>\n",
+       "      <td>53.0</td>\n",
+       "      <td>41.0</td>\n",
+       "      <td>41.0</td>\n",
+       "      <td>52.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                       sales                                              \\\n",
+       "date              2017-08-01 2017-08-02 2017-08-03 2017-08-04 2017-08-05   \n",
+       "cluster store_nbr                                                          \n",
+       "1       24              30.0       51.0       26.0       40.0       60.0   \n",
+       "        25              13.0       35.0       17.0       15.0       42.0   \n",
+       "        27              34.0       33.0       28.0       41.0       40.0   \n",
+       "2       37              19.0       41.0       29.0       23.0       27.0   \n",
+       "        42              43.0       31.0       39.0       36.0       36.0   \n",
+       "3       16               0.0        0.0        0.0        0.0        0.0   \n",
+       "        30               0.0        0.0        0.0        0.0        0.0   \n",
+       "        32               0.0        0.0        0.0        0.0        0.0   \n",
+       "        33               0.0        0.0        0.0        0.0        0.0   \n",
+       "        35               0.0        0.0        0.0        0.0        0.0   \n",
+       "        40               0.0        0.0        0.0        0.0        1.0   \n",
+       "        54               0.0        0.0        0.0        0.0        0.0   \n",
+       "4       5                5.0       12.0        6.0       18.0       11.0   \n",
+       "        38              17.0       29.0       19.0       17.0       36.0   \n",
+       "        41              18.0       26.0       17.0       15.0       20.0   \n",
+       "5       44              25.0       42.0       20.0       26.0       48.0   \n",
+       "6       9               15.0        5.0        9.0        2.0        5.0   \n",
+       "        11               2.0        1.0        5.0        5.0        3.0   \n",
+       "        20              14.0       11.0        8.0        5.0        5.0   \n",
+       "        21               8.0        5.0        4.0        1.0        6.0   \n",
+       "        34               4.0        4.0        7.0        8.0       11.0   \n",
+       "        39              13.0        9.0       15.0       25.0       13.0   \n",
+       "7       14               0.0        0.0        0.0        0.0        0.0   \n",
+       "        22               0.0        0.0        0.0        0.0        0.0   \n",
+       "8       3               71.0       79.0       32.0       65.0       65.0   \n",
+       "        7               42.0       21.0       38.0       38.0       67.0   \n",
+       "        8               26.0       44.0       16.0       27.0       53.0   \n",
+       "9       4               19.0       30.0       10.0       28.0       24.0   \n",
+       "        23               0.0        2.0        2.0        1.0        4.0   \n",
+       "10      26               0.0        9.0        5.0       21.0       10.0   \n",
+       "        28               9.0       12.0        5.0        1.0        2.0   \n",
+       "        29               9.0        7.0        3.0        4.0       20.0   \n",
+       "        31               5.0        6.0        2.0        0.0        2.0   \n",
+       "        36              22.0       28.0       35.0       16.0       60.0   \n",
+       "        43               5.0       11.0       17.0       11.0       13.0   \n",
+       "11      45              28.0       36.0       40.0       58.0       73.0   \n",
+       "        49              28.0       27.0       21.0       62.0       34.0   \n",
+       "        52              26.0       61.0       79.0       65.0       69.0   \n",
+       "12      17               0.0        0.0        0.0        0.0        0.0   \n",
+       "13      1               22.0       31.0       10.0       17.0       17.0   \n",
+       "        2               18.0       20.0       15.0       21.0       13.0   \n",
+       "        6                5.0       20.0       13.0        8.0       26.0   \n",
+       "        53              17.0       16.0        5.0        7.0       15.0   \n",
+       "14      46              21.0       24.0       13.0       33.0       32.0   \n",
+       "        47              15.0       22.0       27.0       47.0       31.0   \n",
+       "        48               2.0       15.0        7.0       15.0       10.0   \n",
+       "        50               5.0       18.0        8.0       10.0       13.0   \n",
+       "15      10               0.0        0.0        0.0        0.0        0.0   \n",
+       "        12               0.0        0.0        0.0        0.0        0.0   \n",
+       "        13               0.0        0.0        0.0        0.0        0.0   \n",
+       "        15               0.0        0.0        0.0        0.0        0.0   \n",
+       "        19               0.0        0.0        0.0        0.0        0.0   \n",
+       "16      18              11.0        5.0        8.0        9.0        7.0   \n",
+       "17      51              41.0       50.0       65.0       68.0       70.0   \n",
+       "\n",
+       "                                                                          \\\n",
+       "date              2017-08-06 2017-08-07 2017-08-08 2017-08-09 2017-08-10   \n",
+       "cluster store_nbr                                                          \n",
+       "1       24              32.0       34.0       42.0       52.0       42.0   \n",
+       "        25              18.0       10.0        8.0       44.0       31.0   \n",
+       "        27              60.0       41.0       40.0       22.0       38.0   \n",
+       "2       37              13.0       26.0       14.0       28.0       24.0   \n",
+       "        42              33.0       28.0       33.0       37.0       27.0   \n",
+       "3       16               0.0        0.0        0.0        0.0        0.0   \n",
+       "        30               0.0        0.0        0.0        0.0        0.0   \n",
+       "        32               0.0        0.0        0.0        0.0        0.0   \n",
+       "        33               0.0        0.0        0.0        0.0        0.0   \n",
+       "        35               0.0        0.0        0.0        0.0        0.0   \n",
+       "        40               0.0        0.0        0.0        0.0        0.0   \n",
+       "        54               0.0        0.0        0.0        0.0        0.0   \n",
+       "4       5                9.0        7.0        8.0        6.0        6.0   \n",
+       "        38              21.0        7.0       18.0       15.0       22.0   \n",
+       "        41              22.0        9.0        7.0       20.0        6.0   \n",
+       "5       44              20.0       52.0       16.0       19.0       29.0   \n",
+       "6       9                2.0        6.0        1.0        3.0        6.0   \n",
+       "        11               1.0        1.0        1.0        0.0        0.0   \n",
+       "        20               3.0        1.0        5.0        1.0        4.0   \n",
+       "        21               3.0        4.0        4.0        3.0        0.0   \n",
+       "        34               3.0        6.0        0.0        2.0        3.0   \n",
+       "        39              14.0       14.0       18.0       25.0       14.0   \n",
+       "7       14               0.0        0.0        0.0        0.0        0.0   \n",
+       "        22               0.0        0.0        0.0        0.0        0.0   \n",
+       "8       3               76.0       39.0       37.0       72.0       30.0   \n",
+       "        7               33.0       41.0       55.0       35.0       24.0   \n",
+       "        8               33.0       26.0       33.0       48.0       38.0   \n",
+       "9       4               29.0       10.0       21.0       36.0       22.0   \n",
+       "        23               3.0        0.0        0.0        0.0        7.0   \n",
+       "10      26              16.0       10.0        3.0        2.0       13.0   \n",
+       "        28               4.0        1.0        6.0        8.0        4.0   \n",
+       "        29              11.0        2.0        6.0       14.0        8.0   \n",
+       "        31               9.0       17.0       10.0        9.0        7.0   \n",
+       "        36              33.0        3.0       30.0       18.0       48.0   \n",
+       "        43              13.0        0.0        8.0        9.0        8.0   \n",
+       "11      45              55.0       37.0       15.0       35.0       23.0   \n",
+       "        49              26.0       25.0        8.0       58.0       30.0   \n",
+       "        52              45.0       41.0       51.0       38.0       35.0   \n",
+       "12      17               0.0        0.0        0.0        0.0        0.0   \n",
+       "13      1                9.0       10.0       19.0       20.0       22.0   \n",
+       "        2               31.0       11.0        3.0       14.0       17.0   \n",
+       "        6               29.0       14.0       11.0       23.0       20.0   \n",
+       "        53              17.0        7.0       13.0        5.0       10.0   \n",
+       "14      46              28.0       15.0       14.0       22.0       15.0   \n",
+       "        47              36.0       32.0       17.0       28.0       35.0   \n",
+       "        48              33.0       20.0        5.0       20.0       14.0   \n",
+       "        50               7.0       16.0        7.0       15.0        9.0   \n",
+       "15      10               0.0        0.0        0.0        0.0        0.0   \n",
+       "        12               0.0        0.0        0.0        0.0        0.0   \n",
+       "        13               0.0        0.0        0.0        0.0        0.0   \n",
+       "        15               0.0        0.0        0.0        0.0        0.0   \n",
+       "        19               0.0        0.0        0.0        0.0        0.0   \n",
+       "16      18               4.0        5.0        1.0        2.0        3.0   \n",
+       "17      51              38.0       26.0       40.0       47.0       57.0   \n",
+       "\n",
+       "                                                                          \n",
+       "date              2017-08-11 2017-08-12 2017-08-13 2017-08-14 2017-08-15  \n",
+       "cluster store_nbr                                                         \n",
+       "1       24              34.0       25.0       20.0       40.0       21.0  \n",
+       "        25              69.0       40.0        9.0       13.0       12.0  \n",
+       "        27              69.0       64.0       45.0       36.0       27.0  \n",
+       "2       37              16.0       17.0       16.0        9.0       25.0  \n",
+       "        42              36.0       66.0       26.0       33.0       27.0  \n",
+       "3       16               0.0        0.0        0.0        0.0        0.0  \n",
+       "        30               0.0        0.0        0.0        0.0        0.0  \n",
+       "        32               0.0        0.0        0.0        0.0        0.0  \n",
+       "        33               0.0        0.0        0.0        0.0        0.0  \n",
+       "        35               0.0        0.0        0.0        0.0        0.0  \n",
+       "        40               0.0        0.0        0.0        1.0        0.0  \n",
+       "        54               0.0        0.0        0.0        0.0        0.0  \n",
+       "4       5               16.0       12.0        6.0       15.0        2.0  \n",
+       "        38              14.0       24.0       11.0        8.0       11.0  \n",
+       "        41              45.0       13.0       21.0        2.0        6.0  \n",
+       "5       44              49.0       37.0       28.0       18.0       22.0  \n",
+       "6       9                3.0        4.0        6.0        8.0       11.0  \n",
+       "        11               1.0        6.0        3.0        4.0        5.0  \n",
+       "        20               8.0       10.0       15.0        8.0        4.0  \n",
+       "        21               6.0        5.0        2.0        2.0        3.0  \n",
+       "        34               7.0        5.0        5.0        8.0        2.0  \n",
+       "        39              11.0       11.0        9.0       11.0       15.0  \n",
+       "7       14               0.0        0.0        0.0        0.0        0.0  \n",
+       "        22               0.0        0.0        0.0        0.0        0.0  \n",
+       "8       3               62.0       69.0       42.0       38.0       43.0  \n",
+       "        7               39.0       50.0       28.0       39.0       43.0  \n",
+       "        8               35.0       33.0       39.0       32.0       38.0  \n",
+       "9       4               34.0       16.0       27.0       21.0       14.0  \n",
+       "        23               2.0        6.0        1.0        2.0        0.0  \n",
+       "10      26               3.0        3.0       12.0        5.0        0.0  \n",
+       "        28              11.0       10.0        8.0        9.0        9.0  \n",
+       "        29               4.0        6.0        8.0        1.0        6.0  \n",
+       "        31              12.0       10.0        7.0        7.0        6.0  \n",
+       "        36              56.0       25.0       15.0       17.0       22.0  \n",
+       "        43              23.0        9.0       12.0        3.0        8.0  \n",
+       "11      45              69.0       37.0       33.0       16.0       35.0  \n",
+       "        49              49.0       32.0       35.0       41.0       16.0  \n",
+       "        52              78.0       86.0       59.0       43.0       54.0  \n",
+       "12      17               0.0        0.0        0.0        0.0        0.0  \n",
+       "13      1               15.0       10.0        8.0       27.0       17.0  \n",
+       "        2               10.0       32.0       23.0       10.0       21.0  \n",
+       "        6               23.0       27.0       23.0       11.0       18.0  \n",
+       "        53              31.0       18.0       11.0       10.0       13.0  \n",
+       "14      46              51.0       43.0       40.0       13.0       25.0  \n",
+       "        47              66.0       36.0       21.0       35.0       34.0  \n",
+       "        48              15.0       15.0       23.0        5.0        7.0  \n",
+       "        50              10.0       13.0       11.0       12.0        5.0  \n",
+       "15      10               0.0        0.0        0.0        0.0        0.0  \n",
+       "        12               0.0        0.0        0.0        0.0        0.0  \n",
+       "        13               0.0        0.0        0.0        0.0        0.0  \n",
+       "        15               0.0        0.0        0.0        0.0        0.0  \n",
+       "        19               0.0        0.0        0.0        0.0        0.0  \n",
+       "16      18               1.0        0.0        1.0        0.0        0.0  \n",
+       "17      51              73.0       53.0       41.0       41.0       52.0  "
+      ]
+     },
+     "execution_count": 188,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "yX_test.query('family == \"LAWN AND GARDEN\"').pivot_table(index=['cluster', 'store_nbr'], columns='date', values=['sales']) #.sort_values('cluster', ascending=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 107,
+   "id": "4bd332c6",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1566    52.0\n",
+       "1567    43.0\n",
+       "1568    79.0\n",
+       "1569    53.0\n",
+       "1570    10.0\n",
+       "        ... \n",
+       "1679    78.0\n",
+       "1680    86.0\n",
+       "1681    59.0\n",
+       "1682    43.0\n",
+       "1683    54.0\n",
+       "Name: sales, Length: 118, dtype: float32"
+      ]
+     },
+     "execution_count": 107,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df_train.query('store_nbr == 52 and family == \"LAWN AND GARDEN\"')['sales'].reset_index(drop=True).iloc[1566:]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 232,
+   "id": "7c7277bc",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<AxesSubplot:xlabel='date'>"
+      ]
+     },
+     "execution_count": 232,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABZsAAAEtCAYAAABu0r4SAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8/fFQqAAAACXBIWXMAAAsTAAALEwEAmpwYAAArqElEQVR4nO3de5hlZ10n+u+v77knkJ4A6TDJaEAw3JuLw3EQY44ih0nmURk8gJHDTM4ogowajYIOetAD3tAoJ2NGLkEQA1EgJBGMCXcB07mQEEJI50a6c+t06E7Snb5VveePWtVdl91dtXvXpbv683meemqtd62117uh8j67vvXr36rWWgAAAAAAYBCL5nsCAAAAAAAc/ITNAAAAAAAMTNgMAAAAAMDAhM0AAAAAAAxM2AwAAAAAwMCEzQAAAAAADGzJfE8gSY4//vh28sknz/c0AAAAAADYh2uvvfah1trKXscOiLD55JNPzpo1a+Z7GgAAAAAA7ENV3b23Y9poAAAAAAAwMGEzAAAAAAADEzYDAAAAADCwA6JnMwAAAADAgWrnzp1Zt25dtm3bNt9TmTMrVqzIqlWrsnTp0mlfI2wGAAAAANiHdevW5aijjsrJJ5+cqprv6cy61lo2btyYdevW5ZRTTpn2ddpoAAAAAADsw7Zt2/LEJz7xkAiak6Sq8sQnPrHvSm5hMwAAAADAFA6VoHnU/rxfYTMAAAAAwALy8z//87nkkkvm/L7CZgAAAABgnP9y0TV54wevme9pcJCZMmyuqqdX1Q1jvh6pqrdW1ROq6sqquq37flx3flXV+VW1tqpurKrnz/7bAAAAAABmyj/f8mCu+vaD8z0NxtiyZUte+cpX5jnPeU5OO+20XHzxxfm93/u9vPCFL8xpp52Wc845J621Sddde+21ednLXpYXvOAF+fEf//Hcd999SZLzzz8/z3zmM/PsZz87r3nNa2ZkjkumOqG1dmuS5yZJVS1Osj7JJ5Kcl+Sq1tq7quq8bv83krwiyand14uTXNB9BwAAAAA4qP3up2/Ot+59ZEZf85lPOTr/41U/uM9zPvOZz+QpT3lKLr/88iTJ5s2bc8YZZ+R3fud3kiSvf/3rc9lll+VVr3rV7mt27tyZN7/5zfnUpz6VlStX5uKLL87b3va2vP/978+73vWu3HnnnVm+fHk2bdo0I++j3zYapye5vbV2d5Izk1zUjV+U5Kxu+8wkH2ojvpbk2Kp68kxMFgAAAADgUPSsZz0rV155ZX7jN34jX/rSl3LMMcfkc5/7XF784hfnWc96Vq6++urcfPPN46659dZb881vfjNnnHFGnvvc5+ad73xn1q1blyR59rOfnde+9rX58Ic/nCVLpqxJnpZ+X+U1ST7abZ/QWruv274/yQnd9olJ7hlzzbpu7L4AAAAAABzEpqpAni1Pe9rTct111+WKK67I29/+9px++ul573vfmzVr1uSkk07KO97xjmzbtm3cNa21/OAP/mC++tWvTnq9yy+/PF/84hfz6U9/Or//+7+fm266aeDQedqVzVW1LMl/TPLxicfaSDOQyQ1B9v1651TVmqpas2HDhn4uBQAAAAA4pNx77705/PDD87rXvS7nnnturrvuuiTJ8ccfn8ceeyyXXHLJpGue/vSnZ8OGDbvD5p07d+bmm2/O8PBw7rnnnrz85S/Pu9/97mzevDmPPfbYwHPsJ6p+RZLrWmsPdPsPVNWTW2v3dW0yRjuGr09y0pjrVnVj47TWLkxyYZKsXr26r6AaAAAAAOBQctNNN+Xcc8/NokWLsnTp0lxwwQX55Cc/mdNOOy1PetKT8sIXvnDSNcuWLcsll1ySt7zlLdm8eXN27dqVt771rXna056W173uddm8eXNaa3nLW96SY489duA5Vq8nFPY8servkny2tfaBbv+Pkmwc84DAJ7TWfr2qXpnkl5L8ZEYeDHh+a+1F+3rt1atXtzVr1gzyPgAAAACAGXLyeSMPobvrXa+c55kcGG655ZY84xnPmO9pzLle77uqrm2tre51/rQqm6vqiCRnJPm/xwy/K8nHquqNSe5O8upu/IqMBM1rk2xN8oZ+3gAAAAAAAAefaYXNrbUtSZ44YWxjktN7nNuSvGlGZgcAAAAAwEFh2g8IBAAAAACAvRE2AwAAAABMYbrPvlso9uf9CpsBAAAAAPZhxYoV2bhx4yETOLfWsnHjxqxYsaKv66bVsxkAAAAA4FC1atWqrFu3Lhs2bJjvqcyZFStWZNWqVX1dI2wGAAAAANiHpUuX5pRTTpnvaRzwtNEAAAAAAGBgwmYAAAAAAAYmbAYAAAAAYGDCZgAAAAAABiZsBgAAAABgYMJmAAAAAAAGJmwGAAAAAGBgwmYAAAAAAAYmbAYAAAAAYGDCZgAAAAAABiZsBgAAAABgYMJmAAAAAAAGJmwGAAAAAGBgwmYAAAAAAAYmbAYAAAAAYGDCZgAAAAAABiZsBgAAAABgYNMKm6vq2Kq6pKq+XVW3VNUPVdUTqurKqrqt+35cd25V1flVtbaqbqyq58/uWwAAAAAAYL5Nt7L5z5N8prX2A0mek+SWJOcluaq1dmqSq7r9JHlFklO7r3OSXDCjMwYAAAAA4IAzZdhcVcck+Q9J3pckrbUdrbVNSc5MclF32kVJzuq2z0zyoTbia0mOraonz/C8AQAAAAA4gEynsvmUJBuSfKCqrq+qv66qI5Kc0Fq7rzvn/iQndNsnJrlnzPXrujEAAAAAABao6YTNS5I8P8kFrbXnJdmSPS0zkiSttZak9XPjqjqnqtZU1ZoNGzb0cykAAAAAAAeY6YTN65Ksa619vdu/JCPh8wOj7TG67w92x9cnOWnM9au6sXFaaxe21la31lavXLlyf+cPAAAAAMABYMqwubV2f5J7qurp3dDpSb6V5NIkZ3djZyf5VLd9aZKfqxEvSbJ5TLsNAAAAAAAWoCXTPO/NST5SVcuS3JHkDRkJqj9WVW9McneSV3fnXpHkJ5OsTbK1OxcAAAAAgAVsWmFza+2GJKt7HDq9x7ktyZsGmxYAAAAAAAeT6fRsBgAAAACAfRI2AwAAAAAwMGEzAAAAAAADEzYDAAAAADAwYTMAAAAAAAMTNgMAAAAAMDBhMwAAAAAAAxM2AwAAAAAwMGEzAAAAAAADEzYDAAAAADAwYTMAAAAAAAMTNgMAAAAAMDBhMwAAAAAAAxM2AwAAAAAwMGEzAAAAAAADEzYDAAAAADAwYTMAAAAAAAMTNgMAAAAAMDBhMwAAAAAAAxM2AwAAAAAwMGEzAAAAAAADEzYDAAAAAD211uZ7ChxEhM0AAAAAQE+yZvoxrbC5qu6qqpuq6oaqWtONPaGqrqyq27rvx3XjVVXnV9Xaqrqxqp4/m28AAAAAAJgdsmb60U9l88tba89tra3u9s9LclVr7dQkV3X7SfKKJKd2X+ckuWCmJgsAAAAAzB1tNOjHIG00zkxyUbd9UZKzxox/qI34WpJjq+rJA9wHAAAAAJgHomb6Md2wuSX5p6q6tqrO6cZOaK3d123fn+SEbvvEJPeMuXZdNzZOVZ1TVWuqas2GDRv2Y+oAAAAAwGxS2Ew/lkzzvP+ttba+qv5Nkiur6ttjD7bWWlX19aPXWrswyYVJsnr1aj+2AAAAAHCAaWqb6cO0Kptba+u77w8m+USSFyV5YLQ9Rvf9we709UlOGnP5qm4MAAAAADiIqGymH1OGzVV1RFUdNbqd5H9P8s0klyY5uzvt7CSf6rYvTfJzNeIlSTaPabcBAAAAAMACNJ02Gick+URVjZ7/t621z1TVNUk+VlVvTHJ3kld351+R5CeTrE2yNckbZnzWAAAAAMCsU9lMP6YMm1trdyR5To/xjUlO7zHekrxpRmYHAAAAAMwbPZvpx7R6NgMAAAAAhx6VzfRD2AwAAAAA9CRrph/CZgAAAACgp6a0mT4ImwEAAACAnkTN9EPYDAAAAAD0pLCZfgibAQAAAIDehM30QdgMAAAAAPQ0rLSZPgibAQAAAICeRM30Q9gMAAAAAPTUVDbTB2EzAAAAANCTqJl+CJsBAAAAgJ4UNtMPYTMAAAAA0FNT20wfhM0AAAAAQG+yZvogbAYAAAAAepI10w9hMwAAAADQk57N9EPYDAAAAAD0pGcz/RA2AwAAAAA9qWymH8JmAAAAAKAnWTP9EDYDAAAAAD01pc30QdgMAAAAAPQka6YfwmYAAAAAAAYmbAYAAAAAelLZTD+mHTZX1eKqur6qLuv2T6mqr1fV2qq6uKqWdePLu/213fGTZ2nuAAAAAMAsah4RSB/6qWz+5SS3jNl/d5L3tNa+P8n3kryxG39jku914+/pzgMAAAAADjIqm+nHtMLmqlqV5JVJ/rrbryQ/muSS7pSLkpzVbZ/Z7ac7fnp3PgAAAABwEJE104/pVjb/WZJfTzLc7T8xyabW2q5uf12SE7vtE5PckyTd8c3d+eNU1TlVtaaq1mzYsGH/Zg8AAAAAzJqmtJk+TBk2V9X/keTB1tq1M3nj1tqFrbXVrbXVK1eunMmXBgAAAABmgKiZfiyZxjkvTfIfq+onk6xIcnSSP09ybFUt6aqXVyVZ352/PslJSdZV1ZIkxyTZOOMzBwAAAABmlcJm+jFlZXNr7Tdba6taaycneU2Sq1trr03yuSQ/3Z12dpJPdduXdvvpjl/d1NsDAAAAwEFIrMf0Tbdncy+/keRXqmptRnoyv68bf1+SJ3bjv5LkvMGmCAAAAADMByWk9GM6bTR2a619Psnnu+07kryoxznbkvzMDMwNAAAAAJhHsmb6MUhlMwAAAACwgKlsph/CZgAAAACgp6a2mT4ImwEAAACAnlQ20w9hMwAAAADQ07C0mT4ImwEAAACAnmTN9EPYDAAAAADAwITNAAAAAEBPKpvph7AZAAAAAOipRdrM9AmbAQAAAICeVDbTD2EzAAAAANCTrJl+CJsBAAAAgJ6a0mb6IGwGAAAAAHoSNdMPYTMAAAAA0JPCZvohbAYAAAAA9kLazPQJmwEAAACAnlQ20w9hMwAAAADQk6yZfgibAQAAAICeVDbTD2EzAAAAANBTkzbTB2EzAAAAANCTqJl+CJsBAAAAgJ4UNtMPYTMAAAAA0FNT20wfhM0AAAAAwDhV3cYsZ82X3XhvnvHbn8n2XUOzeyPmxJRhc1WtqKp/rapvVNXNVfW73fgpVfX1qlpbVRdX1bJufHm3v7Y7fvIsvwcAAAAAYAbNUdacP7j8ljy+cygPPbZjlu/EXJhOZfP2JD/aWntOkucm+YmqekmSdyd5T2vt+5N8L8kbu/PfmOR73fh7uvMAAAAAgINEdaXNs92zebh7/UW17/M4OEwZNrcRj3W7S7uvluRHk1zSjV+U5Kxu+8xuP93x06vKjwsAAAAAHCT2VDbPbto83KXZi8SHC8K0ejZX1eKquiHJg0muTHJ7kk2ttV3dKeuSnNhtn5jkniTpjm9O8sQZnDMAAAAAMItGs9+5qmyWNS8M0wqbW2tDrbXnJlmV5EVJfmDQG1fVOVW1pqrWbNiwYdCXAwAAAABmSHW1zbPds7mpbF5QphU2j2qtbUryuSQ/lOTYqlrSHVqVZH23vT7JSUnSHT8mycYer3Vha211a231ypUr92/2AAAAAMDM213ZrI0G0zdl2FxVK6vq2G77sCRnJLklI6HzT3ennZ3kU932pd1+uuNXt9n+qQQAAAAAZsyens2zywMCF5YlU5+SJye5qKoWZySc/lhr7bKq+laSv6uqdya5Psn7uvPfl+RvqmptkoeTvGYW5g0AAAAAzJKao7R5tLK5Im1eCKYMm1trNyZ5Xo/xOzLSv3ni+LYkPzMjswMAAAAA5txoW4vhWW5YsPvlZc0LQl89mwEAAACAhW93YfMcVTazMAibAQAAAIBxqqtsnv2ezcLmhUTYDAAAAACMs6eyeXbD4GFZ84IibAYAAAAAxuvS5tnOgmc7zGZuCZsBAAAAgHHmqmezrHlhETYDAAAAAOOM9mye7dpmPZsXFmEzAAAAADDOaNY821mwns0Li7AZAAAAABhnbuqaWWiEzQAAAADAOKNtNHS5oB/CZgAAAABgnD2VzdJmpk/YDAAAAACMM1c9m1lYhM0AAAAAwARdG415ngUHF2EzAAAAADDOnspmcTPTJ2wGAAAAAMapqU+BSYTNAAAAAMA4ejazP4TNAAAAAMA4tbtns7SZ6RM2AwAAAADjqGxmfwibAQAAAIBxRns2C5vph7AZAAAAABinarSNBkyfsBkAAAAA6KkpbaYPwmYAAAAAYJzdPZvndxocZITNAAAAAMA4tbtp87xOg4PMlGFzVZ1UVZ+rqm9V1c1V9cvd+BOq6sqquq37flw3XlV1flWtraobq+r5s/0mAAAAAICZUxnt2Tx7abMWHQvPdCqbdyX51dbaM5O8JMmbquqZSc5LclVr7dQkV3X7SfKKJKd2X+ckuWDGZw0AAAAAzJrdbTRmMQ+++tsPzt6LMy+mDJtba/e11q7rth9NckuSE5OcmeSi7rSLkpzVbZ+Z5ENtxNeSHFtVT57piQMAAAAAs2Muumg8+Oj2WXx15kNfPZur6uQkz0vy9SQntNbu6w7dn+SEbvvEJPeMuWxdNwYAAAAAHASqK22ezcrmoWFtNBaaaYfNVXVkkr9P8tbW2iNjj7WRBit9/XRU1TlVtaaq1mzYsKGfSwEAAACAWbS7jYaezfRhWmFzVS3NSND8kdbaP3TDD4y2x+i+jzZZWZ/kpDGXr+rGxmmtXdhaW91aW71y5cr9nT8AAAAAMMNG22jMZvGxyuaFZ8qwuUZq5t+X5JbW2p+OOXRpkrO77bOTfGrM+M/ViJck2Tym3QYAAAAAcICrOXhC4JCsecFZMo1zXprk9UluqqoburHfSvKuJB+rqjcmuTvJq7tjVyT5ySRrk2xN8oaZnDAAAAAAMLvm4gGBwyqbF5wpw+bW2pez5+drotN7nN+SvGnAeQEAAAAA82QOCpszpGfzgjPtBwQCAAAAAAvft+9/JN954LEks/sQPz2bFx5hMwAAAACw26v+4su7t7XRoB/CZgAAAABgt51jntynjQb9EDYDAAAAAD2pbKYfwmYAAAAAoKdZ7dmssnnBETYDAAAAAHNuaHi+Z8BMEzYDAAAAAD3NZvHxsMrmBUfYDAAAAAD01Gaxa/OQns0LjrAZAAAAAOhpNouPhc0Lj7AZAAAAAOhpNuNgbTQWHmEzAAAAANCTymb6IWwGAAAAAHqazZ7NKpsXHmEzAAAAANCTymb6IWwGAAAAAJIkn7/1wTm719DwnN2KOSJsBgAAAACSJF+9feO4/TaLpc3aaCw8wmYAAAAAIEny+M6hcfvaaNAPYTMAAAAAkCR5fMeEsHkW7zWksnnBETYDAAAAAEnmtrJ5WGXzgiNsBgAAAACSJNsmhs2zWNs8to3Gv6x9aNbuw9wRNgMAAAAASea4snnMi//CR66bvRsxZ4TNAAAAAECSOe7ZrI3GgiNsBgAAAACSJI/vHJ6zew3JmhccYTMAAAAAkGRyz+bZ5AGBC8+UYXNVvb+qHqyqb44Ze0JVXVlVt3Xfj+vGq6rOr6q1VXVjVT1/NicPAAAAAMyciW00ZpM2GgvPdCqbP5jkJyaMnZfkqtbaqUmu6vaT5BVJTu2+zklywcxMEwAAAACYbRMfEDibhmbz6YPTtH7T49m0dcd8T2PBmDJsbq19McnDE4bPTHJRt31RkrPGjH+ojfhakmOr6skzNFcAAAAAYBbNZdh8ILTReOm7rs4rz//yfE9jwdjfns0ntNbu67bvT3JCt31iknvGnLeuG5ukqs6pqjVVtWbDhg37OQ0AAAAAYKbs2NXfAwJPPu/yvPsz397nOdfe/XA2PLp90vjwPFc27xoaea/rNz0+r/NYSAZ+QGBrrSXp+yejtXZha211a231ypUrB50GAAAAADCHRnsuX/D52/d53k9d8NWc9d6v5JvrN+cvrrot3924deT6eS5svv+RbfM7gQVof8PmB0bbY3TfH+zG1yc5acx5q7oxAAAAAGAB2bpjV5Jk2eKpI8b1mx7Pn191W/7kyu/kw1+/O8nkNhptikrnhx7b3vMBhr/4kWvzsWvu6XHFvt27aSRsPv7IZX1fS2/7GzZfmuTsbvvsJJ8aM/5zNeIlSTaPabcBAAAAACwQo8HvYcsWTzp298Yt2bJ91+7q52RPuDw04fuoXVP0cF79zn/Oay786rix1lquuOn+/Prf39j3/NdvGqmwPvHYw6Y8d3i45dv3P9L3PQ41U4bNVfXRJF9N8vSqWldVb0zyriRnVNVtSX6s20+SK5LckWRtkv+V5BdnZdYAAAAAQF9uWrc5J593eW7f8Ni48f/v82tz2wOP9v16ow8TPLxH2PyyP/p83vCBa7JzaO89oCf2bN41jb4a31i3edz+Y9t3TWeqPa3/3kiv5qdMI2z+qy/ekZ/4sy/lhns27ff9DgVThs2ttZ9trT25tba0tbaqtfa+1trG1trprbVTW2s/1lp7uDu3tdbe1Fr7vtbas1pra2b/LQAAAAAAY7XWJlUO//1165IkX7h1w+6xoeGWP/zMrXnVX355ytfcvmt8C4ute6ls3taF0P9618PZ3j1wcFFNfr2J89s53N/DCZPkocd2JEmWL9kTc37u1gezfddQTvnNy3Pux7+RJNm0dUdOPu/yXHLtut3n3bt5pI3GiqV75r9raLhnO49v3TdS1Xz3xi19z/FQMvADAgEAAACAA8u5l9yY7/utK8aNjQa/y5fuiQRHM+BtO3uHrKNue+DRPP3tn8nlN+7pmLs7bF46Pmx+dNuu3eOjlc1Le/R1HppmZfP3tuzIpd+4t+exDY9uT5KsPGp5kpHq7Td84Jqc+/Eb01ry8WvXZceu4azfNFLF/LuX3rz72p27xofbDz22Pd//tn/MB//lrgnzGs6nu/tv39V/IH4oETYDAAAAwAIztoJ31I4uKJ3OA/0muv+RkSrg3/rETbvHRns2T2yj8ei2nUmSow9bsueeSybfc2K4vGsvLTf+5xduz1s+en3PYxPD5tG2GmPD6df+9dfyyvNHKrcf3UfbjQe693jxhIcN3vnQnmrmHcLmfRI2AwAAAMAhYMfQ3oPfqSxfMhIob3585+72F1t3dBXMy5aMO/eRrrL5qBVLd1c29wq4v/vw1nH7O/fygMAnHLFsr/Pa8OhIQHz8kSNh89iq7SQ5cvmSXHPX98aNjbb5mGj0Pe6YEHqP/d9L2LxvwmYAAAAAOATs6HouL9+PsHms0XYbux8QOKmNxkhl81ErluwJmyfcs1cV894qm0f7Jfc6b7Rn83GHL00y+b2dcPTySa83Wg090ei1d2zYkhf/wT+PGd/z/iYG0YwnbAYAAACABW7n0HA+e/MDSfavsrmXvbfRGKlsPnrF0t09jif2bH54y44ecxwJsU8+7/K8rWvX8dXbN+ZTN4zv1/yXn1ubbTuH8pv/cGNuWr85SbK4ewLhX3/pznHnPumYFTl6xfjK6+HW8rZP3JR133t83PiSxXueYvjAI3sC6cVjnm64faeweV+EzQAAAACwwD3y+M7d2zt2tewaGs7fX7suw/t4KOBURh8QuGJC2Dx6r5HK5pHXnxhwj1Ykjx/bnn+8aeQBhB/5+neTjO+XPOquh7bk0hvuzUf/9Z584Tsbdo9v3rozn7h+/bhz/81RK/KUYw8bN3bjus35yNe/m6/esXHc+MR2G73sGOrdgoMRwmYAAAAAWOC2jek1/N8+fG3+6ot35Fc//o1JVcO9/PFnb83vX/6tSeN7b6Oxp2fzjr1UNj/02ORWFr/28W/kFz5y3e792x54NI9t3znpvBVLF+fOjZND6K/e8dCksU9cvz5HTahsnthq4xPXr8/mrTsnPYSw9Qji3/u52yeNsYewGQAAAAAWuIkPxbv1/keTZPfD/vblLz+3Nt9Yt3nS+OgDApdOCG9HezYfuXzxXns29wqbN20dHyyf8Z4v5rEuuB5rxdLFubtX2Hz7xkljyeSK5cMmVGInyX//2A2Txrbv5WGAtz3waLbvUuHci7AZAAAAABaI1lr+4qrbdu//l4uuSbKnv/KoezeN9Cs+7ohl+32v0TYaF3z+9jy2fVdu3/BYTj7v8nylC33/15fuzL/cPlJtvGxMP+Skd9h8/JGT5/LtLhQfa8XSxbnroa2Txjc9PrkKupeJVdbJSGuOibbuGMq1dz88afyM93wxf3n12mnd61AjbAYAAACABWLDY9vzJ1d+Z/f+P9/yYJJMqsQdDZsntpjox9gA+8Iv3J7T/+QLSZJr795TSTzadmJswDs03LKxR8/m449cPmlsx9Dk6uIVSxflrh6VzdNVPcbuf2TbpLE//qdb81MXfHXc+xn1QI/zSfb/pwkAAAAAOKBs2d67vcO/3jk+ML1380hY2it4ncq2XcM5cvGi3T2bk+Sqbz+4z2vGttH44L/c1TPk7jU2sf1HMlLZvHVCpfalN9ybl37/8VPOfW8mvl6SfPab9ydJz2D7B5509H7fayFT2QwAAAAAC8SW7ZN7HCfJuz/z7Rm7x7Pe8dnc8/DWcQHtzfc+ss9rPn/rhnE9kB/t0Yt5V4/+0eu+9/iksRVLJkeaW3YM5Z++9cA+5zDqrRffMK3zNm4Zqb7u1Td66eL9iekXPpXNAAAAALBA9KrQ3ZexwetHvv7daV3TWvLDf/i5vu6TJF9e+9A+j+8aml7Y3OsBf/24b3N/LTBuWj/54Yj0prIZAAAAABaIrTt6Vzbvzdjg9e2f/OZMT6cvO3v0Z+5lxdLBwuZ+feE7G+b0fgczYTMAAAAALBC9KpuHerSnOBDtnOY8f/fT35rlmbC/hM0AAAAAsED06tm8ccv2eZhJ/7ZNswXIw10vZQ48wmYAAAAAWCB6VTZ//Y6HB3rNIwbskTxdtz7w6Jzch9kjbAYAAACABWJLj57Nb/7o9QO95lErlg50PYcOYTMAAAAALBBbt0+vFUU/jlyxZMZfk4XJTwoAAAAALBC92mgM4gNfuTOPbptcLQ29qGwGAAAAgAVia482GoMQNNMPYTMAAAAALBBbZriyGfoxK2FzVf1EVd1aVWur6rzZuAcAAAAAMN7W7SqRmT8zHjZX1eIk703yiiTPTPKzVfXMmb4PAAAAADDelhluowH9mI0HBL4oydrW2h1JUlV/l+TMJN+ahXsd1O7d9Hj+6eb753saAAAAACwQdz60Zb6nwCFsNsLmE5PcM2Z/XZIXTzypqs5Jck6SPPWpT52FaRz47tiwJe/4tAweAAAAgAPbsYcvzaatO+d7GlM6esWSPDLDDzU86QmH5Z6HH5/R11yoZiNsnpbW2oVJLkyS1atXt/max3x60SlPyPW/fcZ8TwMAAACABeSYw5Zm0aLK5q07c9SKJalKqipJsmX7rixZXFm+ZHGSZHi45dHtu3LMYUvHvcbmx3dm+ZJFGRpuI99by66hlsOWLs6j23blmMOXprW2+3VHtdbSWrJruGXn0HCOWL5k3H2WL1mUXcMtRy7fE0s+sm1njli2JJVk0aIaN3740sVZsnjR7ns9vmMoVcmKpYsnnTM83DLUWrbtHMpRK5aOm9Ou4ZHxZOTaJYsqVZVdQ8N5fMz5w8Nt3BySZNfQcLbuHMrRK5ZmeLhl8+M7c9iyxfv9/89CNhth8/okJ43ZX9WNMcGyJYuybMmy+Z4GAAAAAAvQMYcvnTR2xPLxceCiRTUpaE4yaWxJktFLR193YtA8OlaVLFtUWbZkz+Pi9nafJDl6xdTjo/eaGPKOPWfRosqiVJYuHv+YuqrK0sWTx5NkyeJFOWrx+Hn2Oufo7pxFiyrHHSHP25sZf0BgkmuSnFpVp1TVsiSvSXLpLNwHAAAAAIADxIxXNrfWdlXVLyX5bJLFSd7fWrt5pu8DAAAAAMCBY1Z6NrfWrkhyxWy8NgAAAAAAB57ZaKMBAAAAAMAhRtgMAAAAAMDAhM0AAAAAAAxM2AwAAAAAwMCEzQAAAAAADKxaa/M9h1TVhiR3z/c85snxSR6a70kABz1rCTAo6wgwE6wlwEywlsCB7d+21lb2OnBAhM2Hsqpa01pbPd/zAA5u1hJgUNYRYCZYS4CZYC2Bg5c2GgAAAAAADEzYDAAAAADAwITN8+/C+Z4AsCBYS4BBWUeAmWAtAWaCtQQOUno2AwAAAAAwMJXNAAAAAAAMTNgMAAAAAMDAhM0AAAAAAAxM2DwHqmrxfM8BOPhV1THdd2s3sF+q6knd95rvuQAHp6r6wapaMd/zAA5+VfXSqvq++Z4HMLMEFrOoqlZX1d8k+R0LKLA/qmpRVR1dVZclOT9JWmvD8zwt4CBTVc+rqquS/D9J0jwhGuhTVT27qr6c5J1Jnjjf8wEOXlX1/Kr6pyRXJzlmvucDzCxh8yzowqG/TPJXSa5K8uQk76iqw+d3ZsDBpguWH02yNMmJVfWfE9XNwPTUiPck+VCSi1pr/3W+5wQctN6e5JLW2n9qra1P/CsJoD9VtbSq/irJhRkppPlskh/pjvn9BhYI/zHPgi4cujrJ6a21Dyb5wyQtya75nBdw0PqBJA8l+bMkr62qo1prw37BA6bSVTAfmeT61tqHkqSqvs8vdMB0dYU0/y7JY621P+vGzqiqY5Ms7vZ9JgGmY3mSLyT54dbaZUn+PskzqmqJf70JC4dfNGZIVb2kqp42ut9a+4fW2qaqOiPJmoxUN/9BVT1j3iYJHPDGriVjfnFbm2RHkju7r7Or6qn+GTzQy8TPJEl+NcmLq+q3q+orSf4oyQer6gXzM0PgQDd2HekCoIeS/HBVvbKqPpnk1zJSlXhud47PJEBPEz6XbGmt/W1r7fFuf0mSodbaLn8Ih4XDf8wDqqpjq+ryJFcmeXVVHdGNj4ZE30vyf7bWzkiyJSMh0QnzM1vgQNVrLRnzi9vqJI+01m5OcnOS/5Hkgu6foVnHgSR7/0zSWnskyXuT/HSS30zys0nuS/JTVbVyvuYLHHimWEc+kJG+7+9vrf14kr9O8pKqesm8TRg4YO3t95uuxdfo7zBfSPKfquo4lc2wcAgpBndERvoMvbnb/g/Jnr/ut9bWtNau6M79xyTPS7J1HuYJHNh6riWd7yY5qqouTvLrSa5N8p3W2k4fyoAx9rqOtNbOT/IjrbUvtta2J/lkRv6Q5TMJMNa+Po9cluTkJMd1+2uSPJBk+xzODzh47DUr6VoCLkpyV3fOy+ZrksDMEzbvh6r6uap6WVUd3T0c48IkH0uyLSP/TPUpe7n0BRmpJNK7GehnLTkuycok92fkD1a/kOTp2vIA/Xwmaa19b8ylL0iyLsnQnE4YOOBMYx05MUlaazdmpG3GL1XV8Ulel+S0JBvnaerAAWa6n0uqqrqimeXdpdtGx+dj3sDMKu21pqdb9J6U5G+TDCe5PSN/nfvl1tpD3TkvTfLqJNe01j7cjR2d5MVJ/iAjQdGvtta+M/fvADgQ9LmWrGmt/U03dvyY40cmWdZae3ge3gIwzwb4TLI8yQ8l+eOM/PHbZxI4RO3v55Fu/FeS/Lskpyb57621b83x9IEDyACfSxa31oaq6sNJ1rbW3jEf8wdmnsrmaegWwZbkqCTrW2unZ6Sy8OGM/KUuSdJa+0pG/hnID1TVMVW1outv1pK8s7X2Kr/UwaFrP9aSp3dryRGttYeqanFVLWqtPSZohkPTAJ9JDuvaZ+yIzyRwSBvg88hR3fifZiRk/nFBMxzaBvhccnhrbfRfV/1fgmZYWFQ270NVLc7IQzAWJ7kiydFJfrq1dnZ3fFGSe5P859baF7qxI5O8M8lLkzw1yfNaa/fOw/SBA8SAa8m/T/JvYy2BQ5rPJMCgfB4BZor1BNgXlc17UVUvy8hDuI5LsjYjC+nOJC+vqhclSddj6B3d16hXJvnFJDckeZbFEw5tM7CWfCPWEjik+UwCDMrnEWCmWE+AqSyZ7wkcwIaT/MmYfqnPS3JKkt9JckGSF3R/rftkkh+tqpNba3dlpLH9j7XWvjgvswYONNYSYFDWEWBQ1hFgplhPgH1S2bx31yb5WPfPQ5LkK0me2lr7YJLFVfXm7q91q5IMdYtnWmufsngCY1hLgEFZR4BBWUeAmWI9AfZJ2LwXrbWtrbXtY5rWn5FkQ7f9hiTPqKrLknw0yXXJ7qewAuxmLQEGZR0BBmUdAWaK9QSYijYaU+j+WteSnJDk0m740SS/leS0JHe21tYnSfO0RWAvrCXAoKwjwKCsI8BMsZ4Ae6OyeWrDSZYmeSjJs7u/0P12kuHW2pdHF0+AKVhLgEFZR4BBWUeAmWI9AXoqf2CaWlW9JMm/dF8faK29b56nBByErCXAoKwjwKCsI8BMsZ4AvQibp6GqViV5fZI/ba1tn+/5AAcnawkwKOsIMCjrCDBTrCdAL8JmAAAAAAAGpmczAAAAAAADEzYDAAAAADAwYTMAAAAAAAMTNgMAAAAAMDBhMwAADKCq3lFVv7aP42dV1TPnck4AADAfhM0AADC7zkoibAYAYMGr1tp8zwEAAA4qVfW2JGcneTDJPUmuTbI5yTlJliVZm+T1SZ6b5LLu2OYkP9W9xHuTrEyyNcl/ba19ew6nDwAAs0LYDAAAfaiqFyT5YJIXJ1mS5Lok/zPJB1prG7tz3pnkgdbaX1TVB5Nc1lq7pDt2VZL/1lq7rapenOT/ba396Ny/EwAAmFlL5nsCAABwkPnhJJ9orW1Nkqq6tBs/rQuZj01yZJLPTrywqo5M8u+TfLyqRoeXz/aEAQBgLgibAQBgZnwwyVmttW9U1c8n+ZEe5yxKsqm19ty5mxYAAMwNDwgEAID+fDHJWVV1WFUdleRV3fhRSe6rqqVJXjvm/Ee7Y2mtPZLkzqr6mSSpEc+Zu6kDAMDsETYDAEAfWmvXJbk4yTeS/GOSa7pDv53k60m+kmTsA//+Lsm5VXV9VX1fRoLoN1bVN5LcnOTMuZo7AADMJg8IBAAAAABgYCqbAQAAAAAYmLAZAAAAAICBCZsBAAAAABiYsBkAAAAAgIEJmwEAAAAAGJiwGQAAAACAgQmbAQAAAAAYmLAZAAAAAICB/f9qTFTHIxa4xQAAAABJRU5ErkJggg==\n",
+      "text/plain": [
+       "<Figure size 1800x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "df_train_pvt.unstack().reset_index().rename({0: 'sales'}, axis=1).merge(df_store).query('store_nbr == 52 and family == \"LAWN AND GARDEN\"').plot('date', 'sales', figsize=(25, 5))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 89,
+   "id": "af4b6ed4",
+   "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>level_0</th>\n",
+       "      <th>store_nbr</th>\n",
+       "      <th>family</th>\n",
+       "      <th>date</th>\n",
+       "      <th>sales</th>\n",
+       "      <th>city</th>\n",
+       "      <th>state</th>\n",
+       "      <th>type</th>\n",
+       "      <th>cluster</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>2645564</th>\n",
+       "      <td>sales</td>\n",
+       "      <td>52</td>\n",
+       "      <td>LAWN AND GARDEN</td>\n",
+       "      <td>2013-01-01</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>Manta</td>\n",
+       "      <td>Manabi</td>\n",
+       "      <td>A</td>\n",
+       "      <td>11</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2645565</th>\n",
+       "      <td>sales</td>\n",
+       "      <td>52</td>\n",
+       "      <td>LAWN AND GARDEN</td>\n",
+       "      <td>2013-01-02</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>Manta</td>\n",
+       "      <td>Manabi</td>\n",
+       "      <td>A</td>\n",
+       "      <td>11</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2645566</th>\n",
+       "      <td>sales</td>\n",
+       "      <td>52</td>\n",
+       "      <td>LAWN AND GARDEN</td>\n",
+       "      <td>2013-01-03</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>Manta</td>\n",
+       "      <td>Manabi</td>\n",
+       "      <td>A</td>\n",
+       "      <td>11</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2645567</th>\n",
+       "      <td>sales</td>\n",
+       "      <td>52</td>\n",
+       "      <td>LAWN AND GARDEN</td>\n",
+       "      <td>2013-01-04</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>Manta</td>\n",
+       "      <td>Manabi</td>\n",
+       "      <td>A</td>\n",
+       "      <td>11</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2645568</th>\n",
+       "      <td>sales</td>\n",
+       "      <td>52</td>\n",
+       "      <td>LAWN AND GARDEN</td>\n",
+       "      <td>2013-01-05</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>Manta</td>\n",
+       "      <td>Manabi</td>\n",
+       "      <td>A</td>\n",
+       "      <td>11</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",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2647243</th>\n",
+       "      <td>sales</td>\n",
+       "      <td>52</td>\n",
+       "      <td>LAWN AND GARDEN</td>\n",
+       "      <td>2017-08-11</td>\n",
+       "      <td>78.0</td>\n",
+       "      <td>Manta</td>\n",
+       "      <td>Manabi</td>\n",
+       "      <td>A</td>\n",
+       "      <td>11</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2647244</th>\n",
+       "      <td>sales</td>\n",
+       "      <td>52</td>\n",
+       "      <td>LAWN AND GARDEN</td>\n",
+       "      <td>2017-08-12</td>\n",
+       "      <td>86.0</td>\n",
+       "      <td>Manta</td>\n",
+       "      <td>Manabi</td>\n",
+       "      <td>A</td>\n",
+       "      <td>11</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2647245</th>\n",
+       "      <td>sales</td>\n",
+       "      <td>52</td>\n",
+       "      <td>LAWN AND GARDEN</td>\n",
+       "      <td>2017-08-13</td>\n",
+       "      <td>59.0</td>\n",
+       "      <td>Manta</td>\n",
+       "      <td>Manabi</td>\n",
+       "      <td>A</td>\n",
+       "      <td>11</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2647246</th>\n",
+       "      <td>sales</td>\n",
+       "      <td>52</td>\n",
+       "      <td>LAWN AND GARDEN</td>\n",
+       "      <td>2017-08-14</td>\n",
+       "      <td>43.0</td>\n",
+       "      <td>Manta</td>\n",
+       "      <td>Manabi</td>\n",
+       "      <td>A</td>\n",
+       "      <td>11</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2647247</th>\n",
+       "      <td>sales</td>\n",
+       "      <td>52</td>\n",
+       "      <td>LAWN AND GARDEN</td>\n",
+       "      <td>2017-08-15</td>\n",
+       "      <td>54.0</td>\n",
+       "      <td>Manta</td>\n",
+       "      <td>Manabi</td>\n",
+       "      <td>A</td>\n",
+       "      <td>11</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>1684 rows × 9 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "        level_0  store_nbr           family       date  sales   city   state  \\\n",
+       "2645564   sales         52  LAWN AND GARDEN 2013-01-01    0.0  Manta  Manabi   \n",
+       "2645565   sales         52  LAWN AND GARDEN 2013-01-02    0.0  Manta  Manabi   \n",
+       "2645566   sales         52  LAWN AND GARDEN 2013-01-03    0.0  Manta  Manabi   \n",
+       "2645567   sales         52  LAWN AND GARDEN 2013-01-04    0.0  Manta  Manabi   \n",
+       "2645568   sales         52  LAWN AND GARDEN 2013-01-05    0.0  Manta  Manabi   \n",
+       "...         ...        ...              ...        ...    ...    ...     ...   \n",
+       "2647243   sales         52  LAWN AND GARDEN 2017-08-11   78.0  Manta  Manabi   \n",
+       "2647244   sales         52  LAWN AND GARDEN 2017-08-12   86.0  Manta  Manabi   \n",
+       "2647245   sales         52  LAWN AND GARDEN 2017-08-13   59.0  Manta  Manabi   \n",
+       "2647246   sales         52  LAWN AND GARDEN 2017-08-14   43.0  Manta  Manabi   \n",
+       "2647247   sales         52  LAWN AND GARDEN 2017-08-15   54.0  Manta  Manabi   \n",
+       "\n",
+       "        type  cluster  \n",
+       "2645564    A       11  \n",
+       "2645565    A       11  \n",
+       "2645566    A       11  \n",
+       "2645567    A       11  \n",
+       "2645568    A       11  \n",
+       "...      ...      ...  \n",
+       "2647243    A       11  \n",
+       "2647244    A       11  \n",
+       "2647245    A       11  \n",
+       "2647246    A       11  \n",
+       "2647247    A       11  \n",
+       "\n",
+       "[1684 rows x 9 columns]"
+      ]
+     },
+     "execution_count": 89,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df_train_pvt.unstack().reset_index().rename({0: 'sales'}, axis=1).merge(df_store).query('store_nbr == 52 and family == \"LAWN AND GARDEN\"')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 235,
+   "id": "5dae4d4d",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 6 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "yX_train = df_train.merge(df_store, on='store_nbr')\n",
+    "\n",
+    "# yX_train = df_train_pvt.unstack().reset_index().rename({0: 'sales'}, axis=1).merge(df_store)\n",
+    "\n",
+    "# valid = ~yX_train['sales'].isna()\n",
+    "\n",
+    "# x_train = featurize(yX_train[valid])\n",
+    "x_train = featurize(yX_train)\n",
+    "    \n",
+    "model = cbm.CBM() \n",
+    "# model.fit(x_train, yX_train['sales'][valid])\n",
+    "model.fit(x_train, yX_train['sales']) #[valid])\n",
+    "\n",
+    "model.plot_importance(figsize=(20,10))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 237,
+   "id": "7683bf40",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1.7144530119320085"
+      ]
+     },
+     "execution_count": 237,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "y_pred_train = model.predict(x_train).flatten()\n",
+    "\n",
+    "# mean_squared_log_error(yX_train['sales'][valid], y_pred_train, squared=False)\n",
+    "mean_squared_log_error(yX_train['sales'], y_pred_train, squared=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 240,
+   "id": "058327ed",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# submit\n",
+    "\n",
+    "x_test  = featurize(df_test.drop('type', axis=1).merge(df_store))\n",
+    "df_test['sales'] = model.predict(x_test).flatten()\n",
+    "df_test.set_index('id')[['sales']].to_csv('submission.csv', index=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 173,
+   "id": "731f3a29",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 241,
+   "id": "d4ee3a31",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100%|█████████████████████████████████████████| 736k/736k [00:02<00:00, 262kB/s]\n",
+      "Successfully submitted to Store Sales - Time Series Forecasting"
+     ]
+    }
+   ],
+   "source": [
+    "!kaggle competitions submit -c store-sales-time-series-forecasting -f submission.csv -m v1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fa79bc07",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "39d2ae14",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2.2802909184654947\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x720 with 11 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import cbm\n",
+    "from sklearn.metrics import mean_squared_log_error\n",
+    "\n",
+    "### features\n",
+    "min_date = df_train.date.min()\n",
+    "# _, ma_oil_bins = pd.qcut(df_train['ma_oil'].fillna(0), 5, retbins=True)\n",
+    "\n",
+    "def featurize(df):\n",
+    "   return pd.DataFrame({\n",
+    "        'seasonal' : (df['date'] - min_date).dt.days // 90,\n",
+    "        'store'    : df['store_nbr'], #.astype(\"category\").cat.codes, \n",
+    "        'item'     : df['family'], # .astype(\"category\").cat.codes, \n",
+    "        'date'     : df['date'],\n",
+    "        # NaNs\n",
+    "        # 'store_month'     : df['store_nbr'].astype(str) + '_' + df['date'].dt.month.astype(str),\n",
+    "        # 'item_month'      : df['family'].astype(str)    + '_' + df['date'].dt.month.astype(str),\n",
+    "        'store_X_dayofweek'     : df['store_nbr'].astype(\"category\").cat.codes.astype(str) + '_' + df['date'].dt.dayofweek.astype(str),\n",
+    "        'item_X_dayofweek'      : df['family'].astype(\"category\").cat.codes.astype(str)    + '_' + df['date'].dt.dayofweek.astype(str),\n",
+    "        # 'store_item' : df['family'].astype(str) + '_' + df['store_nbr'].astype(str),\n",
+    "       \n",
+    "        # 'dayofweek': df['date'].dt.dayofweek.values,\n",
+    "        # 'dayofyear': df['date'].dt.dayofyear.values,\n",
+    "        # 'month'    : df['date'].dt.month.values,\n",
+    "        # 'type'     : df['type'].fillna('Unknown').astype('category').cat.codes,\n",
+    "        # 'ma_oil'   : pd.cut(df['ma_oil'].fillna(0), ma_oil_bins, include_lowest=True).cat.codes\n",
+    "        # 'ma_oil'   : df['ma_oil'],\n",
+    "        # 'dofw'     : df['dofw'].fillna('Unknown').astype(\"category\").cat.codes,\n",
+    "    })\n",
+    "\n",
+    "\n",
+    "x_train_df = featurize(df_train)\n",
+    "x_test_df  = featurize(df_test)\n",
+    "\n",
+    "x_train = x_train_df # .to_numpy().astype('uint8')\n",
+    "x_test  = x_test_df #.to_numpy().astype('uint8')\n",
+    "y_train = df_train['sales']\n",
+    "# y_test  = test['sales']\n",
+    "\n",
+    "### training\n",
+    "model = cbm.CBM(metric='l1', min_iterations_early_stopping=40, epsilon_early_stopping=1e-5) #binning = lambda _: 3)\n",
+    "model.fit(x_train, y_train)\n",
+    "\n",
+    "y_pred_train = model.predict(x_train).flatten()\n",
+    "\n",
+    "# test on train error\n",
+    "print(mean_squared_log_error(y_train, y_pred_train))\n",
+    "\n",
+    "#### plotting\n",
+    "model.plot_importance(figsize=(15, 10))\n",
+    "# 2.402653144918136\n",
+    "# 2.3801564352203695\n",
+    "# 2.3021129846711794"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "433c0bf7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# hyperparams = np.array(np.meshgrid(learning_rate_step_size, max_iterations, min_iterations_early_stopping)).T.reshape(-1,3)\n",
+    "def cartesian_product(d):\n",
+    "    index = pd.MultiIndex.from_product(d.values(), names=d.keys())\n",
+    "    return pd.DataFrame(index=index).reset_index()\n",
+    "\n",
+    "hp = cartesian_product({\n",
+    "    'learning_rate_step_size': [1/100, 1/200],\n",
+    "    'max_iterations': [50, 100, 200],\n",
+    "    'min_iterations_early_stopping': [10, 20, 40]    \n",
+    "})\n",
+    "\n",
+    "def train_eval(r):\n",
+    "    model = cbm.CBM(\n",
+    "        learning_rate_step_size = r['learning_rate_step_size'],\n",
+    "        max_iterations = int(r['max_iterations']),\n",
+    "        min_iterations_early_stopping = int(r['min_iterations_early_stopping']))\n",
+    "    \n",
+    "    #**kwargs)\n",
+    "    model.fit(x_train, y_train)\n",
+    "\n",
+    "    y_pred_train = model.predict(x_train).flatten()\n",
+    "\n",
+    "    # test on train error\n",
+    "    metric = mean_squared_log_error(y_train, y_pred_train)\n",
+    "    print(metric)\n",
+    "    \n",
+    "    return metric\n",
+    "\n",
+    "hp['metric'] = hp.apply(lambda r: train_eval(r.to_dict()), axis=1)\n",
+    "hp"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 102,
+   "id": "f43480aa",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2.3241800200198566\n"
+     ]
+    }
+   ],
+   "source": [
+    "model = cbm.CBM(\n",
+    "        learning_rate_step_size = 1/40,\n",
+    "        max_iterations = 100,\n",
+    "        min_iterations_early_stopping = 20\n",
+    ")\n",
+    "    \n",
+    "model.fit(x_train, y_train)\n",
+    "\n",
+    "y_pred_train = model.predict(x_train).flatten()\n",
+    "\n",
+    "# test on train error\n",
+    "print(mean_squared_log_error(y_train, y_pred_train))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "id": "b1891939",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(<Figure size 1152x288 with 1 Axes>, <AxesSubplot:>)"
+      ]
+     },
+     "execution_count": 32,
+     "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": [
+    "from sktime.forecasting.exp_smoothing import ExponentialSmoothing\n",
+    "from sktime.utils.plotting import plot_series\n",
+    "\n",
+    "y_dummy = np.array(model.weights[0])\n",
+    "y_dummy_ts = pd.Series(y_dummy)\n",
+    "\n",
+    "fh = np.arange(-len(y_dummy_ts)+1, # cover the training period\n",
+    "               x_test_df['seasonal'].max() + 2 - len(y_dummy_ts) # cover the test period\n",
+    "              )\n",
+    "\n",
+    "forecaster = ExponentialSmoothing(trend=\"add\", seasonal=\"additive\", sp=5)\n",
+    "forecaster.fit(y_dummy_ts)\n",
+    "y_pred = forecaster.predict(fh=fh)\n",
+    "\n",
+    "plot_series(y_dummy_ts, y_pred)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "id": "1b838b76",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2.329658486692809\n",
+      "2.304544600607954\n"
+     ]
+    }
+   ],
+   "source": [
+    "# model_smooth = cbm.CBM()\n",
+    "\n",
+    "w = model.weights\n",
+    "w[0] = y_pred\n",
+    "model.update(w, model.y_mean)\n",
+    "\n",
+    "y_pred_train_smooth = model.predict(x_train).flatten()\n",
+    "\n",
+    "# test on train error\n",
+    "print(mean_squared_log_error(y_pred_train_smooth, y_train))\n",
+    "print(mean_squared_log_error(y_pred_train, y_train))\n",
+    "\n",
+    "# y_pred_test = model_smooth.predict(x_test).flatten()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "891a4fa8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "y_pred_test = model.predict(x_test).flatten()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "ee509b8d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_sub = pd.read_csv(path + 'sample_submission.csv', index_col='id')\n",
+    "df_sub.sales = y_pred_test\n",
+    "df_sub.to_csv('submission.csv', index=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "a61f0bd0",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "100%|█████████████████████████████████████████| 736k/736k [00:02<00:00, 254kB/s]\n",
+      "Successfully submitted to Store Sales - Time Series Forecasting"
+     ]
+    }
+   ],
+   "source": [
+    "!kaggle competitions submit -c store-sales-time-series-forecasting -f submission.csv -m v1"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/src/cbm.h b/src/cbm.h
index e1a432e..7c87090 100644
--- a/src/cbm.h
+++ b/src/cbm.h
@@ -122,6 +122,8 @@ namespace cbm
 
                     y_sum[j][x_ij] += y[i];
 
+                    y_sum[j][x_ij] += y[i];
+
                     if (enableBinCount)
                         _bin_count[j][x_ij]++;
                 }
@@ -144,7 +146,6 @@ namespace cbm
                 {
                     for (size_t k = 0; k <= x_max[j]; k++)
                     {
-
                         // TODO: check if a bin is empty. might be better to remap/exclude the bins?
                         if (y_sum[j][k])
                         {
@@ -164,6 +165,9 @@ namespace cbm
                             }
                         }
                     }
+
+                    // update_y_hat_sum after every feature
+                    update_y_hat_sum(y_hat, y_hat_sum, x, n_examples, n_features);
                 }
 
                 // prediction
diff --git a/tests/test_sklearn.py b/tests/test_sklearn.py
new file mode 100644
index 0000000..2b73309
--- /dev/null
+++ b/tests/test_sklearn.py
@@ -0,0 +1,53 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+import pytest
+import numpy as np
+import pandas as pd
+from sklearn import linear_model
+from sklearn.metrics import make_scorer, mean_squared_error
+from sklearn.preprocessing import OrdinalEncoder, KBinsDiscretizer
+from sklearn.pipeline import Pipeline, make_pipeline
+from sklearn.compose import ColumnTransformer, make_column_transformer
+from sklearn.model_selection import train_test_split, GridSearchCV
+
+import lightgbm as lgb
+import timeit
+import cbm
+
+def test_nyc_bicycle_sklearn():
+	# read data
+	bic = pd.read_csv(
+		'data/nyc_bb_bicyclist_counts.csv',
+		parse_dates=['Date'])
+
+	X_train = bic.drop('BB_COUNT', axis=1)
+	y_train = bic['BB_COUNT']
+
+	cats = make_column_transformer(
+		# https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.OrdinalEncoder.html
+		# (OrdinalEncoder(dtype='int', handle_unknown='use_encoded_value', unknown_value=-1), # +1 in CBM code
+		# ['store_nbr', 'item_nbr', 'onpromotion', 'family', 'class', 'perishable']),
+	
+		(cbm.DateEncoder('weekday'), ['Date', 'Date']),
+		(cbm.DateEncoder('month'),   ['Date']),
+		(KBinsDiscretizer(n_bins=2, encode='ordinal'), ['HIGH_T', 'LOW_T']),
+		(KBinsDiscretizer(n_bins=5, encode='ordinal'), ['PRECIP']),
+	)
+
+	cbm_model = cbm.CBM()
+	pipeline = make_pipeline(cats, cbm_model)
+
+	cv = GridSearchCV(
+		pipeline,
+		param_grid={'columntransformer__kbinsdiscretizer-1__n_bins': np.arange(2, 15)},
+		scoring=make_scorer(mean_squared_error, squared=False),
+		cv=3
+	)
+
+	cv.fit(X_train, y_train)
+
+	print(cv.cv_results_['mean_test_score'])
+	print(cv.best_params_)
+
+	cbm.CBMExplainer(cv.best_estimator_).plot_importance()
\ No newline at end of file