Repository: tinkoff-ai/etna (language: python)

Issue:
Create notebook for `Auto` and `Tune`
### 🚀 Feature Request

We should show how `Auto` and `Tune` work in our tutorials.

Current script with example isn't shown in our documentation.

### Proposal

Create a notebook with examples of usage of `Auto` and `Tune`. What should be covered:
- What `Tune` class does
  - How it works
    - What kind of hyperparameters are tried, `params_to_tune` method
    - How to write custom `params_to_tune` and check them
    - Runner: 
    - Storage: how to suspend and continue the tuning using storage
  - Example of tuning with some pipeline
  - Analysis
    - `summary`
    - `top_k`
- What `Auto` class does
  - How it works
    - Pool stage
    - Tuning stage
    - How stages are working inside `fit`, how resources are divided between them
  - Example of tuning with default pool

### Test cases

-

### Additional context

Blocked by #1269, #1273.
Create notebook for `Auto` and `Tune`
### 🚀 Feature Request

We should show how `Auto` and `Tune` work in our tutorials.

Current script with example isn't shown in our documentation.

### Proposal

Create a notebook with examples of usage of `Auto` and `Tune`. What should be covered:
- What `Tune` class does
  - How it works
    - What kind of hyperparameters are tried, `params_to_tune` method
    - How to write custom `params_to_tune` and check them
    - Runner: 
    - Storage: how to suspend and continue the tuning using storage
  - Example of tuning with some pipeline
  - Analysis
    - `summary`
    - `top_k`
- What `Auto` class does
  - How it works
    - Pool stage
    - Tuning stage
    - How stages are working inside `fit`, how resources are divided between them
  - Example of tuning with default pool

### Test cases

-

### Additional context

Blocked by #1269, #1273.


Discussion / hints:
It would be greate to visualise perfomance gain after running Auto.fit and highlight greedy part and fine turning part
It would be greate to visualise perfomance gain after running Auto.fit and highlight greedy part and fine turning part

