From ce98db1f6d3ef15610d11482f09c0caae6939d5a Mon Sep 17 00:00:00 2001 From: Cattes Date: Wed, 2 Nov 2022 09:33:24 +0100 Subject: [PATCH 1/7] #675 add first draft for tft_explainer --- darts/explainability/__init__.py | 1 + darts/explainability/tft_explainer.py | 215 ++++++++++++++++++++++++++ darts/models/forecasting/tft_model.py | 7 + 3 files changed, 223 insertions(+) create mode 100644 darts/explainability/tft_explainer.py 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/tft_explainer.py b/darts/explainability/tft_explainer.py new file mode 100644 index 0000000000..2343ddfe18 --- /dev/null +++ b/darts/explainability/tft_explainer.py @@ -0,0 +1,215 @@ +from typing import Optional, Sequence, Union + +import matplotlib.pyplot as plt +import pandas as pd + +from darts import TimeSeries, concatenate +from darts.dataprocessing.transformers import Scaler +from darts.datasets import IceCreamHeaterDataset +from darts.explainability.explainability import ( + ExplainabilityResult, + ForecastingModelExplainer, +) +from darts.models import TFTModel + + +class TFTExplainer(ForecastingModelExplainer): + + def __init__( + self, + model: TFTModel, + background_series: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, + background_past_covariates: Optional[ + Union[TimeSeries, Sequence[TimeSeries]] + ] = None, + background_future_covariates: Optional[ + Union[TimeSeries, Sequence[TimeSeries]] + ] = None, + ): + """ + Explainer class for the TFT model. + + Parameters + ---------- + model + The fitted TFT model to be explained. + background_series + The background series to be used for the TFT predict method. + background_past_covariates + The past covariates to be used for the TFT predict method. + background_future_covariates + The future covariates to be used for the TFT predict method. + + """ + super().__init__( + model, + background_series, + background_past_covariates, + background_future_covariates, + ) + + self._model = model + self.background_series = background_series + self.background_past_covariates = background_past_covariates + self.background_future_covariates = background_future_covariates + self._explain_results = None + + def explain( + self, + foreground_series: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, + foreground_past_covariates: Optional[ + Union[TimeSeries, Sequence[TimeSeries]] + ] = None, + foreground_future_covariates: Optional[ + Union[TimeSeries, Sequence[TimeSeries]] + ] = None, + horizons: Optional[Sequence[int]] = None, + target_components: Optional[Sequence[str]] = None, + ) -> ExplainabilityResult: + super().explain( + foreground_series, foreground_past_covariates, foreground_future_covariates + ) + if self._explain_results is None: + # without the predict call, the weights will still bet set to the last iteration of the forward() method + # of the _TFTModule class + _ = self._model.predict(n=self._model.model.output_chunk_length) + + # get the weights and the attention head from the trained model for the prediction + encoder_weights = self._model.model._encoder_sparse_weights.mean(axis=1) + decoder_weights = self._model.model._decoder_sparse_weights.mean(axis=1) + attention_heads = self._model.model._attn_out_weights.squeeze().sum(axis=1).detach() + + # format the weights as the feature importance scaled 0-100% + encoder_weights_percentage = encoder_weights.detach().numpy().mean(axis=0).round(3) * 100 + decoder_weights_percentage = decoder_weights.detach().numpy().mean(axis=0).round(3) * 100 + + # get the feature names + # TODO: This are not the correct feature names + encoder_names = self._model.model.encoder_variables + decoder_names = self._model.model.decoder_variables + + # return the explainer result to be used in other methods + expl_res = { + "decoder_weights_percentage": decoder_weights_percentage, + "decoder_names": decoder_names, + "encoder_weights_percentage": encoder_weights_percentage, + "encoder_names": encoder_names, + "attention_heads": attention_heads, + } + self._explain_results = ExplainabilityResult({"tft": expl_res}) + + return self._explain_results + + def feature_importance(self, plot=True): + if self._explain_results is None: + self.explain() + expl_res = self._explain_results.explained_forecasts["tft"] + encoder_importance = dict( + zip( + expl_res["encoder_names"], + expl_res["encoder_weights_percentage"][0], + ), + ) + decoder_importance = dict( + zip( + expl_res["decoder_names"], + expl_res["decoder_weights_percentage"][0], + ), + ) + if plot: + plt.figure(figsize=(12, 6)) + plt.barh(*zip(*encoder_importance.items())) + plt.title("Encoder feature importance") + plt.show() + plt.figure(figsize=(12, 6)) + plt.barh(*zip(*decoder_importance.items())) + plt.title("Decoder feature importance") + plt.show() + + return {"encoder_importance": encoder_importance, "decoder_importance": decoder_importance} + + def time_plots(self, plot_type="time"): + if self._explain_results is None: + self.explain() + expl_res = self._explain_results.explained_forecasts["tft"] + attention_heads = expl_res["attention_heads"] + + if plot_type == "time": + attention_matrix = attention_heads.mean(axis=0) + plt.plot(attention_matrix) + plt.xlabel("Time steps in past") + plt.ylabel("Attention") + plt.show() + if plot_type == "heatmap": + plt.imshow(attention_heads, cmap='hot', interpolation='nearest') + # plt.legend() + # plt.xticks(range(0, attention_matrix_avarege.shape[1], attention_matrix_avarege.shape[0])) + plt.xlabel("Time steps in past") + plt.ylabel("Horizon") + plt.show() + else: + raise ValueError("`plot_type` must be either 'time' or 'heatmap'") + + +### Debug Code: Ice Example from the TFT turotial ############################ +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) + +# use the last 3 years as past input data +input_chunk_length_ice = 36 + +# use `add_encoders` as we don't have future covariates +my_model_ice = 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=3, + dropout=0.1, + add_encoders={"cyclic": {"future": ["month"]}}, + add_relative_index=False, + optimizer_kwargs={"lr": 1e-3}, + random_state=42, +) + +# fit the model with past covariates +my_model_ice.fit( + train_ice_transformed, past_covariates=covariates_heat_transformed, verbose=True +) + +# call methods for debugging / development +tft_explainer = TFTExplainer( + my_model_ice, + background_series=series_ice_transformed, + background_past_covariates=covariates_heat_transformed, +) +tft_explainer.feature_importance() diff --git a/darts/models/forecasting/tft_model.py b/darts/models/forecasting/tft_model.py index da53e106d2..d9f2ed8b11 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( From 5678f7fecc9ed040c37468abe3bfa6b7149007cb Mon Sep 17 00:00:00 2001 From: Cattes Date: Tue, 22 Nov 2022 23:12:09 +0100 Subject: [PATCH 2/7] #675 add first working version of TFTExplainer class with tests --- darts/explainability/explainability_result.py | 4 +- darts/explainability/tft_explainer.py | 287 ++++++--------- .../explainability/test_tft_explainer.py | 328 ++++++++++++++++++ darts/timeseries.py | 17 +- 4 files changed, 447 insertions(+), 189 deletions(-) create mode 100644 darts/tests/explainability/test_tft_explainer.py 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 index 2343ddfe18..163730faf5 100644 --- a/darts/explainability/tft_explainer.py +++ b/darts/explainability/tft_explainer.py @@ -1,11 +1,9 @@ -from typing import Optional, Sequence, Union +from typing import Dict, Literal, Optional import matplotlib.pyplot as plt import pandas as pd -from darts import TimeSeries, concatenate -from darts.dataprocessing.transformers import Scaler -from darts.datasets import IceCreamHeaterDataset +from darts import TimeSeries from darts.explainability.explainability import ( ExplainabilityResult, ForecastingModelExplainer, @@ -14,17 +12,9 @@ class TFTExplainer(ForecastingModelExplainer): - def __init__( - self, - model: TFTModel, - background_series: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, - background_past_covariates: Optional[ - Union[TimeSeries, Sequence[TimeSeries]] - ] = None, - background_future_covariates: Optional[ - Union[TimeSeries, Sequence[TimeSeries]] - ] = None, + self, + model: TFTModel, ): """ Explainer class for the TFT model. @@ -33,183 +23,118 @@ def __init__( ---------- model The fitted TFT model to be explained. - background_series - The background series to be used for the TFT predict method. - background_past_covariates - The past covariates to be used for the TFT predict method. - background_future_covariates - The future covariates to be used for the TFT predict method. + """ + super().__init__(model) + + if not model._fit_called: + raise ValueError("The model needs to be trained before explaining it.") + + self._model = model + + 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. """ - super().__init__( - model, - background_series, - background_past_covariates, - background_future_covariates, + encoder_weights = self._model.model._encoder_sparse_weights.mean(axis=1) + decoder_weights = self._model.model._decoder_sparse_weights.mean(axis=1) + + # format the weights as the feature importance scaled 0-100% + encoder_weights_percentage = ( + encoder_weights.detach().numpy().mean(axis=0).round(3) * 100 + ) + decoder_weights_percentage = ( + decoder_weights.detach().numpy().mean(axis=0).round(3) * 100 ) - self._model = model - self.background_series = background_series - self.background_past_covariates = background_past_covariates - self.background_future_covariates = background_future_covariates - self._explain_results = None - - def explain( - self, - foreground_series: Optional[Union[TimeSeries, Sequence[TimeSeries]]] = None, - foreground_past_covariates: Optional[ - Union[TimeSeries, Sequence[TimeSeries]] - ] = None, - foreground_future_covariates: Optional[ - Union[TimeSeries, Sequence[TimeSeries]] - ] = None, - horizons: Optional[Sequence[int]] = None, - target_components: Optional[Sequence[str]] = None, - ) -> ExplainabilityResult: - super().explain( - foreground_series, foreground_past_covariates, foreground_future_covariates + # get the feature names + # TODO: These are not the correct feature names + encoder_names = self._model.model.encoder_variables + decoder_names = self._model.model.decoder_variables + + encoder_importance = pd.DataFrame( + encoder_weights_percentage, columns=encoder_names + ) + decoder_importance = pd.DataFrame( + decoder_weights_percentage, columns=decoder_names ) - if self._explain_results is None: - # without the predict call, the weights will still bet set to the last iteration of the forward() method - # of the _TFTModule class - _ = self._model.predict(n=self._model.model.output_chunk_length) - - # get the weights and the attention head from the trained model for the prediction - encoder_weights = self._model.model._encoder_sparse_weights.mean(axis=1) - decoder_weights = self._model.model._decoder_sparse_weights.mean(axis=1) - attention_heads = self._model.model._attn_out_weights.squeeze().sum(axis=1).detach() - - # format the weights as the feature importance scaled 0-100% - encoder_weights_percentage = encoder_weights.detach().numpy().mean(axis=0).round(3) * 100 - decoder_weights_percentage = decoder_weights.detach().numpy().mean(axis=0).round(3) * 100 - - # get the feature names - # TODO: This are not the correct feature names - encoder_names = self._model.model.encoder_variables - decoder_names = self._model.model.decoder_variables - - # return the explainer result to be used in other methods - expl_res = { - "decoder_weights_percentage": decoder_weights_percentage, - "decoder_names": decoder_names, - "encoder_weights_percentage": encoder_weights_percentage, - "encoder_names": encoder_names, - "attention_heads": attention_heads, - } - self._explain_results = ExplainabilityResult({"tft": expl_res}) - - return self._explain_results - - def feature_importance(self, plot=True): - if self._explain_results is None: - self.explain() - expl_res = self._explain_results.explained_forecasts["tft"] - encoder_importance = dict( - zip( - expl_res["encoder_names"], - expl_res["encoder_weights_percentage"][0], - ), + + # sort importance from high to low + encoder_importance = ( + encoder_importance.transpose().sort_values(0, ascending=False).transpose() ) - decoder_importance = dict( - zip( - expl_res["decoder_names"], - expl_res["decoder_weights_percentage"][0], - ), + decoder_importance = ( + decoder_importance.transpose().sort_values(0, ascending=False).transpose() ) + if plot: - plt.figure(figsize=(12, 6)) - plt.barh(*zip(*encoder_importance.items())) - plt.title("Encoder feature importance") - plt.show() - plt.figure(figsize=(12, 6)) - plt.barh(*zip(*decoder_importance.items())) - plt.title("Decoder feature importance") - plt.show() - - return {"encoder_importance": encoder_importance, "decoder_importance": decoder_importance} - - def time_plots(self, plot_type="time"): - if self._explain_results is None: - self.explain() - expl_res = self._explain_results.explained_forecasts["tft"] - attention_heads = expl_res["attention_heads"] - - if plot_type == "time": - attention_matrix = attention_heads.mean(axis=0) - plt.plot(attention_matrix) + # plot the encoder and decoder weights sorted descending + encoder_importance.plot(kind="bar", title="Encoder weights") + decoder_importance.plot(kind="bar", title="Decoder weights") + + return { + "encoder_importance": encoder_importance, + "decoder_importance": decoder_importance, + } + + def explain(self) -> ExplainabilityResult: + """Returns the explainability result of the TFT model.""" + super().explain() + # without the predict call, the weights will still bet set to the last iteration of the forward() method + # of the _TFTModule class + _ = self._model.predict(n=self._model.model.output_chunk_length) + + # 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 + ) plt.xlabel("Time steps in past") plt.ylabel("Attention") - plt.show() - if plot_type == "heatmap": - plt.imshow(attention_heads, cmap='hot', interpolation='nearest') - # plt.legend() - # plt.xticks(range(0, attention_matrix_avarege.shape[1], attention_matrix_avarege.shape[0])) + 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") - plt.show() else: - raise ValueError("`plot_type` must be either 'time' or 'heatmap'") - - -### Debug Code: Ice Example from the TFT turotial ############################ -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) - -# use the last 3 years as past input data -input_chunk_length_ice = 36 - -# use `add_encoders` as we don't have future covariates -my_model_ice = 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=3, - dropout=0.1, - add_encoders={"cyclic": {"future": ["month"]}}, - add_relative_index=False, - optimizer_kwargs={"lr": 1e-3}, - random_state=42, -) - -# fit the model with past covariates -my_model_ice.fit( - train_ice_transformed, past_covariates=covariates_heat_transformed, verbose=True -) - -# call methods for debugging / development -tft_explainer = TFTExplainer( - my_model_ice, - background_series=series_ice_transformed, - background_past_covariates=covariates_heat_transformed, -) -tft_explainer.feature_importance() + raise ValueError("`plot_type` must be either 'all', 'time' or 'heatmap'") diff --git a/darts/tests/explainability/test_tft_explainer.py b/darts/tests/explainability/test_tft_explainer.py new file mode 100644 index 0000000000..2a76031f05 --- /dev/null +++ b/darts/tests/explainability/test_tft_explainer.py @@ -0,0 +1,328 @@ +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 + + +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) + + # 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( + [ + { + "future_covariate_1": 68.4, + "past_covariate_0": 16.5, + "target_0": 10.6, + "future_covariate_0": 4.5, + }, + ], + ) + expected_decoder_importance = pd.DataFrame( + [ + { + "future_covariate_1": 87.8, + "future_covariate_0": 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( + [ + { + "future_covariate_1": 68.4, + "past_covariate_0": 16.5, + "target_0": 10.6, + "future_covariate_0": 4.5, + }, + ], + ) + expected_decoder_importance = pd.DataFrame( + [ + { + "future_covariate_1": 87.8, + "future_covariate_0": 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_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 = 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") diff --git a/darts/timeseries.py b/darts/timeseries.py index ac56837995..0d257e76ad 100644 --- a/darts/timeseries.py +++ b/darts/timeseries.py @@ -3073,6 +3073,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, ): @@ -3099,6 +3100,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 @@ -3131,14 +3134,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: From c22e96d53e7f3983b054f9663f7146add05160be Mon Sep 17 00:00:00 2001 From: Cattes Date: Sun, 27 Nov 2022 16:42:40 +0100 Subject: [PATCH 3/7] #675 allow passing of arguments to the explain method of the TFTExplainer --- darts/explainability/tft_explainer.py | 24 +++++++++++++++++++++--- 1 file changed, 21 insertions(+), 3 deletions(-) diff --git a/darts/explainability/tft_explainer.py b/darts/explainability/tft_explainer.py index 163730faf5..9b7a291b2c 100644 --- a/darts/explainability/tft_explainer.py +++ b/darts/explainability/tft_explainer.py @@ -86,12 +86,30 @@ def get_variable_selection_weight(self, plot=False) -> Dict[str, pd.DataFrame]: "decoder_importance": decoder_importance, } - def explain(self) -> ExplainabilityResult: - """Returns the explainability result of the TFT model.""" + 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 - _ = self._model.predict(n=self._model.model.output_chunk_length) + 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 = ( From 598b1345943d99cc7630744b859e8cd031208094 Mon Sep 17 00:00:00 2001 From: Cattes Date: Sun, 27 Nov 2022 17:21:15 +0100 Subject: [PATCH 4/7] #675 add test for multiple_covariates input to test_tft_explainer.py --- .../explainability/test_tft_explainer.py | 92 ++++++++++++++++++- 1 file changed, 91 insertions(+), 1 deletion(-) diff --git a/darts/tests/explainability/test_tft_explainer.py b/darts/tests/explainability/test_tft_explainer.py index 2a76031f05..359a445ecf 100644 --- a/darts/tests/explainability/test_tft_explainer.py +++ b/darts/tests/explainability/test_tft_explainer.py @@ -11,6 +11,7 @@ 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): @@ -48,6 +49,21 @@ class TFTExplainerTestCase(DartsBaseTestClass): 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 @@ -144,6 +160,57 @@ def test_get_variable_selection_weight(self): 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( + [ + { + "past_covariate_2": 49.1, + "past_covariate_1": 18.9, + "future_covariate_1": 14.7, + "future_covariate_0": 9.5, + "target_0": 5.4, + "past_covariate_0": 2.4, + } + ], + ) + expected_decoder_importance = pd.DataFrame( + [ + { + "future_covariate_1": 80.2, + "future_covariate_0": 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_get_variable_selection_weight_plot(self): """The get_variable_selection_weight method returns the feature importance.""" # arrange @@ -307,7 +374,7 @@ def test_get_explanation(self): def test_plot_attention_heads(self): """The get_variable_selection_weight method returns the feature importance.""" # arrange - model = self.models[0] + model = deepcopy(self.models[0]) # fit the model with past covariates model.fit( self.train_ice_transformed, @@ -326,3 +393,26 @@ def test_plot_attention_heads(self): _ = 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") From f7387a4aefc7ffff7966a3e464cd37cc3c981dcc Mon Sep 17 00:00:00 2001 From: Cattes Date: Sun, 27 Nov 2022 20:21:26 +0100 Subject: [PATCH 5/7] #675 add correct feature names to vsv --- darts/explainability/tft_explainer.py | 129 +++++++++++++----- .../explainability/test_tft_explainer.py | 62 ++++----- 2 files changed, 125 insertions(+), 66 deletions(-) diff --git a/darts/explainability/tft_explainer.py b/darts/explainability/tft_explainer.py index 9b7a291b2c..ee617930de 100644 --- a/darts/explainability/tft_explainer.py +++ b/darts/explainability/tft_explainer.py @@ -1,7 +1,8 @@ -from typing import Dict, Literal, Optional +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 ( @@ -31,6 +32,20 @@ def __init__( 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. @@ -45,45 +60,15 @@ def get_variable_selection_weight(self, plot=False) -> Dict[str, pd.DataFrame]: The variable selection weight. """ - encoder_weights = self._model.model._encoder_sparse_weights.mean(axis=1) - decoder_weights = self._model.model._decoder_sparse_weights.mean(axis=1) - - # format the weights as the feature importance scaled 0-100% - encoder_weights_percentage = ( - encoder_weights.detach().numpy().mean(axis=0).round(3) * 100 - ) - decoder_weights_percentage = ( - decoder_weights.detach().numpy().mean(axis=0).round(3) * 100 - ) - - # get the feature names - # TODO: These are not the correct feature names - encoder_names = self._model.model.encoder_variables - decoder_names = self._model.model.decoder_variables - - encoder_importance = pd.DataFrame( - encoder_weights_percentage, columns=encoder_names - ) - decoder_importance = pd.DataFrame( - decoder_weights_percentage, columns=decoder_names - ) - - # sort importance from high to low - encoder_importance = ( - encoder_importance.transpose().sort_values(0, ascending=False).transpose() - ) - decoder_importance = ( - decoder_importance.transpose().sort_values(0, ascending=False).transpose() - ) if plot: # plot the encoder and decoder weights sorted descending - encoder_importance.plot(kind="bar", title="Encoder weights") - decoder_importance.plot(kind="bar", title="Decoder weights") + self.encoder_importance.plot(kind="bar", title="Encoder weights") + self.decoder_importance.plot(kind="bar", title="Decoder weights") return { - "encoder_importance": encoder_importance, - "decoder_importance": decoder_importance, + "encoder_importance": self.encoder_importance, + "decoder_importance": self.decoder_importance, } def explain(self, **kwargs) -> ExplainabilityResult: @@ -156,3 +141,77 @@ def plot_attention_heads( 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/tests/explainability/test_tft_explainer.py b/darts/tests/explainability/test_tft_explainer.py index 359a445ecf..fbbf8f56c2 100644 --- a/darts/tests/explainability/test_tft_explainer.py +++ b/darts/tests/explainability/test_tft_explainer.py @@ -131,18 +131,18 @@ def test_get_variable_selection_weight(self): expected_encoder_importance = pd.DataFrame( [ { - "future_covariate_1": 68.4, - "past_covariate_0": 16.5, - "target_0": 10.6, - "future_covariate_0": 4.5, + "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( [ { - "future_covariate_1": 87.8, - "future_covariate_0": 12.2, + "darts_enc_fc_cyc_month_cos": 87.8, + "darts_enc_fc_cyc_month_sin": 12.2, }, ] ) @@ -160,8 +160,8 @@ def test_get_variable_selection_weight(self): 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.""" + def test_get_variable_selection_weight_plot(self): + """The get_variable_selection_weight method returns the feature importance.""" # arrange model = deepcopy(self.models[0]) @@ -169,7 +169,7 @@ def test_get_variable_selection_weight_multiple_covariates(self): np.random.seed(342) _ = model.fit( self.train_ice_transformed, - past_covariates=self.multiple_covariates_transformed, + past_covariates=self.covariates_heat_transformed, verbose=False, ) @@ -180,26 +180,25 @@ def test_get_variable_selection_weight_multiple_covariates(self): expected_encoder_importance = pd.DataFrame( [ { - "past_covariate_2": 49.1, - "past_covariate_1": 18.9, - "future_covariate_1": 14.7, - "future_covariate_0": 9.5, - "target_0": 5.4, - "past_covariate_0": 2.4, - } + "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( [ { - "future_covariate_1": 80.2, - "future_covariate_0": 19.8, + "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) + with patch("matplotlib.pyplot.show") as _: + res = explainer.get_variable_selection_weight(plot=True) # assert self.assertTrue(isinstance(res, dict)) @@ -211,8 +210,8 @@ def test_get_variable_selection_weight_multiple_covariates(self): res["decoder_importance"], expected_decoder_importance ) - def test_get_variable_selection_weight_plot(self): - """The get_variable_selection_weight method returns the feature 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]) @@ -220,7 +219,7 @@ def test_get_variable_selection_weight_plot(self): np.random.seed(342) _ = model.fit( self.train_ice_transformed, - past_covariates=self.covariates_heat_transformed, + past_covariates=self.multiple_covariates_transformed, verbose=False, ) @@ -231,25 +230,26 @@ def test_get_variable_selection_weight_plot(self): expected_encoder_importance = pd.DataFrame( [ { - "future_covariate_1": 68.4, - "past_covariate_0": 16.5, - "target_0": 10.6, - "future_covariate_0": 4.5, - }, + "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( [ { - "future_covariate_1": 87.8, - "future_covariate_0": 12.2, + "darts_enc_fc_cyc_month_cos": 80.2, + "darts_enc_fc_cyc_month_sin": 19.8, }, ] ) # act - with patch("matplotlib.pyplot.show") as _: - res = explainer.get_variable_selection_weight(plot=True) + res = explainer.get_variable_selection_weight(plot=False) # assert self.assertTrue(isinstance(res, dict)) From 68e384d6ed31837915e0aa491be2b3420c4baa38 Mon Sep 17 00:00:00 2001 From: Cattes Date: Sun, 27 Nov 2022 21:12:12 +0100 Subject: [PATCH 6/7] #675 add TFTExplainer to 13-TFT-examples.ipynb --- darts/explainability/tft_explainer.py | 9 +- .../explainability/test_tft_explainer.py | 3 +- examples/13-TFT-examples.ipynb | 290 ++++++++++++++++++ 3 files changed, 299 insertions(+), 3 deletions(-) diff --git a/darts/explainability/tft_explainer.py b/darts/explainability/tft_explainer.py index ee617930de..de9c8fc129 100644 --- a/darts/explainability/tft_explainer.py +++ b/darts/explainability/tft_explainer.py @@ -119,13 +119,18 @@ def plot_attention_heads( ): """Plots the attention heads of the TFT model.""" attention_heads = expl_result.get_explanation( - component="attention_heads", horizon=0 + component="attention_heads", + horizon=0, ) if plot_type == "all": fig = plt.figure() attention_heads.plot( - label="Attention Head", plot_all_components=True, figure=fig + 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": diff --git a/darts/tests/explainability/test_tft_explainer.py b/darts/tests/explainability/test_tft_explainer.py index fbbf8f56c2..b16808e8e6 100644 --- a/darts/tests/explainability/test_tft_explainer.py +++ b/darts/tests/explainability/test_tft_explainer.py @@ -333,7 +333,8 @@ def test_explain(self): # assert self.assertTrue(isinstance(res, ExplainabilityResult)) res_attention_heads = res.get_explanation( - component="attention_heads", horizon=0 + component="attention_heads", + horizon=0, ) self.assertTrue(len(res_attention_heads) == 48) self.assertTrue( 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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ice creamdarts_enc_fc_cyc_month_cosheaterdarts_enc_fc_cyc_month_sin
084.66.84.73.8
\n", + "
" + ], + "text/plain": [ + " ice cream darts_enc_fc_cyc_month_cos heater darts_enc_fc_cyc_month_sin\n", + "0 84.6 6.8 4.7 3.8" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
darts_enc_fc_cyc_month_cosdarts_enc_fc_cyc_month_sin
089.310.7
\n", + "
" + ], + "text/plain": [ + " darts_enc_fc_cyc_month_cos darts_enc_fc_cyc_month_sin\n", + "0 89.3 10.7" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "feature_importance = explainer.get_variable_selection_weight()\n", + "display(feature_importance[\"encoder_importance\"])\n", + "display(feature_importance[\"decoder_importance\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can also directly plot the feature importance" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "feature_importance = explainer.get_variable_selection_weight(plot=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To understand the time weights learned by the model we can use the attention heads of the TFT model.\n", + "\n", + "We first get the explainability result that contains the attention head and then use the `plot_attention_heads` method to plot it. \n", + "The function provides three different plots\n", + "1. `plot_type = \"time\"` - plots the attention weights for each time step\n", + "2. `plot_type = \"heatmap\"` - plots all the attention weights for each time step as a heatmap\n", + "3. `plot_type = \"all\"` - plot all attention heads individually" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ee66a9c5aa314e5493945124d7044865", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Predicting: 4it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "expl_result = explainer.explain()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "explainer.plot_attention_heads(expl_result, plot_type=\"time\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "explainer.plot_attention_heads(expl_result, plot_type=\"heatmap\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "explainer.plot_attention_heads(expl_result, plot_type=\"all\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can also get the attention_heads from the result of the `explain` method directly using the `get_explanation()` method." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "darts.timeseries.TimeSeries" + ] + }, + "execution_count": 53, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "attention_heads = expl_result.get_explanation(component=\"attention_heads\", horizon=0)\n", + "type(attention_heads)" + ] } ], "metadata": { From 160d19601e287a75bffb35f366ccf7f63d36cc2a Mon Sep 17 00:00:00 2001 From: Cattes Date: Sun, 27 Nov 2022 22:33:05 +0100 Subject: [PATCH 7/7] #675 add CHANGELOG.md entry for the TFTExplainer class --- CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) 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)