diff --git a/CHANGELOG.md b/CHANGELOG.md
index dfb8f4059d..c0cef3a013 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,7 @@ Darts is still in an early development phase, and we cannot always guarantee bac
- Fixed edge case in ShapExplainer for regression models where covariates series > target series [#1310](https://https://github.com/unit8co/darts/pull/1310) by [Rijk van der Meulen](https://github.com/rijkvandermeulen)
- Removed `IPython` as a dependency. [#1331](https://github.com/unit8co/darts/pull/1331) by [Erik Hasse](https://github.com/erik-hasse)
- New models: `DLinearModel` and `NLinearModel` as proposed in [this paper](https://arxiv.org/pdf/2205.13504.pdf). [#1139](https://github.com/unit8co/darts/pull/1139) by [Julien Herzen](https://github.com/hrzn) and [Greg DeVos](https://github.com/gdevos010).
+- Added new `TFTExplainer` class to implement the Explainable AI part described in [the paper](https://arxiv.org/abs/1912.09363) of the `TFT` model. [#1392](https://github.com/unit8co/darts/pull/1392) by [Sebastian Cattes](https://github.com/cattes).
[Full Changelog](https://github.com/unit8co/darts/compare/0.22.0...master)
diff --git a/darts/explainability/__init__.py b/darts/explainability/__init__.py
index 7b943e3e50..f09eb697d7 100644
--- a/darts/explainability/__init__.py
+++ b/darts/explainability/__init__.py
@@ -5,3 +5,4 @@
from darts.explainability.explainability_result import ExplainabilityResult
from darts.explainability.shap_explainer import ShapExplainer
+from darts.explainability.tft_explainer import TFTExplainer
diff --git a/darts/explainability/explainability_result.py b/darts/explainability/explainability_result.py
index c605edd998..ca8a88d7f7 100644
--- a/darts/explainability/explainability_result.py
+++ b/darts/explainability/explainability_result.py
@@ -58,9 +58,7 @@ def get_explanation(
raise_if(
component is None and len(self.available_components) > 1,
- ValueError(
- "The component parameter is required when the model has more than one component."
- ),
+ "The component parameter is required when the model has more than one component.",
logger,
)
diff --git a/darts/explainability/tft_explainer.py b/darts/explainability/tft_explainer.py
new file mode 100644
index 0000000000..de9c8fc129
--- /dev/null
+++ b/darts/explainability/tft_explainer.py
@@ -0,0 +1,222 @@
+from typing import Dict, List, Literal, Optional
+
+import matplotlib.pyplot as plt
+import pandas as pd
+from torch import Tensor
+
+from darts import TimeSeries
+from darts.explainability.explainability import (
+ ExplainabilityResult,
+ ForecastingModelExplainer,
+)
+from darts.models import TFTModel
+
+
+class TFTExplainer(ForecastingModelExplainer):
+ def __init__(
+ self,
+ model: TFTModel,
+ ):
+ """
+ Explainer class for the TFT model.
+
+ Parameters
+ ----------
+ model
+ The fitted TFT model to be explained.
+ """
+ super().__init__(model)
+
+ if not model._fit_called:
+ raise ValueError("The model needs to be trained before explaining it.")
+
+ self._model = model
+
+ @property
+ def encoder_importance(self):
+ return self._get_importance(
+ weight=self._model.model._encoder_sparse_weights,
+ names=self._model.model.encoder_variables,
+ )
+
+ @property
+ def decoder_importance(self):
+ return self._get_importance(
+ weight=self._model.model._decoder_sparse_weights,
+ names=self._model.model.decoder_variables,
+ )
+
+ def get_variable_selection_weight(self, plot=False) -> Dict[str, pd.DataFrame]:
+ """Returns the variable selection weight of the TFT model.
+
+ Parameters
+ ----------
+ plot
+ Whether to plot the variable selection weight.
+
+ Returns
+ -------
+ TimeSeries
+ The variable selection weight.
+
+ """
+
+ if plot:
+ # plot the encoder and decoder weights sorted descending
+ self.encoder_importance.plot(kind="bar", title="Encoder weights")
+ self.decoder_importance.plot(kind="bar", title="Decoder weights")
+
+ return {
+ "encoder_importance": self.encoder_importance,
+ "decoder_importance": self.decoder_importance,
+ }
+
+ def explain(self, **kwargs) -> ExplainabilityResult:
+ """Returns the explainability result of the TFT model.
+
+ The explainability result contains the attention heads of the TFT model.
+ The attention heads determine the contribution of time-varying inputs.
+
+ Parameters
+ ----------
+ kwargs
+ Arguments passed to the `predict` method of the TFT model.
+
+ Returns
+ -------
+ ExplainabilityResult
+ The explainability result containing the attention heads.
+
+ """
+ super().explain()
+ # without the predict call, the weights will still bet set to the last iteration of the forward() method
+ # of the _TFTModule class
+ if "n" not in kwargs:
+ kwargs["n"] = self._model.model.output_chunk_length
+
+ _ = self._model.predict(**kwargs)
+
+ # get the weights and the attention head from the trained model for the prediction
+ attention_heads = (
+ self._model.model._attn_out_weights.squeeze().sum(axis=1).detach()
+ )
+
+ # return the explainer result to be used in other methods
+ return ExplainabilityResult(
+ {
+ 0: {
+ "attention_heads": TimeSeries.from_dataframe(
+ pd.DataFrame(attention_heads).transpose()
+ ),
+ }
+ },
+ )
+
+ @staticmethod
+ def plot_attention_heads(
+ expl_result: ExplainabilityResult,
+ plot_type: Optional[Literal["all", "time", "heatmap"]] = "time",
+ ):
+ """Plots the attention heads of the TFT model."""
+ attention_heads = expl_result.get_explanation(
+ component="attention_heads",
+ horizon=0,
+ )
+ if plot_type == "all":
+ fig = plt.figure()
+ attention_heads.plot(
+ label="Attention Head",
+ plot_all_components=True,
+ figure=fig,
+ )
+ # move legend to the right side of the figure
+ plt.legend(bbox_to_anchor=(0.95, 1), loc="upper left")
+ plt.xlabel("Time steps in past")
+ plt.ylabel("Attention")
+ elif plot_type == "time":
+ fig = plt.figure()
+ attention_heads.mean(1).plot(label="Mean Attention Head", figure=fig)
+ plt.xlabel("Time steps in past")
+ plt.ylabel("Attention")
+ elif plot_type == "heatmap":
+ avg_attention = attention_heads.values().transpose()
+ fig = plt.figure()
+ plt.imshow(avg_attention, cmap="hot", interpolation="nearest", figure=fig)
+ plt.xlabel("Time steps in past")
+ plt.ylabel("Horizon")
+ else:
+ raise ValueError("`plot_type` must be either 'all', 'time' or 'heatmap'")
+
+ def _get_importance(
+ self,
+ weight: Tensor,
+ names: List[str],
+ n_decimals=3,
+ ) -> pd.DataFrame:
+ """Returns the encoder or decoder variable of the TFT model.
+
+ Parameters
+ ----------
+ weights
+ The weights of the encoder or decoder of the trained TFT model.
+ names
+ The encoder or decoder names saved in the TFT model class.
+ n_decimals
+ The number of decimals to round the importance to.
+
+ Returns
+ -------
+ pd.DataFrame
+ The importance of the variables.
+ """
+ # transform the encoder/decoder weights to percentages, rounded to n_decimals
+ weights_percentage = (
+ weight.mean(axis=1).detach().numpy().mean(axis=0).round(n_decimals) * 100
+ )
+
+ # create a dataframe with the variable names and the weights
+ name_mapping = self._name_mapping
+ importance = pd.DataFrame(
+ weights_percentage,
+ columns=[name_mapping[name] for name in names],
+ )
+
+ # return the importance sorted descending
+ return importance.transpose().sort_values(0, ascending=False).transpose()
+
+ @property
+ def _name_mapping(self) -> Dict[str, str]:
+ """Returns the feature name mapping of the TFT model.
+
+ Returns
+ -------
+ Dict[str, str]
+ The feature name mapping. For example
+ {
+ 'past_covariate_0': 'heater',
+ 'past_covariate_1': 'year',
+ 'past_covariate_2': 'month',
+ 'future_covariate_0': 'darts_enc_fc_cyc_month_sin',
+ 'future_covariate_1': 'darts_enc_fc_cyc_month_cos',
+ 'target_0': 'ice cream',
+ }
+
+ """
+ past_covariates_name_mapping = {
+ f"past_covariate_{i}": colname
+ for i, colname in enumerate(self._model.past_covariate_series.components)
+ }
+ future_covariates_name_mapping = {
+ f"future_covariate_{i}": colname
+ for i, colname in enumerate(self._model.future_covariate_series.components)
+ }
+ target_name_mapping = {
+ f"target_{i}": colname
+ for i, colname in enumerate(self._model.training_series.components)
+ }
+
+ return {
+ **past_covariates_name_mapping,
+ **future_covariates_name_mapping,
+ **target_name_mapping,
+ }
diff --git a/darts/models/forecasting/tft_model.py b/darts/models/forecasting/tft_model.py
index 56cdd31c4f..2fa89dee5a 100644
--- a/darts/models/forecasting/tft_model.py
+++ b/darts/models/forecasting/tft_model.py
@@ -325,6 +325,10 @@ def __init__(
self.output_layer = nn.Linear(self.hidden_size, self.n_targets * self.loss_size)
+ self._encoder_sparse_weights = None
+ self._decoder_sparse_weights = None
+ self._attn_out_weights = None
+
@property
def reals(self) -> List[str]:
"""
@@ -632,6 +636,9 @@ def forward(
out = out.view(
batch_size, self.output_chunk_length, self.n_targets, self.loss_size
)
+ self._encoder_sparse_weights = encoder_sparse_weights
+ self._decoder_sparse_weights = decoder_sparse_weights
+ self._attn_out_weights = attn_out_weights
# TODO: (Darts) remember this in case we want to output interpretation
# return self.to_network_output(
diff --git a/darts/tests/explainability/test_tft_explainer.py b/darts/tests/explainability/test_tft_explainer.py
new file mode 100644
index 0000000000..b16808e8e6
--- /dev/null
+++ b/darts/tests/explainability/test_tft_explainer.py
@@ -0,0 +1,419 @@
+from copy import deepcopy
+from unittest.mock import patch
+
+import numpy as np
+import pandas as pd
+
+from darts import TimeSeries, concatenate
+from darts.dataprocessing.transformers import Scaler
+from darts.datasets import IceCreamHeaterDataset
+from darts.explainability import TFTExplainer
+from darts.explainability.explainability import ExplainabilityResult
+from darts.models import TFTModel
+from darts.tests.base_test_class import DartsBaseTestClass
+from darts.utils.timeseries_generation import datetime_attribute_timeseries
+
+
+class TFTExplainerTestCase(DartsBaseTestClass):
+
+ np.random.seed(342)
+
+ # Ice Example from the TFT tutorial
+ series_ice_heater = IceCreamHeaterDataset().load()
+ # convert monthly sales to average daily sales per month
+ converted_series = []
+ for col in ["ice cream", "heater"]:
+ converted_series.append(
+ series_ice_heater[col]
+ / TimeSeries.from_series(series_ice_heater.time_index.days_in_month)
+ )
+ converted_series = concatenate(converted_series, axis=1)
+ converted_series = converted_series[pd.Timestamp("20100101") :]
+
+ # define train/validation cutoff time
+ forecast_horizon_ice = 12
+ training_cutoff_ice = converted_series.time_index[-(2 * forecast_horizon_ice)]
+
+ # use ice cream sales as target, create train and validation sets and transform data
+ series_ice = converted_series["ice cream"]
+ train_ice, val_ice = series_ice.split_before(training_cutoff_ice)
+ transformer_ice = Scaler()
+ train_ice_transformed = transformer_ice.fit_transform(train_ice)
+ val_ice_transformed = transformer_ice.transform(val_ice)
+ series_ice_transformed = transformer_ice.transform(series_ice)
+
+ # use heater sales as past covariates and transform data
+ covariates_heat = converted_series["heater"]
+ cov_heat_train, cov_heat_val = covariates_heat.split_before(training_cutoff_ice)
+ transformer_heat = Scaler()
+ transformer_heat.fit(cov_heat_train)
+ covariates_heat_transformed = transformer_heat.transform(covariates_heat)
+
+ # create input with multiple past covariates
+ multiple_covariates = covariates_heat.stack(
+ datetime_attribute_timeseries(covariates_heat, attribute="year", one_hot=False)
+ ).stack(
+ datetime_attribute_timeseries(covariates_heat, attribute="month", one_hot=False)
+ )
+ multi_cov_train, multi_cov_val = multiple_covariates.split_before(
+ training_cutoff_ice
+ )
+ transformer_multi_cov = Scaler()
+ transformer_multi_cov.fit(multi_cov_train)
+ multiple_covariates_transformed = transformer_multi_cov.transform(
+ multiple_covariates
+ )
+
+ # use the last 3 years as past input data
+ input_chunk_length_ice = 36
+
+ models = []
+ models.append(
+ TFTModel(
+ input_chunk_length=input_chunk_length_ice,
+ output_chunk_length=forecast_horizon_ice,
+ hidden_size=32,
+ lstm_layers=1,
+ batch_size=16,
+ n_epochs=10,
+ dropout=0.1,
+ add_encoders={"cyclic": {"future": ["month"]}},
+ add_relative_index=False,
+ optimizer_kwargs={"lr": 1e-3},
+ random_state=42,
+ )
+ )
+
+ def test_class_init_not_fitted_model_raises_error(self):
+ """The TFTExplainer class should raise an error if the model we want to explain is not fitted."""
+ # arrange
+ model = deepcopy(self.models[0])
+
+ # act / assert
+ with self.assertRaises(ValueError):
+ TFTExplainer(model)
+
+ def test_class_init_with_fitted_model_works(self):
+ """The TFTExplainer class should work if the model we want to explain is fitted."""
+ # arrange
+ model = deepcopy(self.models[0])
+
+ model.fit(
+ self.train_ice_transformed,
+ past_covariates=self.covariates_heat_transformed,
+ verbose=True,
+ )
+
+ # act
+ res = TFTExplainer(model)
+
+ # assert
+ self.assertTrue(isinstance(res, TFTExplainer))
+ self.assertTrue(hasattr(res, "model"))
+
+ def test_get_variable_selection_weight(self):
+ """The get_variable_selection_weight method returns the feature importance."""
+ # arrange
+ model = deepcopy(self.models[0])
+
+ # fit the model with past covariates
+ np.random.seed(342)
+ _ = model.fit(
+ self.train_ice_transformed,
+ past_covariates=self.covariates_heat_transformed,
+ verbose=False,
+ )
+
+ # call methods for debugging / development
+ explainer = TFTExplainer(model)
+
+ # expected results
+ expected_encoder_importance = pd.DataFrame(
+ [
+ {
+ "darts_enc_fc_cyc_month_cos": 68.4,
+ "heater": 16.5,
+ "ice cream": 10.6,
+ "darts_enc_fc_cyc_month_sin": 4.5,
+ },
+ ],
+ )
+ expected_decoder_importance = pd.DataFrame(
+ [
+ {
+ "darts_enc_fc_cyc_month_cos": 87.8,
+ "darts_enc_fc_cyc_month_sin": 12.2,
+ },
+ ]
+ )
+
+ # act
+ res = explainer.get_variable_selection_weight(plot=False)
+
+ # assert
+ self.assertTrue(isinstance(res, dict))
+ self.assertTrue(res.keys() == {"encoder_importance", "decoder_importance"})
+ pd.testing.assert_frame_equal(
+ res["encoder_importance"], expected_encoder_importance
+ )
+ pd.testing.assert_frame_equal(
+ res["decoder_importance"], expected_decoder_importance
+ )
+
+ def test_get_variable_selection_weight_plot(self):
+ """The get_variable_selection_weight method returns the feature importance."""
+ # arrange
+ model = deepcopy(self.models[0])
+
+ # fit the model with past covariates
+ np.random.seed(342)
+ _ = model.fit(
+ self.train_ice_transformed,
+ past_covariates=self.covariates_heat_transformed,
+ verbose=False,
+ )
+
+ # call methods for debugging / development
+ explainer = TFTExplainer(model)
+
+ # expected results
+ expected_encoder_importance = pd.DataFrame(
+ [
+ {
+ "darts_enc_fc_cyc_month_cos": 68.4,
+ "heater": 16.5,
+ "ice cream": 10.6,
+ "darts_enc_fc_cyc_month_sin": 4.5,
+ },
+ ],
+ )
+ expected_decoder_importance = pd.DataFrame(
+ [
+ {
+ "darts_enc_fc_cyc_month_cos": 87.8,
+ "darts_enc_fc_cyc_month_sin": 12.2,
+ },
+ ]
+ )
+
+ # act
+ with patch("matplotlib.pyplot.show") as _:
+ res = explainer.get_variable_selection_weight(plot=True)
+
+ # assert
+ self.assertTrue(isinstance(res, dict))
+ self.assertTrue(res.keys() == {"encoder_importance", "decoder_importance"})
+ pd.testing.assert_frame_equal(
+ res["encoder_importance"], expected_encoder_importance
+ )
+ pd.testing.assert_frame_equal(
+ res["decoder_importance"], expected_decoder_importance
+ )
+
+ def test_get_variable_selection_weight_multiple_covariates(self):
+ """The get_variable_selection_weight method returns the feature importance for multiple covariates as input."""
+ # arrange
+ model = deepcopy(self.models[0])
+
+ # fit the model with past covariates
+ np.random.seed(342)
+ _ = model.fit(
+ self.train_ice_transformed,
+ past_covariates=self.multiple_covariates_transformed,
+ verbose=False,
+ )
+
+ # call methods for debugging / development
+ explainer = TFTExplainer(model)
+
+ # expected results
+ expected_encoder_importance = pd.DataFrame(
+ [
+ {
+ "month": 49.1,
+ "year": 18.9,
+ "darts_enc_fc_cyc_month_cos": 14.7,
+ "darts_enc_fc_cyc_month_sin": 9.5,
+ "ice cream": 5.4,
+ "heater": 2.4,
+ }
+ ],
+ )
+ expected_decoder_importance = pd.DataFrame(
+ [
+ {
+ "darts_enc_fc_cyc_month_cos": 80.2,
+ "darts_enc_fc_cyc_month_sin": 19.8,
+ },
+ ]
+ )
+
+ # act
+ res = explainer.get_variable_selection_weight(plot=False)
+
+ # assert
+ self.assertTrue(isinstance(res, dict))
+ self.assertTrue(res.keys() == {"encoder_importance", "decoder_importance"})
+ pd.testing.assert_frame_equal(
+ res["encoder_importance"], expected_encoder_importance
+ )
+ pd.testing.assert_frame_equal(
+ res["decoder_importance"], expected_decoder_importance
+ )
+
+ def test_explain(self):
+ """The get_variable_selection_weight method returns the feature importance."""
+ # arrange
+ model = deepcopy(self.models[0])
+ # fit the model with past covariates
+ np.random.seed(342)
+ model.fit(
+ self.train_ice_transformed,
+ past_covariates=self.covariates_heat_transformed,
+ verbose=True,
+ )
+
+ # call methods for debugging / development
+ explainer = TFTExplainer(model)
+
+ expected_average_attention = [
+ [0.1186],
+ [0.1015],
+ [0.094],
+ [0.0955],
+ [0.0996],
+ [0.102],
+ [0.1016],
+ [0.0975],
+ [0.0935],
+ [0.0943],
+ [0.0988],
+ [0.1019],
+ [0.0997],
+ [0.0928],
+ [0.0908],
+ [0.0944],
+ [0.0999],
+ [0.1041],
+ [0.1018],
+ [0.0981],
+ [0.0935],
+ [0.0951],
+ [0.0997],
+ [0.1033],
+ [0.1013],
+ [0.094],
+ [0.0913],
+ [0.0945],
+ [0.0993],
+ [0.1023],
+ [0.102],
+ [0.0981],
+ [0.094],
+ [0.0951],
+ [0.1009],
+ [0.104],
+ [0.0737],
+ [0.0611],
+ [0.0533],
+ [0.0513],
+ [0.0492],
+ [0.0449],
+ [0.0382],
+ [0.0308],
+ [0.0239],
+ [0.0165],
+ [0.0081],
+ [0.0],
+ ]
+
+ # act
+ res = explainer.explain()
+
+ # assert
+ self.assertTrue(isinstance(res, ExplainabilityResult))
+ res_attention_heads = res.get_explanation(
+ component="attention_heads",
+ horizon=0,
+ )
+ self.assertTrue(len(res_attention_heads) == 48)
+ self.assertTrue(
+ (
+ res_attention_heads.time_index
+ == pd.RangeIndex(start=0, stop=48, step=1, name="time")
+ ).all()
+ )
+
+ self.assertTrue(
+ res_attention_heads.mean(1).values().round(4).tolist()
+ == expected_average_attention
+ )
+
+ def test_get_explanation(self):
+ """The get_variable_selection_weight method returns the feature importance."""
+ # arrange
+ model = deepcopy(self.models[0])
+ # fit the model with past covariates
+ np.random.seed(342)
+ model.fit(
+ self.train_ice_transformed,
+ past_covariates=self.covariates_heat_transformed,
+ verbose=True,
+ )
+
+ # call methods for debugging / development
+ explainer = TFTExplainer(model)
+
+ expl_result = explainer.explain()
+
+ # act
+ res = expl_result.get_explanation(component="attention_heads", horizon=0)
+
+ # assert
+ self.assertTrue(isinstance(res, TimeSeries))
+
+ def test_plot_attention_heads(self):
+ """The get_variable_selection_weight method returns the feature importance."""
+ # arrange
+ model = deepcopy(self.models[0])
+ # fit the model with past covariates
+ model.fit(
+ self.train_ice_transformed,
+ past_covariates=self.covariates_heat_transformed,
+ verbose=True,
+ )
+
+ # call methods for debugging / development
+ explainer = TFTExplainer(model)
+
+ expl_result = explainer.explain()
+
+ # act / assert
+ #
+ with patch("matplotlib.pyplot.show") as _:
+ _ = explainer.plot_attention_heads(expl_result, plot_type="all")
+ _ = explainer.plot_attention_heads(expl_result, plot_type="time")
+ _ = explainer.plot_attention_heads(expl_result, plot_type="heatmap")
+
+ def test_plot_attention_heads_multiple_covariates(self):
+ """The get_variable_selection_weight method returns the feature importance."""
+ # arrange
+ model = deepcopy(self.models[0])
+ # fit the model with past covariates
+ model.fit(
+ self.train_ice_transformed,
+ past_covariates=self.multiple_covariates_transformed,
+ verbose=True,
+ )
+
+ # call methods for debugging / development
+ explainer = TFTExplainer(model)
+
+ expl_result = explainer.explain()
+
+ # act / assert
+ #
+ with patch("matplotlib.pyplot.show") as _:
+ _ = explainer.plot_attention_heads(expl_result, plot_type="all")
+ _ = explainer.plot_attention_heads(expl_result, plot_type="time")
+ _ = explainer.plot_attention_heads(expl_result, plot_type="heatmap")
diff --git a/darts/timeseries.py b/darts/timeseries.py
index 71426214a3..7f6936dc27 100644
--- a/darts/timeseries.py
+++ b/darts/timeseries.py
@@ -3597,6 +3597,7 @@ def plot(
low_quantile: Optional[float] = 0.05,
high_quantile: Optional[float] = 0.95,
default_formatting: bool = True,
+ plot_all_components: Optional[bool] = False,
*args,
**kwargs,
):
@@ -3623,6 +3624,8 @@ def plot(
interval is shown if `high_quantile` is None (default 0.95).
default_formatting
Whether or not to use the darts default scheme.
+ plot_all_components
+ Whether to plot all components of the series, or only the first 10.
args
some positional arguments for the `plot()` method
kwargs
@@ -3655,14 +3658,18 @@ def plot(
if not any(lw in kwargs for lw in ["lw", "linewidth"]):
kwargs["lw"] = 2
- if self.n_components > 10:
+ n_components_to_plot = 10
+ if self.n_components > n_components_to_plot and not plot_all_components:
logger.warning(
- "Number of components is larger than 10 ({}). Plotting only the first 10 components.".format(
- self.n_components
- )
+ f"Number of components is larger than {n_components_to_plot} ({self.n_components}). "
+ f"Plotting only the first {n_components_to_plot} components."
+ f"You can overwrite this in the using the `plot_all_components` argument in plot()"
+ f"Beware that plotting all components may take a long time."
)
+ if plot_all_components:
+ n_components_to_plot = self.n_components
- for i, c in enumerate(self._xa.component[:10]):
+ for i, c in enumerate(self._xa.component[:n_components_to_plot]):
comp_name = str(c.values)
if i > 0:
diff --git a/examples/13-TFT-examples.ipynb b/examples/13-TFT-examples.ipynb
index 92799c41e5..991ce38e86 100644
--- a/examples/13-TFT-examples.ipynb
+++ b/examples/13-TFT-examples.ipynb
@@ -739,6 +739,296 @@
" transformer=transformer_ice,\n",
")"
]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Explainability\n",
+ "Let's understand what our `TFTModel` model has learned, to see the feature importance and the time weights learned we can use the ExplainTFT class:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from darts.explainability import TFTExplainer\n",
+ "\n",
+ "explainer = TFTExplainer(my_model_ice)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "We can get and plot the feature importance of the model by getting the encoder and decoder importance"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " ice cream | \n",
+ " darts_enc_fc_cyc_month_cos | \n",
+ " heater | \n",
+ " darts_enc_fc_cyc_month_sin | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " | 0 | \n",
+ " 84.6 | \n",
+ " 6.8 | \n",
+ " 4.7 | \n",
+ " 3.8 | \n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " darts_enc_fc_cyc_month_cos | \n",
+ " darts_enc_fc_cyc_month_sin | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " | 0 | \n",
+ " 89.3 | \n",
+ " 10.7 | \n",
+ "
\n",
+ " \n",
+ "
\n",
+ "