Fix patch:
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 638a23839..53d0aa3cc 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -30,6 +30,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Add default `params_to_tune` for `TreeFeatureSelectionTransform`, `MRMRFeatureSelectionTransform` and `GaleShapleyFeatureSelectionTransform` ([#1250](https://github.com/tinkoff-ai/etna/pull/1250))
 - Add tuning stage into `Auto.fit` ([#1272](https://github.com/tinkoff-ai/etna/pull/1272))
 - Add `params_to_tune` into `Tune` init ([#1282](https://github.com/tinkoff-ai/etna/pull/1282))
+- Skip duplicates during `Tune.fit`, skip duplicates in `top_k`, add AutoML notebook ([#1285](https://github.com/tinkoff-ai/etna/pull/1285))
 ### Fixed
 -
 - Fix `BaseReconciliator` to work on `pandas==1.1.5` ([#1229](https://github.com/tinkoff-ai/etna/pull/1229))
diff --git a/etna/auto/auto.py b/etna/auto/auto.py
index 188b6e4fb..65da9344c 100644
--- a/etna/auto/auto.py
+++ b/etna/auto/auto.py
@@ -104,6 +104,8 @@ def summary(self) -> pd.DataFrame:
     def top_k(self, k: int = 5) -> List[BasePipeline]:
         """Get top k pipelines with the best metric value.
 
+        Only complete and non-duplicate studies are taken into account.
+
         Parameters
         ----------
         k:
@@ -149,7 +151,7 @@ def __init__(
         runner:
             Runner to use for distributed training. By default, :py:class:`~etna.auto.runner.local.LocalRunner` is used.
         storage:
-            Optuna storage to use. By default, sqlite storage is used.
+            Optuna storage to use. By default, sqlite storage is used with name "etna-auto.db".
         metrics:
             List of metrics to compute.
             By default, :py:class:`~etna.metrics.metrics.Sign`, :py:class:`~etna.metrics.metrics.SMAPE`,
@@ -174,7 +176,8 @@ def __init__(
 
     def _top_k(self, summary: pd.DataFrame, k: int) -> List[BasePipeline]:
         metric_name = f"{self.target_metric.name}_{self.metric_aggregation}"
-        df = summary[~summary[metric_name].isna()]
+        df = summary[summary["state"].apply(lambda x: x is optuna.structs.TrialState.COMPLETE)]
+        df = df.drop_duplicates(subset=["hash"])
         df = df.sort_values(
             by=metric_name,
             ascending=(not self.target_metric.greater_is_better),
@@ -184,6 +187,8 @@ def _top_k(self, summary: pd.DataFrame, k: int) -> List[BasePipeline]:
     def top_k(self, k: int = 5) -> List[BasePipeline]:
         """Get top k pipelines with the best metric value.
 
+        Only complete and non-duplicate studies are taken into account.
+
         Parameters
         ----------
         k:
@@ -558,6 +563,14 @@ def _make_tune_summary(self, trials: List[FrozenTrial], pipeline: BasePipeline)
     def summary(self) -> pd.DataFrame:
         """Get Auto trials summary.
 
+        There are columns:
+
+        - hash: hash of the pipeline;
+        - pipeline: pipeline object;
+        - metrics: columns with metrics' values;
+        - state: state of the trial;
+        - study: name of the study in which trial was made.
+
         Returns
         -------
         study_dataframe:
@@ -582,6 +595,8 @@ class Tune(AutoBase):
     """Automatic tuning of custom pipeline.
 
     This class takes given pipelines and tries to optimize its hyperparameters by using `params_to_tune`.
+
+    Trials with duplicate parameters are skipped and previously computed results are returned.
     """
 
     def __init__(
@@ -618,7 +633,7 @@ def __init__(
         runner:
             Runner to use for distributed training. By default, :py:class:`~etna.auto.runner.local.LocalRunner` is used.
         storage:
-            Optuna storage to use. By default, sqlite storage is used.
+            Optuna storage to use. By default, sqlite storage is used with name "etna-auto.db".
         metrics:
             List of metrics to compute.
             By default, :py:class:`~etna.metrics.metrics.Sign`, :py:class:`~etna.metrics.metrics.SMAPE`,
@@ -642,7 +657,7 @@ def __init__(
         )
         self.pipeline = pipeline
         if sampler is None:
-            self.sampler: BaseSampler = TPESampler()
+            self.sampler: BaseSampler = TPESampler(seed=0)
         else:
             self.sampler = sampler
         if params_to_tune is None:
@@ -760,6 +775,18 @@ def objective(
             CategoricalDistribution: lambda x: ("suggest_categorical", {"choices": x.choices}),
         }
 
+        def _find_duplicate_trial(trial: Trial, pipeline: BasePipeline) -> Optional[FrozenTrial]:
+            pipeline_hash = config_hash(pipeline.to_dict())
+
+            for t in trial.study.trials:
+                if t.state != optuna.structs.TrialState.COMPLETE:
+                    continue
+
+                if t.user_attrs.get("hash") == pipeline_hash:
+                    return t
+
+            return None
+
         def _objective(trial: Trial) -> float:
             # using received optuna.distribution objects to call corresponding trial.suggest_xxx
             params_suggested = {}
@@ -771,23 +798,33 @@ def _objective(trial: Trial) -> float:
             # create pipeline instance with the parameters to try
             pipeline_trial_params: BasePipeline = pipeline.set_params(**params_suggested)
 
-            if initializer is not None:
-                initializer(pipeline=pipeline_trial_params)
+            duplicate_trial = _find_duplicate_trial(trial, pipeline_trial_params)
+            if duplicate_trial is not None:
+                for param_name, param_value in duplicate_trial.user_attrs.items():
+                    trial.set_user_attr(param_name, param_value)
 
-            metrics_df, forecast_df, fold_info_df = pipeline_trial_params.backtest(
-                ts, metrics=metrics, **backtest_params
-            )
+                metric_value = trial.user_attrs[f"{target_metric.name}_{metric_aggregation}"]
+                return metric_value
 
-            if callback is not None:
-                callback(metrics_df=metrics_df, forecast_df=forecast_df, fold_info_df=fold_info_df)
+            else:
+                if initializer is not None:
+                    initializer(pipeline=pipeline_trial_params)
 
-            trial.set_user_attr("pipeline", pipeline_trial_params.to_dict())
+                metrics_df, forecast_df, fold_info_df = pipeline_trial_params.backtest(
+                    ts, metrics=metrics, **backtest_params
+                )
 
-            aggregated_metrics = aggregate_metrics_df(metrics_df)
-            for metric in aggregated_metrics:
-                trial.set_user_attr(metric, aggregated_metrics[metric])
+                if callback is not None:
+                    callback(metrics_df=metrics_df, forecast_df=forecast_df, fold_info_df=fold_info_df)
 
-            return aggregated_metrics[f"{target_metric.name}_{metric_aggregation}"]
+                trial.set_user_attr("pipeline", pipeline_trial_params.to_dict())
+                trial.set_user_attr("hash", config_hash(pipeline_trial_params.to_dict()))
+
+                aggregated_metrics = aggregate_metrics_df(metrics_df)
+                for metric in aggregated_metrics:
+                    trial.set_user_attr(metric, aggregated_metrics[metric])
+
+                return aggregated_metrics[f"{target_metric.name}_{metric_aggregation}"]
 
         return _objective
 
@@ -825,6 +862,13 @@ def _summary(self, trials: List[FrozenTrial]) -> List[dict]:
     def summary(self) -> pd.DataFrame:
         """Get trials summary.
 
+        There are columns:
+
+        - hash: hash of the pipeline;
+        - pipeline: pipeline object;
+        - metrics: columns with metrics' values;
+        - state: state of the trial.
+
         Returns
         -------
         study_dataframe:
diff --git a/examples/README.md b/examples/README.md
index 06666eb24..a969c59b6 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -27,20 +27,20 @@ We have prepared a set of tutorials for an easy introduction:
      - Change points plot
      - Interactive change points plot
 
-#### 04. [Outliers](https://github.com/tinkoff-ai/etna/tree/master/examples/outliers.ipynb) 
-- Point outliers
-    - Median method
-    - Density method
-    - Prediction interval method
-    - Histogram method
-- Sequence outliers
-- Interactive visualization
-- Outliers imputation
+#### 04. [Regressors and exogenous data](https://github.com/tinkoff-ai/etna/tree/master/examples/exogenous_data.ipynb)
+- What is regressor? 
+  - What is exogenous data?
+- Dataset
+  - Loading Dataset
+  - EDA
+- Forecast with regressors
 
-#### 05. [Clustering](https://github.com/tinkoff-ai/etna/tree/master/examples/clustering.ipynb) 
-- Clustering pipeline
-- Custom Distance
-- Visualisation
+#### 05. [Custom model and transform](https://github.com/tinkoff-ai/etna/tree/master/examples/exogenous_data.ipynb)
+- What is Transform and how it works 
+- Custom Transform 
+  - Per-segment Custom Transform 
+  - Multi-segment Custom Transform 
+- Custom Model
 
 #### 06. [Deep learning models](https://github.com/tinkoff-ai/etna/tree/master/examples/NN_examples.ipynb)
 - Creating TSDataset  
@@ -54,18 +54,63 @@ We have prepared a set of tutorials for an easy introduction:
 - VotingEnsemble
 - StackingEnsemble
 
-#### 08. [Auto](https://github.com/tinkoff-ai/etna/tree/master/examples/auto.py)
+#### 08. [Outliers](https://github.com/tinkoff-ai/etna/tree/master/examples/outliers.ipynb) 
+- Point outliers
+    - Median method
+    - Density method
+    - Prediction interval method
+    - Histogram method
+- Sequence outliers
+- Interactive visualization
+- Outliers imputation
+
+#### 09. [Forecasting strategies](https://github.com/tinkoff-ai/etna/tree/master/examples/forecasting_strategies.ipynb)
+- Imports and constants 
+- Load dataset 
+- Recursive strategy 
+  - AutoRegressivePipeline 
+- Direct strategy 
+  - Pipeline 
+  - DirectEnsemble 
+  - assemble_pipelines + DirectEnsemble 
+- Summary
+
+#### 10. [Forecast interpretation](https://github.com/tinkoff-ai/etna/tree/master/examples/forecast_interpretation.ipynb)
+- Forecast decomposition 
+  - CatBoost 
+  - SARIMAX 
+  - BATS 
+  - In-sample and out-of-sample decomposition 
+- Accessing target components 
+- Regressors relevance 
+  - Feature relevance 
+  - Components relevance
+
+#### 11. [Clustering](https://github.com/tinkoff-ai/etna/tree/master/examples/clustering.ipynb) 
+- Clustering pipeline
+- Custom Distance
+- Visualisation
+
+#### 12. [AutoML script](https://github.com/tinkoff-ai/etna/tree/master/examples/auto.py)
 - Auto pipeline search
 
-#### 09. Hyperparameter search
+#### 13. [AutoML notebook](https://github.com/tinkoff-ai/etna/tree/master/examples/automl.ipynb)
+- Hyperparameters tuning
+    - How `Tune` works
+    - Example
+- General AutoML
+    - How `Auto` works
+    - Example
+
+#### 14. Hyperparameter search
 - [Optuna](https://github.com/tinkoff-ai/etna/tree/master/examples/optuna)
 - [WandB sweeps](https://github.com/tinkoff-ai/etna/tree/master/examples/wandb/sweeps) example based on [Hydra](https://hydra.cc/)
 
-#### 10. [Inference: using saved pipeline on a new data](https://github.com/tinkoff-ai/etna/tree/master/examples/inference.ipynb) 
+#### 15. [Inference: using saved pipeline on a new data](https://github.com/tinkoff-ai/etna/tree/master/examples/inference.ipynb) 
 - Fitting and saving pipeline
 - Using saved pipeline on a new data
 
-#### 11. [Hierarchical time series](https://github.com/tinkoff-ai/etna/tree/master/examples/hierarchical_pipeline.ipynb)
+#### 16. [Hierarchical time series](https://github.com/tinkoff-ai/etna/tree/master/examples/hierarchical_pipeline.ipynb)
 - Hierarchical time series
 - Hierarchical structure
 - Reconciliation methods
diff --git a/examples/automl.ipynb b/examples/automl.ipynb
new file mode 100644
index 000000000..e01db8f5f
--- /dev/null
+++ b/examples/automl.ipynb
@@ -0,0 +1,2595 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "c855b45e",
+   "metadata": {},
+   "source": [
+    "# AutoML\n",
+    "\n",
+    "<a href=\"https://mybinder.org/v2/gh/tinkoff-ai/etna/master?filepath=examples/automl.ipynb\">\n",
+    "    <img src=\"https://mybinder.org/badge_logo.svg\"  align='left'>\n",
+    "</a>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bca01a6c",
+   "metadata": {},
+   "source": [
+    "This notebooks covers AutoML utilities of ETNA library.\n",
+    "\n",
+    "- [Hyperparameters tuning](#chapter_1)\n",
+    "    - [How `Tune` works](#section_1_1)\n",
+    "    - [Example](#section_1_2)\n",
+    "- [General AutoML](#chapter_2)\n",
+    "    - [How `Auto` works](#section_2_1)\n",
+    "    - [Example](#section_2_2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "6f70e872",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import warnings\n",
+    "\n",
+    "\n",
+    "warnings.filterwarnings(\"ignore\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "e50060f6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "HORIZON = 14"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "33ad7417",
+   "metadata": {},
+   "source": [
+    "## 1. Hyperparameters tuning <a class=\"anchor\" id=\"chapter_1\"></a>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4542c8eb",
+   "metadata": {},
+   "source": [
+    "It is a common task to tune hyperparameters of existing pipeline to improve its quality. For this purpose there is an `etna.auto.Tune` class, which is responsible for creating [optuna](https://github.com/optuna/optuna) study to solve this problem.\n",
+    "\n",
+    "In the next sections we will see how it works and how to use it for your particular problems."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "73194640",
+   "metadata": {},
+   "source": [
+    "### 1.1 How `Tune` works <a class=\"anchor\" id=\"section_1_1\"></a>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c7777ea3",
+   "metadata": {},
+   "source": [
+    "During init `Tune` accepts `pipeline`, its tuning parameters (`params_to_tune`), optimization metric (`target_metric`), parameters of backtest and parameters of optuna study.\n",
+    "\n",
+    "In `fit` the optuna study is created. During each trial the sample of parameters is generated from `params_to_tune` and applied to `pipeline`. After that, the new pipeline is checked in backtest and target metric is returned to optuna framework."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "09e6cb8e",
+   "metadata": {},
+   "source": [
+    "Let's look closer at `params_to_tune` parameter. It expects dictionary with parameter names and its distributions. But how this parameter names should be chosen?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5d7a777a",
+   "metadata": {},
+   "source": [
+    "#### 1.1.1 `set_params`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cc05b85b",
+   "metadata": {},
+   "source": [
+    "We are going to make a little detour to explain the `set_params` method, which is supported by ETNA pipelines, models and transforms. Given a dictionary with parameters it allows to create from existing object a new one with changed parameters."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b291efa4",
+   "metadata": {},
+   "source": [
+    "First, we define some objects for our future examples."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "9d6893b8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from etna.pipeline import Pipeline\n",
+    "from etna.models import LinearPerSegmentModel\n",
+    "from etna.transforms import LagTransform\n",
+    "from etna.transforms import DateFlagsTransform\n",
+    "\n",
+    "\n",
+    "model = LinearPerSegmentModel()\n",
+    "transforms = [\n",
+    "    LagTransform(in_column=\"target\", lags=list(range(HORIZON, HORIZON + 10)), out_column=\"target_lag\"),\n",
+    "    DateFlagsTransform(out_column=\"date_flags\"),\n",
+    "]\n",
+    "pipeline = Pipeline(model=model, transforms=transforms, horizon=HORIZON)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "01a57e5c",
+   "metadata": {},
+   "source": [
+    "Let's look at simple example, when we want to change `fit_intercept` parameter of the `model`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "32c51370",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'fit_intercept': True,\n",
+       " 'kwargs': {},\n",
+       " '_target_': 'etna.models.linear.LinearPerSegmentModel'}"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model.to_dict()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "60bc963f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'fit_intercept': False,\n",
+       " 'kwargs': {},\n",
+       " '_target_': 'etna.models.linear.LinearPerSegmentModel'}"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "new_model_params = {\"fit_intercept\": False}\n",
+    "new_model = model.set_params(**new_model_params)\n",
+    "new_model.to_dict()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "383931c2",
+   "metadata": {},
+   "source": [
+    "Great! On the next step we want to change the `fit_intercept` of `model` inside the `pipeline`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "7ff49f9a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'model': {'fit_intercept': True,\n",
+       "  'kwargs': {},\n",
+       "  '_target_': 'etna.models.linear.LinearPerSegmentModel'},\n",
+       " 'transforms': [{'in_column': 'target',\n",
+       "   'lags': [14, 15, 16, 17, 18, 19, 20, 21, 22, 23],\n",
+       "   'out_column': 'target_lag',\n",
+       "   '_target_': 'etna.transforms.math.lags.LagTransform'},\n",
+       "  {'day_number_in_week': True,\n",
+       "   'day_number_in_month': True,\n",
+       "   'day_number_in_year': False,\n",
+       "   'week_number_in_month': False,\n",
+       "   'week_number_in_year': False,\n",
+       "   'month_number_in_year': False,\n",
+       "   'season_number': False,\n",
+       "   'year_number': False,\n",
+       "   'is_weekend': True,\n",
+       "   'special_days_in_week': (),\n",
+       "   'special_days_in_month': (),\n",
+       "   'out_column': 'date_flags',\n",
+       "   '_target_': 'etna.transforms.timestamp.date_flags.DateFlagsTransform'}],\n",
+       " 'horizon': 14,\n",
+       " '_target_': 'etna.pipeline.pipeline.Pipeline'}"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "pipeline.to_dict()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "497662b6",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'model': {'fit_intercept': False,\n",
+       "  'kwargs': {},\n",
+       "  '_target_': 'etna.models.linear.LinearPerSegmentModel'},\n",
+       " 'transforms': [{'in_column': 'target',\n",
+       "   'lags': [14, 15, 16, 17, 18, 19, 20, 21, 22, 23],\n",
+       "   'out_column': 'target_lag',\n",
+       "   '_target_': 'etna.transforms.math.lags.LagTransform'},\n",
+       "  {'day_number_in_week': True,\n",
+       "   'day_number_in_month': True,\n",
+       "   'day_number_in_year': False,\n",
+       "   'week_number_in_month': False,\n",
+       "   'week_number_in_year': False,\n",
+       "   'month_number_in_year': False,\n",
+       "   'season_number': False,\n",
+       "   'year_number': False,\n",
+       "   'is_weekend': True,\n",
+       "   'special_days_in_week': (),\n",
+       "   'special_days_in_month': (),\n",
+       "   'out_column': 'date_flags',\n",
+       "   '_target_': 'etna.transforms.timestamp.date_flags.DateFlagsTransform'}],\n",
+       " 'horizon': 14,\n",
+       " '_target_': 'etna.pipeline.pipeline.Pipeline'}"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "new_pipeline_params = {\"model.fit_intercept\": False}\n",
+    "new_pipeline = pipeline.set_params(**new_pipeline_params)\n",
+    "new_pipeline.to_dict()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8eba262b",
+   "metadata": {},
+   "source": [
+    "Ok, it looks like we managed to do this. On the last step we are going to change `is_weekend` flag of `DateFlagsTransform` inside our `pipeline`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "28a1ac00",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'model': {'fit_intercept': True,\n",
+       "  'kwargs': {},\n",
+       "  '_target_': 'etna.models.linear.LinearPerSegmentModel'},\n",
+       " 'transforms': [{'in_column': 'target',\n",
+       "   'lags': [14, 15, 16, 17, 18, 19, 20, 21, 22, 23],\n",
+       "   'out_column': 'target_lag',\n",
+       "   '_target_': 'etna.transforms.math.lags.LagTransform'},\n",
+       "  {'day_number_in_week': True,\n",
+       "   'day_number_in_month': True,\n",
+       "   'day_number_in_year': False,\n",
+       "   'week_number_in_month': False,\n",
+       "   'week_number_in_year': False,\n",
+       "   'month_number_in_year': False,\n",
+       "   'season_number': False,\n",
+       "   'year_number': False,\n",
+       "   'is_weekend': False,\n",
+       "   'special_days_in_week': (),\n",
+       "   'special_days_in_month': (),\n",
+       "   'out_column': 'date_flags',\n",
+       "   '_target_': 'etna.transforms.timestamp.date_flags.DateFlagsTransform'}],\n",
+       " 'horizon': 14,\n",
+       " '_target_': 'etna.pipeline.pipeline.Pipeline'}"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "new_pipeline_params = {\"transforms.1.is_weekend\": False}\n",
+    "new_pipeline = pipeline.set_params(**new_pipeline_params)\n",
+    "new_pipeline.to_dict()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "50c2bf0d",
+   "metadata": {},
+   "source": [
+    "As we can see, we managed to do this."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4deb8b8b",
+   "metadata": {},
+   "source": [
+    "#### 1.1.2 `params_to_tune`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8c732645",
+   "metadata": {},
+   "source": [
+    "Let's get back to our initial question about `params_to_tune`. In our optuna study we are going to sample each parameter value from its distribution and pass it into `pipeline.set_params` method. So, the keys for `params_to_tune` should be a valid for `set_params` method."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f6a39f16",
+   "metadata": {},
+   "source": [
+    "For example, something like this will be valid for our `pipeline` defined above:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "4dab566f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import optuna\n",
+    "\n",
+    "\n",
+    "example_params_to_tune = {\n",
+    "    \"model.fit_intercept\": optuna.distributions.CategoricalDistribution([False, True]),\n",
+    "    \"transforms.0.is_weekend\": optuna.distributions.CategoricalDistribution([False, True]),\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a0c81b84",
+   "metadata": {},
+   "source": [
+    "There are some good news: it isn't necessary for our users to define `params_to_tune`, because we have a default grid for many of our classes. The default grid is available by calling `params_to_tune` method on pipeline, model or transform. Let's check our `pipeline`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "b493dace",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'model.fit_intercept': CategoricalDistribution(choices=(False, True)),\n",
+       " 'transforms.1.day_number_in_week': CategoricalDistribution(choices=(False, True)),\n",
+       " 'transforms.1.day_number_in_month': CategoricalDistribution(choices=(False, True)),\n",
+       " 'transforms.1.day_number_in_year': CategoricalDistribution(choices=(False, True)),\n",
+       " 'transforms.1.week_number_in_month': CategoricalDistribution(choices=(False, True)),\n",
+       " 'transforms.1.week_number_in_year': CategoricalDistribution(choices=(False, True)),\n",
+       " 'transforms.1.month_number_in_year': CategoricalDistribution(choices=(False, True)),\n",
+       " 'transforms.1.season_number': CategoricalDistribution(choices=(False, True)),\n",
+       " 'transforms.1.year_number': CategoricalDistribution(choices=(False, True)),\n",
+       " 'transforms.1.is_weekend': CategoricalDistribution(choices=(False, True))}"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "pipeline.params_to_tune()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "554c5af2",
+   "metadata": {},
+   "source": [
+    "Now we are ready to use it in practice."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "df2102f8",
+   "metadata": {},
+   "source": [
+    "### 1.2 Example <a class=\"anchor\" id=\"section_1_2\"></a>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "535c0b18",
+   "metadata": {},
+   "source": [
+    "#### 1.2.1 Loading data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9352eeb4",
+   "metadata": {},
+   "source": [
+    "Let's start by loading example data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "1b4e7705",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "\n",
+    "from etna.datasets import TSDataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "0041c9ab",
+   "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>timestamp</th>\n",
+       "      <th>segment</th>\n",
+       "      <th>target</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>2019-01-01</td>\n",
+       "      <td>segment_a</td>\n",
+       "      <td>170</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>2019-01-02</td>\n",
+       "      <td>segment_a</td>\n",
+       "      <td>243</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>2019-01-03</td>\n",
+       "      <td>segment_a</td>\n",
+       "      <td>267</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>2019-01-04</td>\n",
+       "      <td>segment_a</td>\n",
+       "      <td>287</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>2019-01-05</td>\n",
+       "      <td>segment_a</td>\n",
+       "      <td>279</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "    timestamp    segment  target\n",
+       "0  2019-01-01  segment_a     170\n",
+       "1  2019-01-02  segment_a     243\n",
+       "2  2019-01-03  segment_a     267\n",
+       "3  2019-01-04  segment_a     287\n",
+       "4  2019-01-05  segment_a     279"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df = pd.read_csv(\"data/example_dataset.csv\")\n",
+    "df.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "8996f93a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 2000x1000 with 4 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from etna.datasets import TSDataset\n",
+    "\n",
+    "df = TSDataset.to_dataset(df)\n",
+    "full_ts = TSDataset(df, freq=\"D\")\n",
+    "full_ts.plot()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b1f95a3e",
+   "metadata": {},
+   "source": [
+    "Let's divide current dataset into train and validation parts. We will use validation part later to check final results."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "d72c9f19",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ts, _ = full_ts.train_test_split(test_size=HORIZON * 5)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3efade22",
+   "metadata": {},
+   "source": [
+    "#### 1.2.2 Running `Tune`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1338a41f",
+   "metadata": {},
+   "source": [
+    "We are going to define our `Tune` object:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "5e4efd0c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from etna.metrics import SMAPE\n",
+    "from etna.auto import Tune\n",
+    "\n",
+    "\n",
+    "tune = Tune(pipeline=pipeline, target_metric=SMAPE(), horizon=HORIZON, backtest_params=dict(n_folds=5))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6d61b949",
+   "metadata": {},
+   "source": [
+    "We used mostly default parameters for this example. But for your own experiments you might want to also set up other parameters. \n",
+    "\n",
+    "For example, parameter `runner` allows you to run tuning in parallel on a local machine, and parameter `storage` makes it possible to store optuna results on a dedicated remote server.\n",
+    "\n",
+    "For a full list of parameters we advise you to check our documentation."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "50779a99",
+   "metadata": {},
+   "source": [
+    "Let's hide the logs of optuna, there are too many of them for a notebook."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "1d6650e3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "optuna.logging.set_verbosity(optuna.logging.CRITICAL)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "032a192b",
+   "metadata": {},
+   "source": [
+    "Let's run the tuning"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "49c86098",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%%capture\n",
+    "best_pipeline = tune.fit(ts=ts, n_trials=20)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b644325b",
+   "metadata": {},
+   "source": [
+    "Command `%%capture` just hides the output."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "218a48f2",
+   "metadata": {},
+   "source": [
+    "#### 1.2.3 Analysis"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1fd09627",
+   "metadata": {},
+   "source": [
+    "In the last section dedicated to `Tune` we will look at methods for result analysis."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3faf63b9",
+   "metadata": {},
+   "source": [
+    "First of all there is `summary` method that shows us the results of optuna trials."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "14525b55",
+   "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>pipeline</th>\n",
+       "      <th>hash</th>\n",
+       "      <th>Sign_median</th>\n",
+       "      <th>Sign_mean</th>\n",
+       "      <th>Sign_std</th>\n",
+       "      <th>Sign_percentile_5</th>\n",
+       "      <th>Sign_percentile_25</th>\n",
+       "      <th>Sign_percentile_75</th>\n",
+       "      <th>Sign_percentile_95</th>\n",
+       "      <th>SMAPE_median</th>\n",
+       "      <th>...</th>\n",
+       "      <th>MSE_percentile_75</th>\n",
+       "      <th>MSE_percentile_95</th>\n",
+       "      <th>MedAE_median</th>\n",
+       "      <th>MedAE_mean</th>\n",
+       "      <th>MedAE_std</th>\n",
+       "      <th>MedAE_percentile_5</th>\n",
+       "      <th>MedAE_percentile_25</th>\n",
+       "      <th>MedAE_percentile_75</th>\n",
+       "      <th>MedAE_percentile_95</th>\n",
+       "      <th>state</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>f4f02e1d5f60b8f322a4a8a622dd1c1e</td>\n",
+       "      <td>-0.500000</td>\n",
+       "      <td>-0.478571</td>\n",
+       "      <td>0.205204</td>\n",
+       "      <td>-0.672857</td>\n",
+       "      <td>-0.621429</td>\n",
+       "      <td>-0.357143</td>\n",
+       "      <td>-0.254286</td>\n",
+       "      <td>5.806429</td>\n",
+       "      <td>...</td>\n",
+       "      <td>2220.282484</td>\n",
+       "      <td>2953.865443</td>\n",
+       "      <td>21.000232</td>\n",
+       "      <td>22.334611</td>\n",
+       "      <td>8.070926</td>\n",
+       "      <td>14.955846</td>\n",
+       "      <td>18.861388</td>\n",
+       "      <td>24.473455</td>\n",
+       "      <td>31.581505</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>3d7b7af16d71a36f3b935f69e113e22d</td>\n",
+       "      <td>-0.457143</td>\n",
+       "      <td>-0.485714</td>\n",
+       "      <td>0.242437</td>\n",
+       "      <td>-0.745714</td>\n",
+       "      <td>-0.642857</td>\n",
+       "      <td>-0.300000</td>\n",
+       "      <td>-0.265714</td>\n",
+       "      <td>5.856039</td>\n",
+       "      <td>...</td>\n",
+       "      <td>2644.982216</td>\n",
+       "      <td>3294.855806</td>\n",
+       "      <td>22.762122</td>\n",
+       "      <td>23.389796</td>\n",
+       "      <td>8.482028</td>\n",
+       "      <td>14.897792</td>\n",
+       "      <td>19.344439</td>\n",
+       "      <td>26.807479</td>\n",
+       "      <td>32.760543</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>7c7932114268832a5458acfecfb453fc</td>\n",
+       "      <td>-0.200000</td>\n",
+       "      <td>-0.271429</td>\n",
+       "      <td>0.264447</td>\n",
+       "      <td>-0.581429</td>\n",
+       "      <td>-0.392857</td>\n",
+       "      <td>-0.078571</td>\n",
+       "      <td>-0.061429</td>\n",
+       "      <td>5.693983</td>\n",
+       "      <td>...</td>\n",
+       "      <td>3457.757162</td>\n",
+       "      <td>4209.624737</td>\n",
+       "      <td>22.572681</td>\n",
+       "      <td>23.336111</td>\n",
+       "      <td>12.049564</td>\n",
+       "      <td>11.235277</td>\n",
+       "      <td>18.503043</td>\n",
+       "      <td>27.405750</td>\n",
+       "      <td>36.505748</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>b7ac5f7fcf9c8959626befe263a9d561</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>-0.085714</td>\n",
+       "      <td>0.211248</td>\n",
+       "      <td>-0.340000</td>\n",
+       "      <td>-0.100000</td>\n",
+       "      <td>0.014286</td>\n",
+       "      <td>0.048571</td>\n",
+       "      <td>7.881275</td>\n",
+       "      <td>...</td>\n",
+       "      <td>5039.841145</td>\n",
+       "      <td>5665.228696</td>\n",
+       "      <td>35.976862</td>\n",
+       "      <td>33.937644</td>\n",
+       "      <td>17.252826</td>\n",
+       "      <td>14.444379</td>\n",
+       "      <td>27.282228</td>\n",
+       "      <td>42.632278</td>\n",
+       "      <td>50.576005</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>e928929f89156d88ef49e28abaf55847</td>\n",
+       "      <td>-0.414286</td>\n",
+       "      <td>-0.421429</td>\n",
+       "      <td>0.207840</td>\n",
+       "      <td>-0.620000</td>\n",
+       "      <td>-0.585714</td>\n",
+       "      <td>-0.250000</td>\n",
+       "      <td>-0.232857</td>\n",
+       "      <td>6.032319</td>\n",
+       "      <td>...</td>\n",
+       "      <td>3091.962427</td>\n",
+       "      <td>3181.592755</td>\n",
+       "      <td>23.166650</td>\n",
+       "      <td>25.265089</td>\n",
+       "      <td>13.224461</td>\n",
+       "      <td>13.001779</td>\n",
+       "      <td>18.666844</td>\n",
+       "      <td>29.764896</td>\n",
+       "      <td>40.466215</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>3b4311d41fcaab7307235ea23b6d4599</td>\n",
+       "      <td>-0.400000</td>\n",
+       "      <td>-0.385714</td>\n",
+       "      <td>0.396927</td>\n",
+       "      <td>-0.788571</td>\n",
+       "      <td>-0.514286</td>\n",
+       "      <td>-0.271429</td>\n",
+       "      <td>0.037143</td>\n",
+       "      <td>6.653462</td>\n",
+       "      <td>...</td>\n",
+       "      <td>3800.976318</td>\n",
+       "      <td>4837.444681</td>\n",
+       "      <td>35.792514</td>\n",
+       "      <td>32.276030</td>\n",
+       "      <td>16.296588</td>\n",
+       "      <td>13.499409</td>\n",
+       "      <td>24.106508</td>\n",
+       "      <td>43.962035</td>\n",
+       "      <td>46.129572</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>74065ebc11c81bed6a9819d026c7cd84</td>\n",
+       "      <td>-0.442857</td>\n",
+       "      <td>-0.435714</td>\n",
+       "      <td>0.246196</td>\n",
+       "      <td>-0.672857</td>\n",
+       "      <td>-0.621429</td>\n",
+       "      <td>-0.257143</td>\n",
+       "      <td>-0.188571</td>\n",
+       "      <td>5.739626</td>\n",
+       "      <td>...</td>\n",
+       "      <td>2933.246064</td>\n",
+       "      <td>4802.299660</td>\n",
+       "      <td>27.304852</td>\n",
+       "      <td>24.936077</td>\n",
+       "      <td>8.294963</td>\n",
+       "      <td>15.108636</td>\n",
+       "      <td>21.478207</td>\n",
+       "      <td>30.762723</td>\n",
+       "      <td>31.447233</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7</th>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>b0d0420255c6117045f8254bf8f377a0</td>\n",
+       "      <td>-0.442857</td>\n",
+       "      <td>-0.464286</td>\n",
+       "      <td>0.260167</td>\n",
+       "      <td>-0.725714</td>\n",
+       "      <td>-0.657143</td>\n",
+       "      <td>-0.250000</td>\n",
+       "      <td>-0.232857</td>\n",
+       "      <td>6.042134</td>\n",
+       "      <td>...</td>\n",
+       "      <td>2682.735922</td>\n",
+       "      <td>3688.168155</td>\n",
+       "      <td>28.393903</td>\n",
+       "      <td>25.819143</td>\n",
+       "      <td>8.652993</td>\n",
+       "      <td>15.618131</td>\n",
+       "      <td>21.989342</td>\n",
+       "      <td>32.223704</td>\n",
+       "      <td>32.415490</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8</th>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>25dcd8bb095f87a1ffc499fa6a83ef5d</td>\n",
+       "      <td>-0.457143</td>\n",
+       "      <td>-0.457143</td>\n",
+       "      <td>0.265986</td>\n",
+       "      <td>-0.705714</td>\n",
+       "      <td>-0.671429</td>\n",
+       "      <td>-0.242857</td>\n",
+       "      <td>-0.208571</td>\n",
+       "      <td>5.869280</td>\n",
+       "      <td>...</td>\n",
+       "      <td>3098.567787</td>\n",
+       "      <td>3154.538337</td>\n",
+       "      <td>22.380642</td>\n",
+       "      <td>24.289797</td>\n",
+       "      <td>11.998603</td>\n",
+       "      <td>13.252341</td>\n",
+       "      <td>19.168974</td>\n",
+       "      <td>27.501465</td>\n",
+       "      <td>38.000072</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>9</th>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>3f1ca1759261598081fa3bb2f32fe0ac</td>\n",
+       "      <td>-0.414286</td>\n",
+       "      <td>-0.435714</td>\n",
+       "      <td>0.292654</td>\n",
+       "      <td>-0.725714</td>\n",
+       "      <td>-0.657143</td>\n",
+       "      <td>-0.192857</td>\n",
+       "      <td>-0.175714</td>\n",
+       "      <td>6.608191</td>\n",
+       "      <td>...</td>\n",
+       "      <td>3044.388978</td>\n",
+       "      <td>3611.477391</td>\n",
+       "      <td>23.750327</td>\n",
+       "      <td>26.488927</td>\n",
+       "      <td>13.825791</td>\n",
+       "      <td>14.242057</td>\n",
+       "      <td>20.027917</td>\n",
+       "      <td>30.211337</td>\n",
+       "      <td>42.569838</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>10</th>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>8363309e454e72993f86f10c7fc7c137</td>\n",
+       "      <td>-0.157143</td>\n",
+       "      <td>-0.185714</td>\n",
+       "      <td>0.226779</td>\n",
+       "      <td>-0.431429</td>\n",
+       "      <td>-0.328571</td>\n",
+       "      <td>-0.014286</td>\n",
+       "      <td>0.020000</td>\n",
+       "      <td>5.974832</td>\n",
+       "      <td>...</td>\n",
+       "      <td>2902.306123</td>\n",
+       "      <td>3526.513999</td>\n",
+       "      <td>17.027383</td>\n",
+       "      <td>21.682156</td>\n",
+       "      <td>15.988286</td>\n",
+       "      <td>9.110958</td>\n",
+       "      <td>11.100846</td>\n",
+       "      <td>27.608693</td>\n",
+       "      <td>40.770037</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>11</th>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>8363309e454e72993f86f10c7fc7c137</td>\n",
+       "      <td>-0.157143</td>\n",
+       "      <td>-0.185714</td>\n",
+       "      <td>0.226779</td>\n",
+       "      <td>-0.431429</td>\n",
+       "      <td>-0.328571</td>\n",
+       "      <td>-0.014286</td>\n",
+       "      <td>0.020000</td>\n",
+       "      <td>5.974832</td>\n",
+       "      <td>...</td>\n",
+       "      <td>2902.306123</td>\n",
+       "      <td>3526.513999</td>\n",
+       "      <td>17.027383</td>\n",
+       "      <td>21.682156</td>\n",
+       "      <td>15.988286</td>\n",
+       "      <td>9.110958</td>\n",
+       "      <td>11.100846</td>\n",
+       "      <td>27.608693</td>\n",
+       "      <td>40.770037</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>12</th>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>8363309e454e72993f86f10c7fc7c137</td>\n",
+       "      <td>-0.157143</td>\n",
+       "      <td>-0.185714</td>\n",
+       "      <td>0.226779</td>\n",
+       "      <td>-0.431429</td>\n",
+       "      <td>-0.328571</td>\n",
+       "      <td>-0.014286</td>\n",
+       "      <td>0.020000</td>\n",
+       "      <td>5.974832</td>\n",
+       "      <td>...</td>\n",
+       "      <td>2902.306123</td>\n",
+       "      <td>3526.513999</td>\n",
+       "      <td>17.027383</td>\n",
+       "      <td>21.682156</td>\n",
+       "      <td>15.988286</td>\n",
+       "      <td>9.110958</td>\n",
+       "      <td>11.100846</td>\n",
+       "      <td>27.608693</td>\n",
+       "      <td>40.770037</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>13</th>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>8363309e454e72993f86f10c7fc7c137</td>\n",
+       "      <td>-0.157143</td>\n",
+       "      <td>-0.185714</td>\n",
+       "      <td>0.226779</td>\n",
+       "      <td>-0.431429</td>\n",
+       "      <td>-0.328571</td>\n",
+       "      <td>-0.014286</td>\n",
+       "      <td>0.020000</td>\n",
+       "      <td>5.974832</td>\n",
+       "      <td>...</td>\n",
+       "      <td>2902.306123</td>\n",
+       "      <td>3526.513999</td>\n",
+       "      <td>17.027383</td>\n",
+       "      <td>21.682156</td>\n",
+       "      <td>15.988286</td>\n",
+       "      <td>9.110958</td>\n",
+       "      <td>11.100846</td>\n",
+       "      <td>27.608693</td>\n",
+       "      <td>40.770037</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>14</th>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>8363309e454e72993f86f10c7fc7c137</td>\n",
+       "      <td>-0.157143</td>\n",
+       "      <td>-0.185714</td>\n",
+       "      <td>0.226779</td>\n",
+       "      <td>-0.431429</td>\n",
+       "      <td>-0.328571</td>\n",
+       "      <td>-0.014286</td>\n",
+       "      <td>0.020000</td>\n",
+       "      <td>5.974832</td>\n",
+       "      <td>...</td>\n",
+       "      <td>2902.306123</td>\n",
+       "      <td>3526.513999</td>\n",
+       "      <td>17.027383</td>\n",
+       "      <td>21.682156</td>\n",
+       "      <td>15.988286</td>\n",
+       "      <td>9.110958</td>\n",
+       "      <td>11.100846</td>\n",
+       "      <td>27.608693</td>\n",
+       "      <td>40.770037</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>15</th>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>8363309e454e72993f86f10c7fc7c137</td>\n",
+       "      <td>-0.157143</td>\n",
+       "      <td>-0.185714</td>\n",
+       "      <td>0.226779</td>\n",
+       "      <td>-0.431429</td>\n",
+       "      <td>-0.328571</td>\n",
+       "      <td>-0.014286</td>\n",
+       "      <td>0.020000</td>\n",
+       "      <td>5.974832</td>\n",
+       "      <td>...</td>\n",
+       "      <td>2902.306123</td>\n",
+       "      <td>3526.513999</td>\n",
+       "      <td>17.027383</td>\n",
+       "      <td>21.682156</td>\n",
+       "      <td>15.988286</td>\n",
+       "      <td>9.110958</td>\n",
+       "      <td>11.100846</td>\n",
+       "      <td>27.608693</td>\n",
+       "      <td>40.770037</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>16</th>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>8363309e454e72993f86f10c7fc7c137</td>\n",
+       "      <td>-0.157143</td>\n",
+       "      <td>-0.185714</td>\n",
+       "      <td>0.226779</td>\n",
+       "      <td>-0.431429</td>\n",
+       "      <td>-0.328571</td>\n",
+       "      <td>-0.014286</td>\n",
+       "      <td>0.020000</td>\n",
+       "      <td>5.974832</td>\n",
+       "      <td>...</td>\n",
+       "      <td>2902.306123</td>\n",
+       "      <td>3526.513999</td>\n",
+       "      <td>17.027383</td>\n",
+       "      <td>21.682156</td>\n",
+       "      <td>15.988286</td>\n",
+       "      <td>9.110958</td>\n",
+       "      <td>11.100846</td>\n",
+       "      <td>27.608693</td>\n",
+       "      <td>40.770037</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>17</th>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>8363309e454e72993f86f10c7fc7c137</td>\n",
+       "      <td>-0.157143</td>\n",
+       "      <td>-0.185714</td>\n",
+       "      <td>0.226779</td>\n",
+       "      <td>-0.431429</td>\n",
+       "      <td>-0.328571</td>\n",
+       "      <td>-0.014286</td>\n",
+       "      <td>0.020000</td>\n",
+       "      <td>5.974832</td>\n",
+       "      <td>...</td>\n",
+       "      <td>2902.306123</td>\n",
+       "      <td>3526.513999</td>\n",
+       "      <td>17.027383</td>\n",
+       "      <td>21.682156</td>\n",
+       "      <td>15.988286</td>\n",
+       "      <td>9.110958</td>\n",
+       "      <td>11.100846</td>\n",
+       "      <td>27.608693</td>\n",
+       "      <td>40.770037</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>18</th>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>6f595f4f43b323804c04d4cea49c169b</td>\n",
+       "      <td>-0.414286</td>\n",
+       "      <td>-0.435714</td>\n",
+       "      <td>0.325242</td>\n",
+       "      <td>-0.754286</td>\n",
+       "      <td>-0.685714</td>\n",
+       "      <td>-0.164286</td>\n",
+       "      <td>-0.147143</td>\n",
+       "      <td>5.657316</td>\n",
+       "      <td>...</td>\n",
+       "      <td>2247.347025</td>\n",
+       "      <td>2681.501259</td>\n",
+       "      <td>21.624614</td>\n",
+       "      <td>22.111993</td>\n",
+       "      <td>7.952462</td>\n",
+       "      <td>14.197890</td>\n",
+       "      <td>17.080865</td>\n",
+       "      <td>26.655742</td>\n",
+       "      <td>30.708428</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>19</th>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>8363309e454e72993f86f10c7fc7c137</td>\n",
+       "      <td>-0.157143</td>\n",
+       "      <td>-0.185714</td>\n",
+       "      <td>0.226779</td>\n",
+       "      <td>-0.431429</td>\n",
+       "      <td>-0.328571</td>\n",
+       "      <td>-0.014286</td>\n",
+       "      <td>0.020000</td>\n",
+       "      <td>5.974832</td>\n",
+       "      <td>...</td>\n",
+       "      <td>2902.306123</td>\n",
+       "      <td>3526.513999</td>\n",
+       "      <td>17.027383</td>\n",
+       "      <td>21.682156</td>\n",
+       "      <td>15.988286</td>\n",
+       "      <td>9.110958</td>\n",
+       "      <td>11.100846</td>\n",
+       "      <td>27.608693</td>\n",
+       "      <td>40.770037</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>20 rows × 38 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                                             pipeline  \\\n",
+       "0   Pipeline(model = LinearPerSegmentModel(fit_int...   \n",
+       "1   Pipeline(model = LinearPerSegmentModel(fit_int...   \n",
+       "2   Pipeline(model = LinearPerSegmentModel(fit_int...   \n",
+       "3   Pipeline(model = LinearPerSegmentModel(fit_int...   \n",
+       "4   Pipeline(model = LinearPerSegmentModel(fit_int...   \n",
+       "5   Pipeline(model = LinearPerSegmentModel(fit_int...   \n",
+       "6   Pipeline(model = LinearPerSegmentModel(fit_int...   \n",
+       "7   Pipeline(model = LinearPerSegmentModel(fit_int...   \n",
+       "8   Pipeline(model = LinearPerSegmentModel(fit_int...   \n",
+       "9   Pipeline(model = LinearPerSegmentModel(fit_int...   \n",
+       "10  Pipeline(model = LinearPerSegmentModel(fit_int...   \n",
+       "11  Pipeline(model = LinearPerSegmentModel(fit_int...   \n",
+       "12  Pipeline(model = LinearPerSegmentModel(fit_int...   \n",
+       "13  Pipeline(model = LinearPerSegmentModel(fit_int...   \n",
+       "14  Pipeline(model = LinearPerSegmentModel(fit_int...   \n",
+       "15  Pipeline(model = LinearPerSegmentModel(fit_int...   \n",
+       "16  Pipeline(model = LinearPerSegmentModel(fit_int...   \n",
+       "17  Pipeline(model = LinearPerSegmentModel(fit_int...   \n",
+       "18  Pipeline(model = LinearPerSegmentModel(fit_int...   \n",
+       "19  Pipeline(model = LinearPerSegmentModel(fit_int...   \n",
+       "\n",
+       "                                hash  Sign_median  Sign_mean  Sign_std  \\\n",
+       "0   f4f02e1d5f60b8f322a4a8a622dd1c1e    -0.500000  -0.478571  0.205204   \n",
+       "1   3d7b7af16d71a36f3b935f69e113e22d    -0.457143  -0.485714  0.242437   \n",
+       "2   7c7932114268832a5458acfecfb453fc    -0.200000  -0.271429  0.264447   \n",
+       "3   b7ac5f7fcf9c8959626befe263a9d561     0.000000  -0.085714  0.211248   \n",
+       "4   e928929f89156d88ef49e28abaf55847    -0.414286  -0.421429  0.207840   \n",
+       "5   3b4311d41fcaab7307235ea23b6d4599    -0.400000  -0.385714  0.396927   \n",
+       "6   74065ebc11c81bed6a9819d026c7cd84    -0.442857  -0.435714  0.246196   \n",
+       "7   b0d0420255c6117045f8254bf8f377a0    -0.442857  -0.464286  0.260167   \n",
+       "8   25dcd8bb095f87a1ffc499fa6a83ef5d    -0.457143  -0.457143  0.265986   \n",
+       "9   3f1ca1759261598081fa3bb2f32fe0ac    -0.414286  -0.435714  0.292654   \n",
+       "10  8363309e454e72993f86f10c7fc7c137    -0.157143  -0.185714  0.226779   \n",
+       "11  8363309e454e72993f86f10c7fc7c137    -0.157143  -0.185714  0.226779   \n",
+       "12  8363309e454e72993f86f10c7fc7c137    -0.157143  -0.185714  0.226779   \n",
+       "13  8363309e454e72993f86f10c7fc7c137    -0.157143  -0.185714  0.226779   \n",
+       "14  8363309e454e72993f86f10c7fc7c137    -0.157143  -0.185714  0.226779   \n",
+       "15  8363309e454e72993f86f10c7fc7c137    -0.157143  -0.185714  0.226779   \n",
+       "16  8363309e454e72993f86f10c7fc7c137    -0.157143  -0.185714  0.226779   \n",
+       "17  8363309e454e72993f86f10c7fc7c137    -0.157143  -0.185714  0.226779   \n",
+       "18  6f595f4f43b323804c04d4cea49c169b    -0.414286  -0.435714  0.325242   \n",
+       "19  8363309e454e72993f86f10c7fc7c137    -0.157143  -0.185714  0.226779   \n",
+       "\n",
+       "    Sign_percentile_5  Sign_percentile_25  Sign_percentile_75  \\\n",
+       "0           -0.672857           -0.621429           -0.357143   \n",
+       "1           -0.745714           -0.642857           -0.300000   \n",
+       "2           -0.581429           -0.392857           -0.078571   \n",
+       "3           -0.340000           -0.100000            0.014286   \n",
+       "4           -0.620000           -0.585714           -0.250000   \n",
+       "5           -0.788571           -0.514286           -0.271429   \n",
+       "6           -0.672857           -0.621429           -0.257143   \n",
+       "7           -0.725714           -0.657143           -0.250000   \n",
+       "8           -0.705714           -0.671429           -0.242857   \n",
+       "9           -0.725714           -0.657143           -0.192857   \n",
+       "10          -0.431429           -0.328571           -0.014286   \n",
+       "11          -0.431429           -0.328571           -0.014286   \n",
+       "12          -0.431429           -0.328571           -0.014286   \n",
+       "13          -0.431429           -0.328571           -0.014286   \n",
+       "14          -0.431429           -0.328571           -0.014286   \n",
+       "15          -0.431429           -0.328571           -0.014286   \n",
+       "16          -0.431429           -0.328571           -0.014286   \n",
+       "17          -0.431429           -0.328571           -0.014286   \n",
+       "18          -0.754286           -0.685714           -0.164286   \n",
+       "19          -0.431429           -0.328571           -0.014286   \n",
+       "\n",
+       "    Sign_percentile_95  SMAPE_median  ...  MSE_percentile_75  \\\n",
+       "0            -0.254286      5.806429  ...        2220.282484   \n",
+       "1            -0.265714      5.856039  ...        2644.982216   \n",
+       "2            -0.061429      5.693983  ...        3457.757162   \n",
+       "3             0.048571      7.881275  ...        5039.841145   \n",
+       "4            -0.232857      6.032319  ...        3091.962427   \n",
+       "5             0.037143      6.653462  ...        3800.976318   \n",
+       "6            -0.188571      5.739626  ...        2933.246064   \n",
+       "7            -0.232857      6.042134  ...        2682.735922   \n",
+       "8            -0.208571      5.869280  ...        3098.567787   \n",
+       "9            -0.175714      6.608191  ...        3044.388978   \n",
+       "10            0.020000      5.974832  ...        2902.306123   \n",
+       "11            0.020000      5.974832  ...        2902.306123   \n",
+       "12            0.020000      5.974832  ...        2902.306123   \n",
+       "13            0.020000      5.974832  ...        2902.306123   \n",
+       "14            0.020000      5.974832  ...        2902.306123   \n",
+       "15            0.020000      5.974832  ...        2902.306123   \n",
+       "16            0.020000      5.974832  ...        2902.306123   \n",
+       "17            0.020000      5.974832  ...        2902.306123   \n",
+       "18           -0.147143      5.657316  ...        2247.347025   \n",
+       "19            0.020000      5.974832  ...        2902.306123   \n",
+       "\n",
+       "    MSE_percentile_95  MedAE_median  MedAE_mean  MedAE_std  \\\n",
+       "0         2953.865443     21.000232   22.334611   8.070926   \n",
+       "1         3294.855806     22.762122   23.389796   8.482028   \n",
+       "2         4209.624737     22.572681   23.336111  12.049564   \n",
+       "3         5665.228696     35.976862   33.937644  17.252826   \n",
+       "4         3181.592755     23.166650   25.265089  13.224461   \n",
+       "5         4837.444681     35.792514   32.276030  16.296588   \n",
+       "6         4802.299660     27.304852   24.936077   8.294963   \n",
+       "7         3688.168155     28.393903   25.819143   8.652993   \n",
+       "8         3154.538337     22.380642   24.289797  11.998603   \n",
+       "9         3611.477391     23.750327   26.488927  13.825791   \n",
+       "10        3526.513999     17.027383   21.682156  15.988286   \n",
+       "11        3526.513999     17.027383   21.682156  15.988286   \n",
+       "12        3526.513999     17.027383   21.682156  15.988286   \n",
+       "13        3526.513999     17.027383   21.682156  15.988286   \n",
+       "14        3526.513999     17.027383   21.682156  15.988286   \n",
+       "15        3526.513999     17.027383   21.682156  15.988286   \n",
+       "16        3526.513999     17.027383   21.682156  15.988286   \n",
+       "17        3526.513999     17.027383   21.682156  15.988286   \n",
+       "18        2681.501259     21.624614   22.111993   7.952462   \n",
+       "19        3526.513999     17.027383   21.682156  15.988286   \n",
+       "\n",
+       "    MedAE_percentile_5  MedAE_percentile_25  MedAE_percentile_75  \\\n",
+       "0            14.955846            18.861388            24.473455   \n",
+       "1            14.897792            19.344439            26.807479   \n",
+       "2            11.235277            18.503043            27.405750   \n",
+       "3            14.444379            27.282228            42.632278   \n",
+       "4            13.001779            18.666844            29.764896   \n",
+       "5            13.499409            24.106508            43.962035   \n",
+       "6            15.108636            21.478207            30.762723   \n",
+       "7            15.618131            21.989342            32.223704   \n",
+       "8            13.252341            19.168974            27.501465   \n",
+       "9            14.242057            20.027917            30.211337   \n",
+       "10            9.110958            11.100846            27.608693   \n",
+       "11            9.110958            11.100846            27.608693   \n",
+       "12            9.110958            11.100846            27.608693   \n",
+       "13            9.110958            11.100846            27.608693   \n",
+       "14            9.110958            11.100846            27.608693   \n",
+       "15            9.110958            11.100846            27.608693   \n",
+       "16            9.110958            11.100846            27.608693   \n",
+       "17            9.110958            11.100846            27.608693   \n",
+       "18           14.197890            17.080865            26.655742   \n",
+       "19            9.110958            11.100846            27.608693   \n",
+       "\n",
+       "    MedAE_percentile_95                state  \n",
+       "0             31.581505  TrialState.COMPLETE  \n",
+       "1             32.760543  TrialState.COMPLETE  \n",
+       "2             36.505748  TrialState.COMPLETE  \n",
+       "3             50.576005  TrialState.COMPLETE  \n",
+       "4             40.466215  TrialState.COMPLETE  \n",
+       "5             46.129572  TrialState.COMPLETE  \n",
+       "6             31.447233  TrialState.COMPLETE  \n",
+       "7             32.415490  TrialState.COMPLETE  \n",
+       "8             38.000072  TrialState.COMPLETE  \n",
+       "9             42.569838  TrialState.COMPLETE  \n",
+       "10            40.770037  TrialState.COMPLETE  \n",
+       "11            40.770037  TrialState.COMPLETE  \n",
+       "12            40.770037  TrialState.COMPLETE  \n",
+       "13            40.770037  TrialState.COMPLETE  \n",
+       "14            40.770037  TrialState.COMPLETE  \n",
+       "15            40.770037  TrialState.COMPLETE  \n",
+       "16            40.770037  TrialState.COMPLETE  \n",
+       "17            40.770037  TrialState.COMPLETE  \n",
+       "18            30.708428  TrialState.COMPLETE  \n",
+       "19            40.770037  TrialState.COMPLETE  \n",
+       "\n",
+       "[20 rows x 38 columns]"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "tune.summary()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cf987a2e",
+   "metadata": {},
+   "source": [
+    "Let's show only the columns we are interested in."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "b650bfc7",
+   "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>hash</th>\n",
+       "      <th>pipeline</th>\n",
+       "      <th>SMAPE_mean</th>\n",
+       "      <th>state</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>19</th>\n",
+       "      <td>8363309e454e72993f86f10c7fc7c137</td>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>8.556535</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>17</th>\n",
+       "      <td>8363309e454e72993f86f10c7fc7c137</td>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>8.556535</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>16</th>\n",
+       "      <td>8363309e454e72993f86f10c7fc7c137</td>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>8.556535</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>15</th>\n",
+       "      <td>8363309e454e72993f86f10c7fc7c137</td>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>8.556535</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>14</th>\n",
+       "      <td>8363309e454e72993f86f10c7fc7c137</td>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>8.556535</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>13</th>\n",
+       "      <td>8363309e454e72993f86f10c7fc7c137</td>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>8.556535</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>12</th>\n",
+       "      <td>8363309e454e72993f86f10c7fc7c137</td>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>8.556535</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>10</th>\n",
+       "      <td>8363309e454e72993f86f10c7fc7c137</td>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>8.556535</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>11</th>\n",
+       "      <td>8363309e454e72993f86f10c7fc7c137</td>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>8.556535</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>7c7932114268832a5458acfecfb453fc</td>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>9.210183</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8</th>\n",
+       "      <td>25dcd8bb095f87a1ffc499fa6a83ef5d</td>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>9.943658</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>e928929f89156d88ef49e28abaf55847</td>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>9.946866</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>f4f02e1d5f60b8f322a4a8a622dd1c1e</td>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>9.957781</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>18</th>\n",
+       "      <td>6f595f4f43b323804c04d4cea49c169b</td>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>10.061742</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>3d7b7af16d71a36f3b935f69e113e22d</td>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>10.306909</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>9</th>\n",
+       "      <td>3f1ca1759261598081fa3bb2f32fe0ac</td>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>10.554444</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>3b4311d41fcaab7307235ea23b6d4599</td>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>10.756703</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>74065ebc11c81bed6a9819d026c7cd84</td>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>10.917164</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>b7ac5f7fcf9c8959626befe263a9d561</td>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>11.255320</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7</th>\n",
+       "      <td>b0d0420255c6117045f8254bf8f377a0</td>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>11.478760</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                                hash  \\\n",
+       "19  8363309e454e72993f86f10c7fc7c137   \n",
+       "17  8363309e454e72993f86f10c7fc7c137   \n",
+       "16  8363309e454e72993f86f10c7fc7c137   \n",
+       "15  8363309e454e72993f86f10c7fc7c137   \n",
+       "14  8363309e454e72993f86f10c7fc7c137   \n",
+       "13  8363309e454e72993f86f10c7fc7c137   \n",
+       "12  8363309e454e72993f86f10c7fc7c137   \n",
+       "10  8363309e454e72993f86f10c7fc7c137   \n",
+       "11  8363309e454e72993f86f10c7fc7c137   \n",
+       "2   7c7932114268832a5458acfecfb453fc   \n",
+       "8   25dcd8bb095f87a1ffc499fa6a83ef5d   \n",
+       "4   e928929f89156d88ef49e28abaf55847   \n",
+       "0   f4f02e1d5f60b8f322a4a8a622dd1c1e   \n",
+       "18  6f595f4f43b323804c04d4cea49c169b   \n",
+       "1   3d7b7af16d71a36f3b935f69e113e22d   \n",
+       "9   3f1ca1759261598081fa3bb2f32fe0ac   \n",
+       "5   3b4311d41fcaab7307235ea23b6d4599   \n",
+       "6   74065ebc11c81bed6a9819d026c7cd84   \n",
+       "3   b7ac5f7fcf9c8959626befe263a9d561   \n",
+       "7   b0d0420255c6117045f8254bf8f377a0   \n",
+       "\n",
+       "                                             pipeline  SMAPE_mean  \\\n",
+       "19  Pipeline(model = LinearPerSegmentModel(fit_int...    8.556535   \n",
+       "17  Pipeline(model = LinearPerSegmentModel(fit_int...    8.556535   \n",
+       "16  Pipeline(model = LinearPerSegmentModel(fit_int...    8.556535   \n",
+       "15  Pipeline(model = LinearPerSegmentModel(fit_int...    8.556535   \n",
+       "14  Pipeline(model = LinearPerSegmentModel(fit_int...    8.556535   \n",
+       "13  Pipeline(model = LinearPerSegmentModel(fit_int...    8.556535   \n",
+       "12  Pipeline(model = LinearPerSegmentModel(fit_int...    8.556535   \n",
+       "10  Pipeline(model = LinearPerSegmentModel(fit_int...    8.556535   \n",
+       "11  Pipeline(model = LinearPerSegmentModel(fit_int...    8.556535   \n",
+       "2   Pipeline(model = LinearPerSegmentModel(fit_int...    9.210183   \n",
+       "8   Pipeline(model = LinearPerSegmentModel(fit_int...    9.943658   \n",
+       "4   Pipeline(model = LinearPerSegmentModel(fit_int...    9.946866   \n",
+       "0   Pipeline(model = LinearPerSegmentModel(fit_int...    9.957781   \n",
+       "18  Pipeline(model = LinearPerSegmentModel(fit_int...   10.061742   \n",
+       "1   Pipeline(model = LinearPerSegmentModel(fit_int...   10.306909   \n",
+       "9   Pipeline(model = LinearPerSegmentModel(fit_int...   10.554444   \n",
+       "5   Pipeline(model = LinearPerSegmentModel(fit_int...   10.756703   \n",
+       "6   Pipeline(model = LinearPerSegmentModel(fit_int...   10.917164   \n",
+       "3   Pipeline(model = LinearPerSegmentModel(fit_int...   11.255320   \n",
+       "7   Pipeline(model = LinearPerSegmentModel(fit_int...   11.478760   \n",
+       "\n",
+       "                  state  \n",
+       "19  TrialState.COMPLETE  \n",
+       "17  TrialState.COMPLETE  \n",
+       "16  TrialState.COMPLETE  \n",
+       "15  TrialState.COMPLETE  \n",
+       "14  TrialState.COMPLETE  \n",
+       "13  TrialState.COMPLETE  \n",
+       "12  TrialState.COMPLETE  \n",
+       "10  TrialState.COMPLETE  \n",
+       "11  TrialState.COMPLETE  \n",
+       "2   TrialState.COMPLETE  \n",
+       "8   TrialState.COMPLETE  \n",
+       "4   TrialState.COMPLETE  \n",
+       "0   TrialState.COMPLETE  \n",
+       "18  TrialState.COMPLETE  \n",
+       "1   TrialState.COMPLETE  \n",
+       "9   TrialState.COMPLETE  \n",
+       "5   TrialState.COMPLETE  \n",
+       "6   TrialState.COMPLETE  \n",
+       "3   TrialState.COMPLETE  \n",
+       "7   TrialState.COMPLETE  "
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "tune.summary()[[\"hash\", \"pipeline\", \"SMAPE_mean\", \"state\"]].sort_values(\"SMAPE_mean\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "95721277",
+   "metadata": {},
+   "source": [
+    "As we can see, we have duplicate lines according to the `hash` column. Some trials have the same sampled hyperparameters and they have the same results. We have a special handling for such duplicates: they are skipped during optimization and the previously computed metric values are returned.\n",
+    "\n",
+    "Duplicates on the summary can be eliminated using `hash` column."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "7506fe96",
+   "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>hash</th>\n",
+       "      <th>pipeline</th>\n",
+       "      <th>SMAPE_mean</th>\n",
+       "      <th>state</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>19</th>\n",
+       "      <td>8363309e454e72993f86f10c7fc7c137</td>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>8.556535</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>7c7932114268832a5458acfecfb453fc</td>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>9.210183</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8</th>\n",
+       "      <td>25dcd8bb095f87a1ffc499fa6a83ef5d</td>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>9.943658</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>e928929f89156d88ef49e28abaf55847</td>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>9.946866</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>f4f02e1d5f60b8f322a4a8a622dd1c1e</td>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>9.957781</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>18</th>\n",
+       "      <td>6f595f4f43b323804c04d4cea49c169b</td>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>10.061742</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>3d7b7af16d71a36f3b935f69e113e22d</td>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>10.306909</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>9</th>\n",
+       "      <td>3f1ca1759261598081fa3bb2f32fe0ac</td>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>10.554444</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>3b4311d41fcaab7307235ea23b6d4599</td>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>10.756703</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>74065ebc11c81bed6a9819d026c7cd84</td>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>10.917164</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>b7ac5f7fcf9c8959626befe263a9d561</td>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>11.255320</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7</th>\n",
+       "      <td>b0d0420255c6117045f8254bf8f377a0</td>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>11.478760</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                                hash  \\\n",
+       "19  8363309e454e72993f86f10c7fc7c137   \n",
+       "2   7c7932114268832a5458acfecfb453fc   \n",
+       "8   25dcd8bb095f87a1ffc499fa6a83ef5d   \n",
+       "4   e928929f89156d88ef49e28abaf55847   \n",
+       "0   f4f02e1d5f60b8f322a4a8a622dd1c1e   \n",
+       "18  6f595f4f43b323804c04d4cea49c169b   \n",
+       "1   3d7b7af16d71a36f3b935f69e113e22d   \n",
+       "9   3f1ca1759261598081fa3bb2f32fe0ac   \n",
+       "5   3b4311d41fcaab7307235ea23b6d4599   \n",
+       "6   74065ebc11c81bed6a9819d026c7cd84   \n",
+       "3   b7ac5f7fcf9c8959626befe263a9d561   \n",
+       "7   b0d0420255c6117045f8254bf8f377a0   \n",
+       "\n",
+       "                                             pipeline  SMAPE_mean  \\\n",
+       "19  Pipeline(model = LinearPerSegmentModel(fit_int...    8.556535   \n",
+       "2   Pipeline(model = LinearPerSegmentModel(fit_int...    9.210183   \n",
+       "8   Pipeline(model = LinearPerSegmentModel(fit_int...    9.943658   \n",
+       "4   Pipeline(model = LinearPerSegmentModel(fit_int...    9.946866   \n",
+       "0   Pipeline(model = LinearPerSegmentModel(fit_int...    9.957781   \n",
+       "18  Pipeline(model = LinearPerSegmentModel(fit_int...   10.061742   \n",
+       "1   Pipeline(model = LinearPerSegmentModel(fit_int...   10.306909   \n",
+       "9   Pipeline(model = LinearPerSegmentModel(fit_int...   10.554444   \n",
+       "5   Pipeline(model = LinearPerSegmentModel(fit_int...   10.756703   \n",
+       "6   Pipeline(model = LinearPerSegmentModel(fit_int...   10.917164   \n",
+       "3   Pipeline(model = LinearPerSegmentModel(fit_int...   11.255320   \n",
+       "7   Pipeline(model = LinearPerSegmentModel(fit_int...   11.478760   \n",
+       "\n",
+       "                  state  \n",
+       "19  TrialState.COMPLETE  \n",
+       "2   TrialState.COMPLETE  \n",
+       "8   TrialState.COMPLETE  \n",
+       "4   TrialState.COMPLETE  \n",
+       "0   TrialState.COMPLETE  \n",
+       "18  TrialState.COMPLETE  \n",
+       "1   TrialState.COMPLETE  \n",
+       "9   TrialState.COMPLETE  \n",
+       "5   TrialState.COMPLETE  \n",
+       "6   TrialState.COMPLETE  \n",
+       "3   TrialState.COMPLETE  \n",
+       "7   TrialState.COMPLETE  "
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "tune.summary()[[\"hash\", \"pipeline\", \"SMAPE_mean\", \"state\"]].sort_values(\"SMAPE_mean\").drop_duplicates(subset=\"hash\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a642c361",
+   "metadata": {},
+   "source": [
+    "The second method `top_k` is useful when you want to check out best tried pipelines without duplicates."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "6f707553",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "top_3_pipelines = tune.top_k(k=3)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "7fd2b238",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[Pipeline(model = LinearPerSegmentModel(fit_intercept = True, ), transforms = [LagTransform(in_column = 'target', lags = [14, 15, 16, 17, 18, 19, 20, 21, 22, 23], out_column = 'target_lag', ), DateFlagsTransform(day_number_in_week = False, day_number_in_month = True, day_number_in_year = False, week_number_in_month = True, week_number_in_year = False, month_number_in_year = False, season_number = False, year_number = False, is_weekend = True, special_days_in_week = (), special_days_in_month = (), out_column = 'date_flags', )], horizon = 14, ),\n",
+       " Pipeline(model = LinearPerSegmentModel(fit_intercept = True, ), transforms = [LagTransform(in_column = 'target', lags = [14, 15, 16, 17, 18, 19, 20, 21, 22, 23], out_column = 'target_lag', ), DateFlagsTransform(day_number_in_week = False, day_number_in_month = True, day_number_in_year = False, week_number_in_month = True, week_number_in_year = False, month_number_in_year = False, season_number = False, year_number = False, is_weekend = False, special_days_in_week = (), special_days_in_month = (), out_column = 'date_flags', )], horizon = 14, ),\n",
+       " Pipeline(model = LinearPerSegmentModel(fit_intercept = False, ), transforms = [LagTransform(in_column = 'target', lags = [14, 15, 16, 17, 18, 19, 20, 21, 22, 23], out_column = 'target_lag', ), DateFlagsTransform(day_number_in_week = True, day_number_in_month = False, day_number_in_year = True, week_number_in_month = False, week_number_in_year = False, month_number_in_year = False, season_number = False, year_number = True, is_weekend = False, special_days_in_week = (), special_days_in_month = (), out_column = 'date_flags', )], horizon = 14, )]"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "top_3_pipelines"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "15ef8f10",
+   "metadata": {},
+   "source": [
+    "## 2. General AutoML <a class=\"anchor\" id=\"chapter_2\"></a>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fef33f7e",
+   "metadata": {},
+   "source": [
+    "Hyperparameters tuning is useful, but can be too narrow. In this section we move our attention to general AutoML pipeline.\n",
+    "In ETNA we have an `etna.auto.Auto` class for making automatic pipeline selection. It can be useful to quickly create a good baseline for your forecasting task."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8c1763e2",
+   "metadata": {},
+   "source": [
+    "### 2.1 How `Auto` works <a class=\"anchor\" id=\"section_2_1\"></a>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4e20092d",
+   "metadata": {},
+   "source": [
+    "`Auto` init has similar parameters to `Tune`, but instead of `pipeline` it works with `pool`. Pool, in general, is just a list of pipelines.\n",
+    "\n",
+    "During `fit` there are two stages:\n",
+    "- pool stage,\n",
+    "- tuning stage.\n",
+    "\n",
+    "Pool stage is responsible for checking every pipeline suggested in a given `pool`. For each pipeline we run a backtest and compute `target_metric`. Results are saved in optuna study.\n",
+    "\n",
+    "Tuning stage takes `tune_size` best pipelines according to the resuls of the pool stage. And then runs `Tune` with default `params_to_tune` for them sequentially from best to the worst. \n",
+    "\n",
+    "Limit parameters `n_trials` and `timeout` are shared between pool and tuning stages. First, we run pool stage with given `n_trials` and `timeout`. After that, the remaining values are divided equally among `tune_size` tuning steps."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "96b2fb38",
+   "metadata": {},
+   "source": [
+    "### 2.2 Example <a class=\"anchor\" id=\"section_2_2\"></a>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "02b2c527",
+   "metadata": {},
+   "source": [
+    "We will move stright to the example."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "ea97e2f7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from etna.auto import Auto\n",
+    "\n",
+    "\n",
+    "auto = Auto(target_metric=SMAPE(), horizon=HORIZON, backtest_params=dict(n_folds=5))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "83fe5077",
+   "metadata": {},
+   "source": [
+    "We used mostly default parameters, even pool. There is also a default `sampler`, but to make results more reproducible we fixed the `seed`."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "aa87e050",
+   "metadata": {},
+   "source": [
+    "Let's start the fitting. We can start by running only pool stage."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "47ccd63b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%%capture\n",
+    "best_pool_pipeline = auto.fit(ts=ts, tune_size=0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "d972dfb5",
+   "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>hash</th>\n",
+       "      <th>pipeline</th>\n",
+       "      <th>SMAPE_mean</th>\n",
+       "      <th>state</th>\n",
+       "      <th>study</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>19</th>\n",
+       "      <td>af8088ac0abfde46e93a8dbb407a2117</td>\n",
+       "      <td>Pipeline(model = CatBoostPerSegmentModel(itera...</td>\n",
+       "      <td>5.057438</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "      <td>pool</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>9</th>\n",
+       "      <td>d8215d95e2c6c9a4b4fdacf3fa77dddc</td>\n",
+       "      <td>Pipeline(model = NaiveModel(lag = 7, ), transf...</td>\n",
+       "      <td>5.164436</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "      <td>pool</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>12</th>\n",
+       "      <td>8f640faabcac0552153ca19337179f3b</td>\n",
+       "      <td>Pipeline(model = HoltWintersModel(trend = 'add...</td>\n",
+       "      <td>5.931951</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "      <td>pool</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>d6a44adb551f1aec09ef37c14aed260f</td>\n",
+       "      <td>Pipeline(model = SeasonalMovingAverageModel(wi...</td>\n",
+       "      <td>6.197182</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "      <td>pool</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>18</th>\n",
+       "      <td>16eb77200eb2fd5dc1f6f2a5067884cd</td>\n",
+       "      <td>Pipeline(model = HoltWintersModel(trend = 'add...</td>\n",
+       "      <td>6.347734</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "      <td>pool</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>17</th>\n",
+       "      <td>4c07749e913403906cd033e4882fc4f9</td>\n",
+       "      <td>Pipeline(model = SeasonalMovingAverageModel(wi...</td>\n",
+       "      <td>6.529721</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "      <td>pool</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>6e2eb71d033b6d0607f5b6d0a7596ce9</td>\n",
+       "      <td>Pipeline(model = ProphetModel(growth = 'linear...</td>\n",
+       "      <td>7.799984</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "      <td>pool</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>13</th>\n",
+       "      <td>6bb58e7ce09eab00448d5732240ec2ec</td>\n",
+       "      <td>Pipeline(model = CatBoostMultiSegmentModel(ite...</td>\n",
+       "      <td>7.814187</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "      <td>pool</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>a640ddfb767ea0cbf31751ddda6e36ee</td>\n",
+       "      <td>Pipeline(model = CatBoostMultiSegmentModel(ite...</td>\n",
+       "      <td>7.816528</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "      <td>pool</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>10</th>\n",
+       "      <td>cfeb21bcf2e922a390ade8be9d845e0d</td>\n",
+       "      <td>Pipeline(model = ProphetModel(growth = 'linear...</td>\n",
+       "      <td>7.893421</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "      <td>pool</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7</th>\n",
+       "      <td>a5e036978ef9cc9f297c9eb2c280af05</td>\n",
+       "      <td>Pipeline(model = AutoARIMAModel(), transforms ...</td>\n",
+       "      <td>8.297048</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "      <td>pool</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>16</th>\n",
+       "      <td>2e36e0b9cb67a43bb1bf96fa2ccf718f</td>\n",
+       "      <td>Pipeline(model = LinearMultiSegmentModel(fit_i...</td>\n",
+       "      <td>9.205423</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "      <td>pool</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>8b9f5fa09754a80f17380dec2b998f1d</td>\n",
+       "      <td>Pipeline(model = LinearPerSegmentModel(fit_int...</td>\n",
+       "      <td>10.997462</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "      <td>pool</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>11</th>\n",
+       "      <td>d62c0579459d4a1b88aea8ed6effdf4e</td>\n",
+       "      <td>Pipeline(model = MovingAverageModel(window = 1...</td>\n",
+       "      <td>11.317256</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "      <td>pool</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>14</th>\n",
+       "      <td>5916e5b653295271c79caae490618ee9</td>\n",
+       "      <td>Pipeline(model = MovingAverageModel(window = 2...</td>\n",
+       "      <td>12.028916</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "      <td>pool</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>5a91b6c8acc2c461913df44fd1429375</td>\n",
+       "      <td>Pipeline(model = ElasticPerSegmentModel(alpha ...</td>\n",
+       "      <td>12.213320</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "      <td>pool</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>403b3e18012af5ff9815b408f5c2e47d</td>\n",
+       "      <td>Pipeline(model = MovingAverageModel(window = 4...</td>\n",
+       "      <td>12.243011</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "      <td>pool</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>15</th>\n",
+       "      <td>6cf8605e6c513053ac4f5203e330c59d</td>\n",
+       "      <td>Pipeline(model = HoltWintersModel(trend = None...</td>\n",
+       "      <td>15.473118</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "      <td>pool</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8</th>\n",
+       "      <td>53e90ae4cf7f1f71e6396107549c25ef</td>\n",
+       "      <td>Pipeline(model = NaiveModel(lag = 1, ), transf...</td>\n",
+       "      <td>19.361078</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "      <td>pool</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>90b31b54cb8c01867be05a3320852682</td>\n",
+       "      <td>Pipeline(model = ElasticMultiSegmentModel(alph...</td>\n",
+       "      <td>35.971166</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "      <td>pool</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                                hash  \\\n",
+       "19  af8088ac0abfde46e93a8dbb407a2117   \n",
+       "9   d8215d95e2c6c9a4b4fdacf3fa77dddc   \n",
+       "12  8f640faabcac0552153ca19337179f3b   \n",
+       "3   d6a44adb551f1aec09ef37c14aed260f   \n",
+       "18  16eb77200eb2fd5dc1f6f2a5067884cd   \n",
+       "17  4c07749e913403906cd033e4882fc4f9   \n",
+       "5   6e2eb71d033b6d0607f5b6d0a7596ce9   \n",
+       "13  6bb58e7ce09eab00448d5732240ec2ec   \n",
+       "1   a640ddfb767ea0cbf31751ddda6e36ee   \n",
+       "10  cfeb21bcf2e922a390ade8be9d845e0d   \n",
+       "7   a5e036978ef9cc9f297c9eb2c280af05   \n",
+       "16  2e36e0b9cb67a43bb1bf96fa2ccf718f   \n",
+       "2   8b9f5fa09754a80f17380dec2b998f1d   \n",
+       "11  d62c0579459d4a1b88aea8ed6effdf4e   \n",
+       "14  5916e5b653295271c79caae490618ee9   \n",
+       "4   5a91b6c8acc2c461913df44fd1429375   \n",
+       "6   403b3e18012af5ff9815b408f5c2e47d   \n",
+       "15  6cf8605e6c513053ac4f5203e330c59d   \n",
+       "8   53e90ae4cf7f1f71e6396107549c25ef   \n",
+       "0   90b31b54cb8c01867be05a3320852682   \n",
+       "\n",
+       "                                             pipeline  SMAPE_mean  \\\n",
+       "19  Pipeline(model = CatBoostPerSegmentModel(itera...    5.057438   \n",
+       "9   Pipeline(model = NaiveModel(lag = 7, ), transf...    5.164436   \n",
+       "12  Pipeline(model = HoltWintersModel(trend = 'add...    5.931951   \n",
+       "3   Pipeline(model = SeasonalMovingAverageModel(wi...    6.197182   \n",
+       "18  Pipeline(model = HoltWintersModel(trend = 'add...    6.347734   \n",
+       "17  Pipeline(model = SeasonalMovingAverageModel(wi...    6.529721   \n",
+       "5   Pipeline(model = ProphetModel(growth = 'linear...    7.799984   \n",
+       "13  Pipeline(model = CatBoostMultiSegmentModel(ite...    7.814187   \n",
+       "1   Pipeline(model = CatBoostMultiSegmentModel(ite...    7.816528   \n",
+       "10  Pipeline(model = ProphetModel(growth = 'linear...    7.893421   \n",
+       "7   Pipeline(model = AutoARIMAModel(), transforms ...    8.297048   \n",
+       "16  Pipeline(model = LinearMultiSegmentModel(fit_i...    9.205423   \n",
+       "2   Pipeline(model = LinearPerSegmentModel(fit_int...   10.997462   \n",
+       "11  Pipeline(model = MovingAverageModel(window = 1...   11.317256   \n",
+       "14  Pipeline(model = MovingAverageModel(window = 2...   12.028916   \n",
+       "4   Pipeline(model = ElasticPerSegmentModel(alpha ...   12.213320   \n",
+       "6   Pipeline(model = MovingAverageModel(window = 4...   12.243011   \n",
+       "15  Pipeline(model = HoltWintersModel(trend = None...   15.473118   \n",
+       "8   Pipeline(model = NaiveModel(lag = 1, ), transf...   19.361078   \n",
+       "0   Pipeline(model = ElasticMultiSegmentModel(alph...   35.971166   \n",
+       "\n",
+       "                  state study  \n",
+       "19  TrialState.COMPLETE  pool  \n",
+       "9   TrialState.COMPLETE  pool  \n",
+       "12  TrialState.COMPLETE  pool  \n",
+       "3   TrialState.COMPLETE  pool  \n",
+       "18  TrialState.COMPLETE  pool  \n",
+       "17  TrialState.COMPLETE  pool  \n",
+       "5   TrialState.COMPLETE  pool  \n",
+       "13  TrialState.COMPLETE  pool  \n",
+       "1   TrialState.COMPLETE  pool  \n",
+       "10  TrialState.COMPLETE  pool  \n",
+       "7   TrialState.COMPLETE  pool  \n",
+       "16  TrialState.COMPLETE  pool  \n",
+       "2   TrialState.COMPLETE  pool  \n",
+       "11  TrialState.COMPLETE  pool  \n",
+       "14  TrialState.COMPLETE  pool  \n",
+       "4   TrialState.COMPLETE  pool  \n",
+       "6   TrialState.COMPLETE  pool  \n",
+       "15  TrialState.COMPLETE  pool  \n",
+       "8   TrialState.COMPLETE  pool  \n",
+       "0   TrialState.COMPLETE  pool  "
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "auto.summary()[[\"hash\", \"pipeline\", \"SMAPE_mean\", \"state\", \"study\"]].sort_values(\"SMAPE_mean\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ff62ced9",
+   "metadata": {},
+   "source": [
+    "We can continue our training. The pool stage is over and there will be only the tuning stage. If we don't want to wait forever we should limit the tuning by fixing `n_trials` or `timeout`. We also set `gc_after_trial=True` to prevent `fit` from increasing memory consumption. Parameter `catch` is responsible for not failing if some trials are erroneous."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "13a1861a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%%capture\n",
+    "best_tuning_pipeline = auto.fit(\n",
+    "    ts=ts, tune_size=3, n_trials=100, optuna_params=dict(gc_after_trial=True, catch=(Exception,))\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "09f78f63",
+   "metadata": {},
+   "source": [
+    "Let's look at the results."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "95c854eb",
+   "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>hash</th>\n",
+       "      <th>pipeline</th>\n",
+       "      <th>SMAPE_mean</th>\n",
+       "      <th>state</th>\n",
+       "      <th>study</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>56</th>\n",
+       "      <td>419fc80cf634ba0888c4f899f666ad45</td>\n",
+       "      <td>Pipeline(model = HoltWintersModel(trend = 'mul...</td>\n",
+       "      <td>4.769471</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "      <td>tuning/8f640faabcac0552153ca19337179f3b</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>89</th>\n",
+       "      <td>731ccb72a473bec81789b7f186001ddd</td>\n",
+       "      <td>Pipeline(model = CatBoostPerSegmentModel(itera...</td>\n",
+       "      <td>4.899715</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "      <td>tuning/af8088ac0abfde46e93a8dbb407a2117</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>97</th>\n",
+       "      <td>9c302769456b4adb9143f11c582f7264</td>\n",
+       "      <td>Pipeline(model = CatBoostPerSegmentModel(itera...</td>\n",
+       "      <td>4.927197</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "      <td>tuning/af8088ac0abfde46e93a8dbb407a2117</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>88</th>\n",
+       "      <td>182c748af70287ab3a12bf32c03320f5</td>\n",
+       "      <td>Pipeline(model = CatBoostPerSegmentModel(itera...</td>\n",
+       "      <td>4.941247</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "      <td>tuning/af8088ac0abfde46e93a8dbb407a2117</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>96</th>\n",
+       "      <td>4f426335c0eb00d847d9dd1e0a421415</td>\n",
+       "      <td>Pipeline(model = CatBoostPerSegmentModel(itera...</td>\n",
+       "      <td>4.977773</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "      <td>tuning/af8088ac0abfde46e93a8dbb407a2117</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>98</th>\n",
+       "      <td>2cafd0750f191e7ab2d4160da50a7c64</td>\n",
+       "      <td>Pipeline(model = CatBoostPerSegmentModel(itera...</td>\n",
+       "      <td>5.056993</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "      <td>tuning/af8088ac0abfde46e93a8dbb407a2117</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>19</th>\n",
+       "      <td>af8088ac0abfde46e93a8dbb407a2117</td>\n",
+       "      <td>Pipeline(model = CatBoostPerSegmentModel(itera...</td>\n",
+       "      <td>5.057438</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "      <td>pool</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>75</th>\n",
+       "      <td>382825866425cac211691205a9537c95</td>\n",
+       "      <td>Pipeline(model = CatBoostPerSegmentModel(itera...</td>\n",
+       "      <td>5.081609</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "      <td>tuning/af8088ac0abfde46e93a8dbb407a2117</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>95</th>\n",
+       "      <td>c2a8d498fe35873d060e173e1af042d5</td>\n",
+       "      <td>Pipeline(model = CatBoostPerSegmentModel(itera...</td>\n",
+       "      <td>5.117583</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "      <td>tuning/af8088ac0abfde46e93a8dbb407a2117</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>91</th>\n",
+       "      <td>035f8e28180bc7491a30b3d0d67060c9</td>\n",
+       "      <td>Pipeline(model = CatBoostPerSegmentModel(itera...</td>\n",
+       "      <td>5.135956</td>\n",
+       "      <td>TrialState.COMPLETE</td>\n",
+       "      <td>tuning/af8088ac0abfde46e93a8dbb407a2117</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                                hash  \\\n",
+       "56  419fc80cf634ba0888c4f899f666ad45   \n",
+       "89  731ccb72a473bec81789b7f186001ddd   \n",
+       "97  9c302769456b4adb9143f11c582f7264   \n",
+       "88  182c748af70287ab3a12bf32c03320f5   \n",
+       "96  4f426335c0eb00d847d9dd1e0a421415   \n",
+       "98  2cafd0750f191e7ab2d4160da50a7c64   \n",
+       "19  af8088ac0abfde46e93a8dbb407a2117   \n",
+       "75  382825866425cac211691205a9537c95   \n",
+       "95  c2a8d498fe35873d060e173e1af042d5   \n",
+       "91  035f8e28180bc7491a30b3d0d67060c9   \n",
+       "\n",
+       "                                             pipeline  SMAPE_mean  \\\n",
+       "56  Pipeline(model = HoltWintersModel(trend = 'mul...    4.769471   \n",
+       "89  Pipeline(model = CatBoostPerSegmentModel(itera...    4.899715   \n",
+       "97  Pipeline(model = CatBoostPerSegmentModel(itera...    4.927197   \n",
+       "88  Pipeline(model = CatBoostPerSegmentModel(itera...    4.941247   \n",
+       "96  Pipeline(model = CatBoostPerSegmentModel(itera...    4.977773   \n",
+       "98  Pipeline(model = CatBoostPerSegmentModel(itera...    5.056993   \n",
+       "19  Pipeline(model = CatBoostPerSegmentModel(itera...    5.057438   \n",
+       "75  Pipeline(model = CatBoostPerSegmentModel(itera...    5.081609   \n",
+       "95  Pipeline(model = CatBoostPerSegmentModel(itera...    5.117583   \n",
+       "91  Pipeline(model = CatBoostPerSegmentModel(itera...    5.135956   \n",
+       "\n",
+       "                  state                                    study  \n",
+       "56  TrialState.COMPLETE  tuning/8f640faabcac0552153ca19337179f3b  \n",
+       "89  TrialState.COMPLETE  tuning/af8088ac0abfde46e93a8dbb407a2117  \n",
+       "97  TrialState.COMPLETE  tuning/af8088ac0abfde46e93a8dbb407a2117  \n",
+       "88  TrialState.COMPLETE  tuning/af8088ac0abfde46e93a8dbb407a2117  \n",
+       "96  TrialState.COMPLETE  tuning/af8088ac0abfde46e93a8dbb407a2117  \n",
+       "98  TrialState.COMPLETE  tuning/af8088ac0abfde46e93a8dbb407a2117  \n",
+       "19  TrialState.COMPLETE                                     pool  \n",
+       "75  TrialState.COMPLETE  tuning/af8088ac0abfde46e93a8dbb407a2117  \n",
+       "95  TrialState.COMPLETE  tuning/af8088ac0abfde46e93a8dbb407a2117  \n",
+       "91  TrialState.COMPLETE  tuning/af8088ac0abfde46e93a8dbb407a2117  "
+      ]
+     },
+     "execution_count": 27,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "auto.summary()[[\"hash\", \"pipeline\", \"SMAPE_mean\", \"state\", \"study\"]].sort_values(\"SMAPE_mean\").drop_duplicates(\n",
+    "    subset=(\"hash\", \"study\")\n",
+    ").head(10)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "640269ba",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[Pipeline(model = HoltWintersModel(trend = 'mul', damped_trend = False, seasonal = 'mul', seasonal_periods = None, initialization_method = 'estimated', initial_level = None, initial_trend = None, initial_seasonal = None, use_boxcox = True, bounds = None, dates = None, freq = None, missing = 'none', smoothing_level = None, smoothing_trend = None, smoothing_seasonal = None, damping_trend = None, ), transforms = [], horizon = 14, ),\n",
+       " Pipeline(model = CatBoostPerSegmentModel(iterations = None, depth = 9, learning_rate = 0.0435214895575014, logging_level = 'Silent', l2_leaf_reg = 1.588756097852857, thread_count = None, random_strength = 0.0001602176189749599, ), transforms = [LagTransform(in_column = 'target', lags = [15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], out_column = None, ), DateFlagsTransform(day_number_in_week = True, day_number_in_month = False, day_number_in_year = False, week_number_in_month = False, week_number_in_year = False, month_number_in_year = False, season_number = False, year_number = False, is_weekend = True, special_days_in_week = [], special_days_in_month = [], out_column = None, )], horizon = 14, ),\n",
+       " Pipeline(model = CatBoostPerSegmentModel(iterations = None, depth = 10, learning_rate = 0.066387199945575, logging_level = 'Silent', l2_leaf_reg = 3.8476771557403033, thread_count = None, random_strength = 2.6976801196146113e-05, ), transforms = [LagTransform(in_column = 'target', lags = [15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], out_column = None, ), DateFlagsTransform(day_number_in_week = True, day_number_in_month = False, day_number_in_year = False, week_number_in_month = False, week_number_in_year = False, month_number_in_year = False, season_number = False, year_number = False, is_weekend = True, special_days_in_week = [], special_days_in_month = [], out_column = None, )], horizon = 14, ),\n",
+       " Pipeline(model = CatBoostPerSegmentModel(iterations = None, depth = 8, learning_rate = 0.1368955392889537, logging_level = 'Silent', l2_leaf_reg = 1.8121398100968207, thread_count = None, random_strength = 1.0292981436693363e-05, ), transforms = [LagTransform(in_column = 'target', lags = [15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], out_column = None, ), DateFlagsTransform(day_number_in_week = True, day_number_in_month = True, day_number_in_year = True, week_number_in_month = False, week_number_in_year = False, month_number_in_year = False, season_number = False, year_number = False, is_weekend = True, special_days_in_week = [], special_days_in_month = [], out_column = None, )], horizon = 14, ),\n",
+       " Pipeline(model = CatBoostPerSegmentModel(iterations = None, depth = 10, learning_rate = 0.04930475651736648, logging_level = 'Silent', l2_leaf_reg = 1.2938317623739193, thread_count = None, random_strength = 0.00020141074677370956, ), transforms = [LagTransform(in_column = 'target', lags = [15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], out_column = None, ), DateFlagsTransform(day_number_in_week = True, day_number_in_month = False, day_number_in_year = False, week_number_in_month = False, week_number_in_year = False, month_number_in_year = False, season_number = False, year_number = False, is_weekend = True, special_days_in_week = [], special_days_in_month = [], out_column = None, )], horizon = 14, )]"
+      ]
+     },
+     "execution_count": 28,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "auto.top_k(k=5)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7451f135",
+   "metadata": {},
+   "source": [
+    "If we look at `study` column we will see that best trial from tuning stage is better then best trial from pool stage. It means, that tuning stage was successful and improved the final result. \n",
+    "\n",
+    "Let's compare best pipeline on pool and tuning stages on hold-out part of initial `ts`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "id": "ce8953ab",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%%capture\n",
+    "best_pool_metrics, _, _ = best_pool_pipeline.backtest(ts=full_ts, metrics=[SMAPE()], n_folds=5)\n",
+    "best_tuning_metrics, _, _ = best_tuning_pipeline.backtest(ts=full_ts, metrics=[SMAPE()], n_folds=5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "id": "7a42cc84",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Best pool SMAPE: 8.262\n",
+      "Best tuning SMAPE: 8.188\n"
+     ]
+    }
+   ],
+   "source": [
+    "best_pool_smape = best_pool_metrics[\"SMAPE\"].mean()\n",
+    "best_tuning_smape = best_tuning_metrics[\"SMAPE\"].mean()\n",
+    "print(f\"Best pool SMAPE: {best_pool_smape:.3f}\")\n",
+    "print(f\"Best tuning SMAPE: {best_tuning_smape:.3f}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3f41537f",
+   "metadata": {},
+   "source": [
+    "As we can see, the results are slightly better after the tuning stage, but it can be statistically insignificant. For your datasets the results could be different."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3322d9c2",
+   "metadata": {},
+   "source": [
+    "## 3. Summary"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "39b4a081",
+   "metadata": {},
+   "source": [
+    "In this notebook we discussed how AutoML works in ETNA library and how to use it. There are two supported scenarios:\n",
+    "- Tuning your existing pipeline;\n",
+    "- Automatic search of the pipeline for your forecasting task."
+   ]
+  }
+ ],
+ "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.8.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}


Test patch:
diff --git a/tests/test_auto/conftest.py b/tests/test_auto/conftest.py
index 6117de125..646d42dcd 100644
--- a/tests/test_auto/conftest.py
+++ b/tests/test_auto/conftest.py
@@ -2,9 +2,10 @@
 
 import pytest
 from optuna.storages import RDBStorage
-from typing_extensions import Literal
+from optuna.structs import TrialState
 from typing_extensions import NamedTuple
 
+from etna.auto.utils import config_hash
 from etna.models import NaiveModel
 from etna.pipeline import Pipeline
 
@@ -19,12 +20,18 @@ def optuna_storage():
 def trials():
     class Trial(NamedTuple):
         user_attrs: dict
-        state: Literal["RUNNING", "WAITING", "COMPLETE", "PRUNED", "FAIL"] = "COMPLETE"
+        state: TrialState = TrialState.COMPLETE
 
     complete_trials = [
-        Trial(user_attrs={"pipeline": pipeline.to_dict(), "SMAPE_median": float(i)})
+        Trial(
+            user_attrs={
+                "pipeline": pipeline.to_dict(),
+                "SMAPE_median": float(i),
+                "hash": config_hash(pipeline.to_dict()),
+            }
+        )
         for i, pipeline in enumerate((Pipeline(NaiveModel(j), horizon=7) for j in range(10)))
     ]
-    fail_trials = [Trial(user_attrs={}, state="FAIL")]
+    fail_trials = [Trial(user_attrs={}, state=TrialState.FAIL)]
 
-    return complete_trials + fail_trials
+    return complete_trials + complete_trials[:3] + fail_trials
diff --git a/tests/test_auto/test_auto.py b/tests/test_auto/test_auto.py
index 414cd651c..a8e01175c 100644
--- a/tests/test_auto/test_auto.py
+++ b/tests/test_auto/test_auto.py
@@ -253,7 +253,7 @@ def test_summary_after_fit(
     auto.fit(ts=example_tsds, n_trials=11, tune_size=2)
 
     df_summary = auto.summary()
-    assert {"pipeline", "state", "study"}.issubset(set(df_summary.columns))
+    assert {"hash", "pipeline", "state", "study"}.issubset(set(df_summary.columns))
     assert len(df_summary) == 11
     assert len(df_summary[df_summary["study"] == "pool"]) == 3
     df_summary_tune_0 = df_summary[df_summary["study"] == "tuning/edddb11f9acb86ea0cd5568f13f53874"]
diff --git a/tests/test_auto/test_tune.py b/tests/test_auto/test_tune.py
index 642312ba0..f45adbc3b 100644
--- a/tests/test_auto/test_tune.py
+++ b/tests/test_auto/test_tune.py
@@ -135,7 +135,7 @@ def test_summary(
     df_summary = Tune.summary(self=tune)
 
     assert len(df_summary) == len(trials)
-    assert {"pipeline", "state"}.issubset(set(df_summary.columns))
+    assert {"hash", "pipeline", "state"}.issubset(set(df_summary.columns))
     expected_smape = pd.Series([trial.user_attrs.get("SMAPE_median") for trial in trials])
     pd.testing.assert_series_equal(df_summary["SMAPE_median"], expected_smape, check_names=False)
 
@@ -184,7 +184,7 @@ def test_tune_run(example_tsds, optuna_storage, pipeline):
 
     assert len(tune._optuna.study.trials) == 2
     assert len(tune.summary()) == 2
-    assert len(tune.top_k()) == 2
+    assert len(tune.top_k()) <= 2
     assert len(tune.top_k(k=1)) == 1
 
 
@@ -242,5 +242,5 @@ def test_tune_hierarchical_run(
 
     assert len(tune._optuna.study.trials) == 2
     assert len(tune.summary()) == 2
-    assert len(tune.top_k()) == 2
+    assert len(tune.top_k()) <= 2
     assert len(tune.top_k(k=1)) == 1