diff --git a/.github/workflows/Build.yml b/.github/workflows/Build.yml
index 980bffc..c923cdf 100644
--- a/.github/workflows/Build.yml
+++ b/.github/workflows/Build.yml
@@ -287,13 +287,17 @@ jobs:
       - name: Step 6 - Test TSSaliencyExplainer
         run: python ./tests/tssaliency/test_tssaliency.py
 
+      # tslime deps are already satisfied.
+      - name: Step 7 - Test TSLimeExplainer
+        run: python ./tests/tslime/test_tslime.py
+
   build-imd-on-py38-310:
     # The type of runner that the job will run on
     runs-on: "${{ matrix.os }}"
     strategy:
       fail-fast: false
       matrix:
-#        os: [ubuntu-18.04, ubuntu-latest, macos-latest, windows-latest]
+        #        os: [ubuntu-18.04, ubuntu-latest, macos-latest, windows-latest]
         os: [ubuntu-20.04]
         python-version: ["3.10"]
 
diff --git a/aix360/algorithms/tslime/__init__.py b/aix360/algorithms/tslime/__init__.py
new file mode 100644
index 0000000..43fc589
--- /dev/null
+++ b/aix360/algorithms/tslime/__init__.py
@@ -0,0 +1 @@
+from .tslime import TSLimeExplainer
diff --git a/aix360/algorithms/tslime/surrogate.py b/aix360/algorithms/tslime/surrogate.py
new file mode 100644
index 0000000..239f040
--- /dev/null
+++ b/aix360/algorithms/tslime/surrogate.py
@@ -0,0 +1,50 @@
+from abc import abstractmethod
+import numpy as np
+from sklearn.linear_model import LinearRegression
+
+
+class LinearSurrogateModel:
+    """Linear Interpretable Surrogate Model Wrapper."""
+
+    def __init__(self, model):
+        self.model = model
+
+    def fit(self, *args, **kwargs):
+        self.model.fit(*args, **kwargs)
+
+    def predict(self, *args, **kwargs):
+        return self.model.predict(*args, **kwargs)
+
+    @abstractmethod
+    def get_weights(self):
+        pass
+
+
+class LinearRegressionSurrogate(LinearSurrogateModel):
+    """Linear Interpretable Surrogate Model using LinearRegression from Scikit-Learn."""
+
+    def __init__(self):
+        super(LinearRegressionSurrogate, self).__init__(LinearRegression())
+
+    def get_weights(self):
+        return self.model.coef_
+
+
+def linear_surrogate_weights(
+    x_perturbations: np.ndarray,
+    y_perturbations: np.ndarray,
+    surrogate: LinearSurrogateModel = None,
+):
+    """Function to compute weights from a linear interpretable model
+    using provided time series pertubations."""
+
+    if surrogate is None:
+        surrogate = LinearRegressionSurrogate()
+
+    surrogate.fit(
+        x_perturbations.reshape(x_perturbations.shape[0], -1),
+        y_perturbations.reshape(y_perturbations.shape[0], -1),
+    )
+
+    # retrieve weights
+    return surrogate, surrogate.get_weights()
diff --git a/aix360/algorithms/tslime/tslime.py b/aix360/algorithms/tslime/tslime.py
new file mode 100644
index 0000000..4501e8b
--- /dev/null
+++ b/aix360/algorithms/tslime/tslime.py
@@ -0,0 +1,217 @@
+import warnings
+import numpy as np
+import pandas as pd
+from typing import Union, List, Callable
+from aix360.algorithms.tslbbe import TSLocalBBExplainer
+from aix360.algorithms.tsutils.tsframe import tsFrame, to_np_array
+from aix360.algorithms.tslime.surrogate import (
+    linear_surrogate_weights,
+    LinearSurrogateModel,
+)
+from aix360.algorithms.tsutils.tsperturbers.perturbed_data_generator import (
+    PerturbedDataGenerator,
+)
+from aix360.algorithms.tsutils.tsperturbers.tsperturber import (
+    TSPerturber,
+    BlockSelector,
+)
+
+
+class TSLimeExplainer(TSLocalBBExplainer):
+    """Time Series Local Interpretable Model-agnostic Explainer (TSLime) is a model-agnostic local time series
+    explainer. LIME (Locally interpretable Model agnostic explainer) is a popular algorithm for local
+    explanation. LIME explains the model behavior by approximating the model response with linear models.
+    LIME algorithm specifically assumes tabular data format, where each row is a data point, and columns
+    are features. A generalization of LIME algorithm for image data uses super pixel based perturbation.
+    TSLIME generalizes LIME algorithm for time series context.
+
+    TSLIME uses time series perturbation methods to produce a local input perturbation, and linear model
+    surrogate which best approximates the model response. TSLime produces an interpretable explanation.
+    The explanation weights produced by the TSLime explanation indicates model local sensitivity.
+
+    References:
+        .. [##] Marco Tulio Ribeiro et al. '"Why Should I Trust You?": Explaining the Predictions of Any Classifier'
+            https://arxiv.org/abs/1602.04938
+    """
+
+    def __init__(
+        self,
+        model: Callable,
+        input_length: int,
+        n_perturbations: int = 2000,
+        relevant_history: int = None,
+        perturbers: List[Union[TSPerturber, dict]] = None,
+        local_interpretable_model: LinearSurrogateModel = None,
+        random_seed: int = None,
+    ):
+        """Initializer for TSLimeExplainer
+
+        Args:
+            model (Callable): Callable object produces a prediction as numpy array
+                for a given input as numpy array.
+            input_length (int): Input (history) length used for input model.
+            n_perturbations (int): Number of perturbed instance for TSExplanation. Defaults to 25.
+            relevant_history (int): Interested window size for explanations. The explanation is
+                computed for selected latest window of length `relevant_history`. If `input_length=20`
+                and `relevant_history=10`, explanation is computed for last 10 time points. If None,
+                relevant_history is set to input_length. Defaults to None.
+            perturbers (List[TSPerturber, dict]): data perturbation algorithm specification by TSPerturber
+                instance or dict. Allowed values for "type" key in dictionary are block-bootstrap, frequency,
+                moving-average, shift. Block-bootstrap split the time series into contiguous
+                chunks called blocks, for each block noise is estimated and noise is exchanged
+                and added to the signal between randomly selected blocks. Moving-average perturbation
+                maintains the moving mean of the time series data with the specified window length,
+                but add perturbed noise with similar distribution as the data. Frequency
+                perturber performs FFT on the noise, and removes random high frequency
+                components from the noise estimates. Number of frequencies to be removed
+                is specified by the truncate_frequencies argument. Shift perturber adds
+                random upward or downward shift in the data value over time continuous
+                blocks. If not provided default perturber is block-bootstrap. Defaults to None.
+            local_interpretable_model (LinearSurrogateModel): Local interpretable model, a surrogate that
+                is to be trained on the given input time series neighborhood. This model is used to provide
+                local weights for each time point in the selected timeseries. If None, sklearn's Linear Regression
+                model, aix360.algorithms.tslime.surrogate.LinearRegressionSurrogate is used. Defaults to None.
+            random_seed (int): random seed to get consistent results. Refer to numpy random state.
+                Defaults to None.
+        """
+        self.model = model
+
+        if perturbers is None:
+            perturbers = [
+                dict(type="block-bootstrap"),
+            ]
+
+        block_selector = BlockSelector(start=-input_length, end=None)
+        perturber = PerturbedDataGenerator(
+            perturber_engines=perturbers,
+            block_selector=block_selector,
+        )
+        self._parameters = dict()
+
+        # Input Specification
+        self.input_length = input_length
+
+        # Surrogate training params
+        self.local_interpretable_model = local_interpretable_model
+        self.n_perturbations = n_perturbations
+        self.perturber = perturber
+
+        # Explanation params
+        if relevant_history is None:
+            relevant_history = input_length
+
+        self.relevant_history = relevant_history
+        self.random_seed = random_seed
+
+    def get_params(self):
+        return self._parameters.copy()
+
+    def set_params(self, *argv, **kwargs):
+        self._parameters.update(kwargs)
+        return self
+
+    def _ts_perturb(self, x):
+        # create perturbations
+        x_perturbations = None
+        y_perturbations = None
+
+        x_perturbations, _ = self.perturber.fit_transform(
+            x, None, n=self.n_perturbations
+        )
+
+        x_perturbations = np.asarray(x_perturbations).astype("float")
+        return x_perturbations
+
+    def _batch_predict(self, x_perturbations):
+        f_predict_samples = None
+
+        try:
+            f_predict_samples = self.model(x_perturbations)
+        except Exception as ex:
+            warnings.warn(
+                "Batch scoring failed with error: {}. Scoring sequentially...".format(
+                    ex
+                )
+            )
+            f_predict_samples = [
+                self.model(x_perturbations[i]) for i in range(x_perturbations.shape[0])
+            ]
+            f_predict_samples = np.array(f_predict_samples)
+
+        return f_predict_samples
+
+    def explain_instance(self, ts: tsFrame, **explain_params):
+        """Explain the prediction made by the time series model at a certain point in time
+        (**local explanation**).
+
+        Args
+            ts (tsFrame): Input time series signal in ``tsFrame`` format. This can
+                be generated using :py:mod:`aix360.algorithms.tsframe.tsFrame`.
+                A ``tsFrame`` is a pandas ``DataFrame`` indexed by ``Timestamp`` objects
+                (that is ``DatetimeIndex``). Each column corresponds to an input feature.
+            explain_params: Arbitrary explainer parameters.
+
+        Returns:
+            explanation (Union[List[Dict], Dict]): Dictionary with keys: input_data, history_weights,
+                model_prediction, surrogate_prediction, x_perturbations, y_perturbations.
+        """
+        return super(TSLimeExplainer, self).explain_instance(
+            ts=ts, ts_related=None, **explain_params
+        )
+
+    def _explain_instance(
+        self,
+        ts: tsFrame,
+        **explain_params,
+    ):
+        # for consistent results. Is it possible here?
+        np.random.seed(self.random_seed)
+
+        ### input validation
+        if ts.shape[0] < self.input_length:
+            raise ValueError(
+                "Error: expecting input length {} but found {}.".format(
+                    self.input_length, ts.shape[0]
+                )
+            )
+        xc = ts[-self.input_length :]
+        xc = to_np_array(xc)
+
+        ### generate time series perturbations
+        x_perturbations = self._ts_perturb(x=xc)
+
+        ### generate y
+        y_perturbations = self._batch_predict(x_perturbations)
+        if y_perturbations is None:
+            raise Exception(
+                "Model prediction could not be computed for gradient samples."
+            )
+
+        y_perturbations = np.asarray(y_perturbations).astype("float")
+
+        ### select k time points - relevant_history
+        x_perturbations = x_perturbations[
+            :, -self.relevant_history :
+        ]  # consider only k time points
+
+        xc_relevant = xc[-self.relevant_history :, :].reshape(1, -1)
+
+        ### compute weights using a linear model
+        surrogate, history_weights = linear_surrogate_weights(
+            surrogate=self.local_interpretable_model,
+            x_perturbations=x_perturbations,
+            y_perturbations=y_perturbations,
+        )
+
+        model_prediction = self._batch_predict(xc)
+
+        surrogate_prediction = surrogate.predict(xc_relevant)
+        explanation = {
+            "input_data": ts,
+            "model_prediction": model_prediction,
+            "surrogate_prediction": surrogate_prediction,
+            "history_weights": history_weights.reshape(self.relevant_history, -1),
+            "x_perturbations": x_perturbations,
+            "y_perturbations": y_perturbations,
+        }
+        return explanation
diff --git a/aix360/algorithms/tssaliency/tssaliency.py b/aix360/algorithms/tssaliency/tssaliency.py
index 40ba80b..1ed4d86 100644
--- a/aix360/algorithms/tssaliency/tssaliency.py
+++ b/aix360/algorithms/tssaliency/tssaliency.py
@@ -115,7 +115,7 @@ def explain_instance(self, ts: tsFrame, **explain_params):
 
     def _explain_instance(
         self,
-        ts: Union["tsFrame", np.ndarray],
+        ts: tsFrame,
         **explain_params,
     ):
         # fix seed for consistent results
diff --git a/aix360/algorithms/tsutils/tsperturbers/block_bootstrap_perturber.py b/aix360/algorithms/tsutils/tsperturbers/block_bootstrap_perturber.py
index a9e1144..092ad74 100644
--- a/aix360/algorithms/tsutils/tsperturbers/block_bootstrap_perturber.py
+++ b/aix360/algorithms/tsutils/tsperturbers/block_bootstrap_perturber.py
@@ -68,7 +68,7 @@ def _transform(
         block_swap = self._parameters.get("block_swap")
 
         x_res = [self._residual.copy() for _ in range(n_perturbations)]
-        margin = self._residual.shape[0] - block_length
+        margin = self._residual.shape[0] - block_length + 1
         for _ in range(block_swap):
             if block_selector is None:
                 from_point = np.random.randint(
diff --git a/aix360/algorithms/tsutils/tsperturbers/perturber_utils.py b/aix360/algorithms/tsutils/tsperturbers/perturber_utils.py
index 8b470b5..c22ee0f 100644
--- a/aix360/algorithms/tsutils/tsperturbers/perturber_utils.py
+++ b/aix360/algorithms/tsutils/tsperturbers/perturber_utils.py
@@ -25,11 +25,11 @@ def ts_rolling_mean(
     if isinstance(ts, np.ndarray):
         if len(ts.shape) == 1:
             ts = ts.reshape(-1, 1)
-        ts = ts.astype("float32")
+        ts = ts.astype("float")
         n_obs, n_vars = ts.shape
         den = np.convolve(
-            np.ones(n_obs), np.ones(window_size, dtype="float32"), "same"
-        ).astype("float32")
+            np.ones(n_obs), np.ones(window_size, dtype="float"), "same"
+        ).astype("float")
         df = np.asarray(
             [
                 np.convolve(ts[:, i], np.ones(window_size), "same") / den
@@ -51,8 +51,8 @@ def ts_split_mean_residual(
     format.
 
     Args:
-        ts (Union[tsFrame, numpy ndarray]): input time series as dataframe or numpy array
-        window_size (int): numer of observation for averaging.
+        ts (Union[tsFrame, numpy ndarray]): input time series as tsFrame or numpy array
+        window_size (int): number of observations for averaging.
 
     Returns:
         tuple (Union[Tuple[numpy ndarray, numpy ndarray], Tuple[tsFrame, tsFrame]]): depending
diff --git a/aix360/datasets/sunspots_dataset.py b/aix360/datasets/sunspots_dataset.py
index 47e2b27..24d4470 100644
--- a/aix360/datasets/sunspots_dataset.py
+++ b/aix360/datasets/sunspots_dataset.py
@@ -14,10 +14,12 @@ class SunspotDataset:
 
     References:
         .. [#1] Andrews, D. F. and Herzberg, A. M., "Data: A Collection of Problems from
-        Many Fields for the Student and Research Worker,"
-        New York: Springer-Verlag, 1985.
+            Many Fields for the Student and Research Worker,"
+            New York: Springer-Verlag, 1985.
         .. [#2] https://stat.ethz.ch/R-manual/R-devel/library/datasets/html/sunspots.html
         .. [#3] https://r-data.pmagunia.com/dataset/r-dataset-package-datasets-sunspots
+        .. [#4] Avishek Pal, PKS Prakash, "Practical Time Series Analysis"
+            https://github.com/PacktPublishing/Practical-Time-Series-Analysis/
 
     """
 
@@ -30,16 +32,17 @@ def __init__(self):
         self.data_file = os.path.realpath(
             os.path.join(self.data_folder, "sunspots.csv")
         )
-        sunspots_url = (
-            "https://r-data.pmagunia.com/system/files/datasets/dataset-61024.csv"
-        )
+        sunspots_url = "https://raw.githubusercontent.com/PacktPublishing/Practical-Time-Series-Analysis/master/Data%20Files/monthly-sunspot-number-zurich-17.csv"
 
         if not os.path.exists(self.data_file):
             response = requests.get(sunspots_url)
-            data = pd.read_csv(StringIO(response.text))
-            data["time"] = pd.to_datetime(
-                data["time"].apply(self._convert_to_date), format="%Y-%m"
+            data = pd.read_csv(
+                StringIO(response.text),
+                skiprows=0,
+                nrows=2820,
             )
+            data.columns = ["time", "sunspots"]
+            data["time"] = pd.to_datetime(data["time"], format="%Y-%m")
 
             data.to_csv(self.data_file, index=False)
 
diff --git a/docs/tslbbe.rst b/docs/tslbbe.rst
index c0915d3..23fb4c5 100644
--- a/docs/tslbbe.rst
+++ b/docs/tslbbe.rst
@@ -12,3 +12,9 @@ Time Series Saliency (TSSaliency) Explainer
 
 .. autoclass:: aix360.algorithms.tssaliency.tssaliency.TSSaliencyExplainer
    :members:
+
+Time Series Local Interpretable Model-agnostic Explainer (TSLime)
+-------------------------------------------------------------------------
+
+.. autoclass:: aix360.algorithms.tslime.tslime.TSLimeExplainer
+   :members:
diff --git a/examples/README.md b/examples/README.md
index d811b85..f7b5352 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -39,3 +39,7 @@ the user through the various steps of the notebook.
 - [TSSaliencyExplainer using FordA dataset](./tssaliency/tssaliency_univariate_demo.ipynb)[[on nbviewer](https://nbviewer.org/github/Trusted-AI/AIX360/blob/master/examples/tssaliency/tssaliency_univariate_demo.ipynb)]
 
 - [TSSaliencyExplainer using Climate dataset](./tssaliency/tssaliency_multivariate_demo.ipynb)[[on nbviewer](https://nbviewer.org/github/Trusted-AI/AIX360/blob/master/examples/tssaliency/tssaliency_multivariate_demo.ipynb)]
+
+- [TSLimeExplainer using FordA dataset](./tslime/tslime_univariate_demo.ipynb)[[on nbviewer](https://nbviewer.org/github/Trusted-AI/AIX360/blob/master/examples/tslime/tslime_univariate_demo.ipynb)]
+
+- [TSLimeExplainer using Climate dataset](./tslime/tslime_multivariate_demo.ipynb)[[on nbviewer](https://nbviewer.org/github/Trusted-AI/AIX360/blob/master/examples/tslime/tslime_multivariate_demo.ipynb)]
diff --git a/examples/tsice/tsice_demo.ipynb b/examples/tsice/tsice_demo.ipynb
index 9a198af..3485801 100644
--- a/examples/tsice/tsice_demo.ipynb
+++ b/examples/tsice/tsice_demo.ipynb
@@ -1,6 +1,7 @@
 {
  "cells": [
   {
+   "attachments": {},
    "cell_type": "markdown",
    "id": "e8fe6486",
    "metadata": {},
@@ -11,6 +12,7 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "id": "e5ce6a26-07c8-4de2-897f-b81dc25a7ee5",
    "metadata": {},
@@ -30,6 +32,7 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "id": "3f02eae5-f871-457a-9750-526581319e8b",
    "metadata": {},
@@ -66,6 +69,7 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "id": "8c197693",
    "metadata": {},
@@ -73,7 +77,7 @@
     "<a id='load_dataset'></a>\n",
     "### Load Sunspot Dataset\n",
     "- This example notebook uses sunspot dataset, a univariate dataset.\n",
-    "- The `sunspots` dataset loads the monthly **sunspots** (`df`) recorded between the year 1749 to 1983. For more information on sunspots, you can refer to [R-sunspots](https://r-data.pmagunia.com/dataset/r-dataset-package-datasets-sunspots) and [other articles](https://en.wikipedia.org/wiki/Sunspot).\n",
+    "- The `sunspots` dataset loads the monthly **sunspots** (`df`) recorded between the year 1749 to 1983. For more information on sunspots, you can refer to [Avishek Pal, PKS Prakash, \"Practical Time Series Analysis\"](https://github.com/PacktPublishing/Practical-Time-Series-Analysis/), [R-sunspots](https://r-data.pmagunia.com/dataset/r-dataset-package-datasets-sunspots) and [other articles](https://en.wikipedia.org/wiki/Sunspot).\n",
     "- TSICE expects the input time series in `tsFrame` data format. `aix360` exposes `tsFrame` utility that converts a regular time series to `DateTimeIndex` indexed `pd.DataFrame`.\n",
     "- Split the univariate time series into sequential train and test subsets using `sklearn.model_selection.train_test_split` without shuffle."
    ]
@@ -154,6 +158,7 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "id": "42904a77",
    "metadata": {},
@@ -199,6 +204,7 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "id": "c13f4180",
    "metadata": {},
@@ -256,6 +262,7 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "id": "2dec0adf-97c8-4dee-ba59-3b78999eb8c0",
    "metadata": {},
@@ -282,6 +289,7 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "id": "0d1310d4-830e-49a2-8bd7-2283d75b6479",
    "metadata": {},
@@ -310,6 +318,7 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "id": "f6a5c4cb-02c6-469d-8137-e921a49d0d54",
    "metadata": {},
@@ -345,6 +354,7 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "id": "2c1f6cc6",
    "metadata": {},
@@ -391,6 +401,7 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "id": "d305b238",
    "metadata": {},
@@ -416,6 +427,7 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "id": "e85da965-0438-42e6-a466-88fbd08aa0af",
    "metadata": {},
@@ -451,6 +463,7 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "id": "4e7d0465-eac4-4cc3-b60b-31dbc73e0353",
    "metadata": {},
@@ -489,6 +502,7 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "id": "b829a75b-dffb-4759-8ce9-334380707f83",
    "metadata": {},
@@ -497,6 +511,7 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "id": "3ed6b790-0fd3-4186-8c12-bcf1e14521b4",
    "metadata": {},
@@ -542,6 +557,7 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "id": "c33ac779-b97a-4f26-955f-d24577f2f459",
    "metadata": {},
@@ -565,6 +581,7 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "id": "5f738f01-85b2-4b1d-a66f-45ec66746198",
    "metadata": {},
@@ -600,6 +617,7 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "id": "844c5792-8130-4828-9330-9c3372ceb20e",
    "metadata": {},
@@ -634,6 +652,7 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "id": "0852152e-8c82-4af5-8a6e-416c279697f4",
    "metadata": {},
diff --git a/examples/tslime/tslime_multivariate_demo.ipynb b/examples/tslime/tslime_multivariate_demo.ipynb
new file mode 100644
index 0000000..7d1930f
--- /dev/null
+++ b/examples/tslime/tslime_multivariate_demo.ipynb
@@ -0,0 +1,658 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "48f88759-48eb-4f4f-a896-3b60aa00e003",
+   "metadata": {},
+   "source": [
+    "# TSLimeExplainer For Multivariate\n",
+    "\n",
+    "Advanced time series models are complex and often hard to interpret. Time Series Local Interpretable Model-agnostic Explainer (TSLime) is a model-agnostic local time series explainer. It explains a time series model behavior using an approximate linear model as surrogate. TSLime approximates model response by evaluating the model over time series samples generated by applying time series perturbation techniques. The explanation produced by TSLime is the weights of the linear model over different time point observations. The relative signed value of the explanation is indicative of model sensitivity at temporal resolution. TSLime uses the recent time context length for the local surrogate model fitting.\n",
+    "\n",
+    "TSLime supports univariate and multi-variate use cases related to forecasting, time series classification, regression and anomaly detection. This notebook demonstrates usage of TSLimeExplainer for Multi-variate data using [Jena Climate dataset](https://www.bgc-jena.mpg.de/wetter/) recorded by Max Planck Institute for Biogeochemistry."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "45c39595-265b-4480-b6c1-20339113ed33",
+   "metadata": {},
+   "source": [
+    "<a id='notebook_workflow'></a>\n",
+    "## Notebook Workflow\n",
+    "- [Imports](#imports)\n",
+    "- [Load Dataset](#load_dataset)\n",
+    "- [Train Forecaster](#train_forecaster)\n",
+    "- [Initialize TSLimeExplainer](#initialize_tslime)\n",
+    "- [Compute Explanation](#compute_explanation)\n",
+    "- [Plot Explanation](#plot_explanation)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "21e3e84e-ece2-43bb-a11c-9d7dff21bc13",
+   "metadata": {},
+   "source": [
+    "<a id='imports'></a>\n",
+    "### Imports\n",
+    "\n",
+    "The example model is a pre-trained keras model and hosted on huggingface hub. So, this notebook requires to install tensorflow 2.4+ and huggingface_hub packages."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "95272a35-1111-4140-8a07-c0f15e78145d",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "# to suppress unrelated tensorflow warnings while importing aix360.datasets\n",
+    "os.environ[\"TF_CPP_MIN_LOG_LEVEL\"] = \"3\"\n",
+    "\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "from tensorflow import keras\n",
+    "from huggingface_hub import from_pretrained_keras\n",
+    "from aix360.datasets import ClimateDataset\n",
+    "from aix360.algorithms.tsutils.tsframe import tsFrame\n",
+    "from aix360.algorithms.tslime.tslime import TSLimeExplainer\n",
+    "from aix360.algorithms.tsutils.model_wrappers import Tensor_Based_Forecaster\n",
+    "from huggingface_hub.utils import logging as h_logging\n",
+    "\n",
+    "# huggingface hub warnings\n",
+    "h_logging.set_verbosity_error()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6a33c82c-5947-4ae2-9a80-87a27032db1d",
+   "metadata": {},
+   "source": [
+    "<a id='load_dataset'></a>\n",
+    "### Load Dataset\n",
+    "\n",
+    "The dataset is weather readings recorded at the Weather Station at the Max Planck Institute for Biogeochemistry in Jena, Germany from 2009 to 2016. It can be obtained from [Max Planck Institute for Biogeochemistry](https://www.bgc-jena.mpg.de/wetter/), [Keras examples](https://github.com/keras-team/keras-io/blob/master/examples/timeseries/timeseries_weather_forecasting.py) or [Kaggle](https://www.kaggle.com/stytch16/jena-climate-2009-2016).\n",
+    "\n",
+    "As described in the prior links, the dataset consists of 14 variables (temperature, pressure etc.) measured every 10 minutes. The data is aggregated for an hour for analysis. The pre-trained model used in this notebook, is trained on selected (7) features with 120 hours as past window and forecasts temperature after 12 hours in Celcius. More details on dataset are available in [Keras examples](https://github.com/keras-team/keras-io/blob/master/examples/timeseries/timeseries_weather_forecasting.py)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "de16300d-2ea7-4bbf-94c4-ac9c36a36d7a",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "datasets = ClimateDataset().load_data(return_train=False, test_start=100551)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "fccb240b-802a-4e2b-88b2-cd7ee0902eac",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "df = datasets[\"df\"]\n",
+    "selected_feature_columns = datasets[\"selected_feature_columns\"]\n",
+    "selected_feature_names = datasets[\"selected_feature_names\"]\n",
+    "sequence_length = datasets[\"sequence_length\"]\n",
+    "x_test = datasets[\"x_test\"]\n",
+    "y_test = datasets[\"y_test\"]\n",
+    "timestamps = datasets[\"timestamps\"]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "c396925b-3aa9-4641-8945-02bce075f3bb",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1500x1400 with 7 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib\n",
+    "\n",
+    "np.random.seed(242)\n",
+    "cmap = matplotlib.cm.brg\n",
+    "colors = cmap(np.random.choice(np.arange(256), len(selected_feature_columns)))\n",
+    "\n",
+    "fig = plt.figure(figsize=(15,14))\n",
+    "\n",
+    "for i, feature_col in enumerate(selected_feature_columns):\n",
+    "    feature_data = df[feature_col]\n",
+    "    feature_data.index = timestamps\n",
+    "    ax = fig.add_subplot(int((len(selected_feature_columns) + 1) / 2), 2, i+1)\n",
+    "    ax = feature_data.plot(\n",
+    "        ax=ax,\n",
+    "        color=colors[i],\n",
+    "        title=\"{} - {}\".format(selected_feature_names[i], feature_col),\n",
+    "        rot=25,\n",
+    "    )\n",
+    "plt.tight_layout(rect=[0, 0.03, 1, 0.95])\n",
+    "\n",
+    "fig.suptitle(\"Jena Climate Dataset 2009 to 2016\", fontsize=\"x-large\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1e50af8b-2ca8-45e4-8a6f-48492ce7a084",
+   "metadata": {},
+   "source": [
+    "<a id='train_forecaster'></a>\n",
+    "### Download Pre-Trained Model\n",
+    "For simplicity, use a pre-trained model from Keras/HuggingFace.\n",
+    "\n",
+    "The pre-trained model is from: https://keras.io/examples/timeseries/timeseries_weather_forecasting/\n",
+    "The Hugging face model url is: https://huggingface.co/keras-io/timeseries_forecasting_for_weather\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "4660c52f-b3e8-4848-b2c0-372673dc9495",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "7b017ebe6478433b90d50247d5fc4be7",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Fetching 9 files:   0%|          | 0/9 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "model = from_pretrained_keras(\"keras-io/timeseries_forecasting_for_weather\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "f39c0f14-ede8-444b-afb0-61cc78780ad7",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model: \"model\"\n",
+      "_________________________________________________________________\n",
+      " Layer (type)                Output Shape              Param #   \n",
+      "=================================================================\n",
+      " input_1 (InputLayer)        [(None, 120, 7)]          0         \n",
+      "                                                                 \n",
+      " lstm (LSTM)                 (None, 32)                5120      \n",
+      "                                                                 \n",
+      " dense (Dense)               (None, 1)                 33        \n",
+      "                                                                 \n",
+      "=================================================================\n",
+      "Total params: 5,153\n",
+      "Trainable params: 5,153\n",
+      "Non-trainable params: 0\n",
+      "_________________________________________________________________\n"
+     ]
+    }
+   ],
+   "source": [
+    "model.summary()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f13daba6-29c7-4143-be7f-333b6d792201",
+   "metadata": {},
+   "source": [
+    "As the model inputs are tensor based, we are selecting Tensor_Based_Forecaster from aix360 to wrap the model. The wrapper manages the input and output shapes between the original model and the explainer."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "cd241404-5615-4342-a8e0-f5fd9f282833",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "f_model = Tensor_Based_Forecaster(model=model, forecast_function=\"predict\", input_length=sequence_length, n_features = len(selected_feature_columns))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b7304d90-1085-4aa5-9c85-cb86776e3d03",
+   "metadata": {},
+   "source": [
+    "Model accuracy for selected test samples."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "62c4f0e5-b185-4b53-b77b-a7836c376025",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "MAPE for 10 samples: 0.19223103294346963.\n"
+     ]
+    }
+   ],
+   "source": [
+    "from sklearn.metrics import mean_absolute_percentage_error\n",
+    "\n",
+    "test_sample_size = 10\n",
+    "y_pred = f_model.predict(x_test[0:test_sample_size], verbose = 0)\n",
+    "print(\"MAPE for {} samples: {}.\".format(test_sample_size, mean_absolute_percentage_error(y_test[0:test_sample_size], y_pred)))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "64b6fb0f-c9dd-4243-bd5b-c6c44d8160cd",
+   "metadata": {},
+   "source": [
+    "<a id='initialize_tslime'></a>\n",
+    "### Initialize TSLimeExplainer\n",
+    "\n",
+    "`TSLimeExplainer` requires a model function which is to be explained and input (history) length used for the input model. The explanation is for selected latest window of length `relevant_history` over all input features. If `input_length=20` and `relevant_history=10`, explanation is computed for last 10 time points. The default linear model used for explanation is sklearn's LinearRegression. If a different linear interpretable model is to be used, the model can be wrapped with `aix360.algorithms.tslime.surrogate.LinearSurrogateModel` and provided as param `local_interpretable_model`. \n",
+    "\n",
+    "The explainer uses TSPerturber for generating perturbed/simulated time series data to train the linear interpretable model. Available perturbers are \"block-bootstrap\", \"frequency\", \"moving_average\", \"shift\". "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "791e5cfd-1f56-488e-854a-77b3f993c4f5",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "import functools\n",
+    "from aix360.algorithms.tslime.tslime import TSLimeExplainer\n",
+    "from aix360.algorithms.tsutils.tsperturbers import BlockBootstrapPerturber\n",
+    "\n",
+    "relevant_history = 40\n",
+    "explainer = TSLimeExplainer(\n",
+    "                            model= functools.partial(f_model.predict, verbose = 0),\n",
+    "                            input_length=sequence_length,\n",
+    "                            relevant_history=relevant_history,\n",
+    "                            perturbers=[\n",
+    "                                BlockBootstrapPerturber(window_length=min(10, sequence_length-1), block_length=2, block_swap=2),\n",
+    "                            ],\n",
+    "                            n_perturbations=10000,\n",
+    "                            random_seed=22,\n",
+    "                        )\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d6144697-4b3d-4945-85dc-56e087ccd65c",
+   "metadata": {},
+   "source": [
+    "<a id='compute_explanation'></a>\n",
+    "### Compute Explanation\n",
+    "\n",
+    "Compute lime weights for a given input timeseries."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "9f7c2fc3-64a3-4f79-841e-5160613f1112",
+   "metadata": {
+    "tags": []
+   },
+   "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>X_1</th>\n",
+       "      <th>X_2</th>\n",
+       "      <th>X_3</th>\n",
+       "      <th>X_4</th>\n",
+       "      <th>X_5</th>\n",
+       "      <th>X_6</th>\n",
+       "      <th>X_7</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>time</th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>0.097410</td>\n",
+       "      <td>1.087409</td>\n",
+       "      <td>1.049267</td>\n",
+       "      <td>1.343109</td>\n",
+       "      <td>0.373339</td>\n",
+       "      <td>-0.980914</td>\n",
+       "      <td>-0.615123</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>0.101056</td>\n",
+       "      <td>0.898643</td>\n",
+       "      <td>0.775765</td>\n",
+       "      <td>0.883069</td>\n",
+       "      <td>0.399370</td>\n",
+       "      <td>-0.819606</td>\n",
+       "      <td>-1.269978</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>0.138732</td>\n",
+       "      <td>0.733038</td>\n",
+       "      <td>0.555661</td>\n",
+       "      <td>0.504212</td>\n",
+       "      <td>0.429120</td>\n",
+       "      <td>-0.668334</td>\n",
+       "      <td>-1.053876</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>0.160609</td>\n",
+       "      <td>0.804839</td>\n",
+       "      <td>0.648130</td>\n",
+       "      <td>0.664498</td>\n",
+       "      <td>0.414245</td>\n",
+       "      <td>-0.724878</td>\n",
+       "      <td>-0.431764</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>0.161824</td>\n",
+       "      <td>0.675134</td>\n",
+       "      <td>0.482727</td>\n",
+       "      <td>0.370988</td>\n",
+       "      <td>0.447714</td>\n",
+       "      <td>-0.613259</td>\n",
+       "      <td>0.072475</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>115</th>\n",
+       "      <td>0.374511</td>\n",
+       "      <td>1.261121</td>\n",
+       "      <td>1.322769</td>\n",
+       "      <td>1.840618</td>\n",
+       "      <td>0.302682</td>\n",
+       "      <td>-1.058753</td>\n",
+       "      <td>1.519705</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>116</th>\n",
+       "      <td>0.432848</td>\n",
+       "      <td>1.161526</td>\n",
+       "      <td>1.163877</td>\n",
+       "      <td>1.590822</td>\n",
+       "      <td>0.295244</td>\n",
+       "      <td>-0.960108</td>\n",
+       "      <td>0.963078</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>117</th>\n",
+       "      <td>0.458371</td>\n",
+       "      <td>1.211323</td>\n",
+       "      <td>1.242020</td>\n",
+       "      <td>1.428455</td>\n",
+       "      <td>0.618778</td>\n",
+       "      <td>-1.011511</td>\n",
+       "      <td>0.426097</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>118</th>\n",
+       "      <td>0.496047</td>\n",
+       "      <td>1.136048</td>\n",
+       "      <td>1.123503</td>\n",
+       "      <td>1.193231</td>\n",
+       "      <td>0.670841</td>\n",
+       "      <td>-0.940771</td>\n",
+       "      <td>0.740427</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>119</th>\n",
+       "      <td>0.587198</td>\n",
+       "      <td>0.884746</td>\n",
+       "      <td>0.756229</td>\n",
+       "      <td>0.437600</td>\n",
+       "      <td>0.856780</td>\n",
+       "      <td>-0.711904</td>\n",
+       "      <td>-0.392473</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>120 rows × 7 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "           X_1       X_2       X_3       X_4       X_5       X_6       X_7\n",
+       "time                                                                      \n",
+       "0     0.097410  1.087409  1.049267  1.343109  0.373339 -0.980914 -0.615123\n",
+       "1     0.101056  0.898643  0.775765  0.883069  0.399370 -0.819606 -1.269978\n",
+       "2     0.138732  0.733038  0.555661  0.504212  0.429120 -0.668334 -1.053876\n",
+       "3     0.160609  0.804839  0.648130  0.664498  0.414245 -0.724878 -0.431764\n",
+       "4     0.161824  0.675134  0.482727  0.370988  0.447714 -0.613259  0.072475\n",
+       "...        ...       ...       ...       ...       ...       ...       ...\n",
+       "115   0.374511  1.261121  1.322769  1.840618  0.302682 -1.058753  1.519705\n",
+       "116   0.432848  1.161526  1.163877  1.590822  0.295244 -0.960108  0.963078\n",
+       "117   0.458371  1.211323  1.242020  1.428455  0.618778 -1.011511  0.426097\n",
+       "118   0.496047  1.136048  1.123503  1.193231  0.670841 -0.940771  0.740427\n",
+       "119   0.587198  0.884746  0.756229  0.437600  0.856780 -0.711904 -0.392473\n",
+       "\n",
+       "[120 rows x 7 columns]"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "indx = 0\n",
+    "instance = x_test[indx]\n",
+    "base_value = np.mean(instance, axis=0)\n",
+    "\n",
+    "ts_instance = tsFrame(instance)\n",
+    "ts_instance.index = pd.to_numeric(ts_instance.index)\n",
+    "ts_instance"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d41f16ed-758e-484a-b5e8-c1487e3ce565",
+   "metadata": {},
+   "source": [
+    "Explanation object `explanation` contains the history weights computed for selected time window (relevant history) and surrogate prediction for this selected time window."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "6bba2b72-435d-4035-9947-762083cdc4b2",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "explanation = explainer.explain_instance(ts_instance)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b531066b-b407-4704-9bbd-6a25ccfba8f2",
+   "metadata": {},
+   "source": [
+    "<a id='plot_explanation'></a>\n",
+    "### Plot Explanation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "7fd375e9-902e-4317-b2fe-6264aa79cdd7",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1500x1000 with 7 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "import matplotlib.gridspec as gridspec\n",
+    "\n",
+    "fig = plt.figure(layout='constrained', figsize=(15,10))\n",
+    "gs0 = gridspec.GridSpec(2, 1, figure=fig, height_ratios= [1, 3], top=0.9)\n",
+    "gs2 = gridspec.GridSpecFromSubplotSpec(3, 2, subplot_spec=gs0[1])\n",
+    "gs1 = gridspec.GridSpecFromSubplotSpec(1, 3, subplot_spec=gs0[0], width_ratios=[4.5, 10, 4.5])\n",
+    "\n",
+    "        \n",
+    "def plot_feature(figure, scores, feature_values, gs, title, legend=False):\n",
+    "    ax = fig.add_subplot(gs)\n",
+    "    ax.plot(feature_values, label='Input Time Series', marker='o')\n",
+    "    # plt.gca().invert_yaxis()\n",
+    "    ax.set_title(title)\n",
+    "\n",
+    "    ax.bar(feature_values.index, scores, 0.4, label = 'TSLime Weights (Normalized)', color='red')\n",
+    "    ax.axhline(y=0, color='r', linestyle='-', alpha=0.4)\n",
+    "    if legend:\n",
+    "        ax.legend(bbox_to_anchor=(1.5, 1.0), loc='upper right')\n",
+    "\n",
+    "    \n",
+    "instance_prediction = explanation['model_prediction']\n",
+    "normalized_weights = (explanation['history_weights'] / np.mean(np.abs(explanation['history_weights'])))\n",
+    "\n",
+    "for i, feature_col in enumerate(selected_feature_columns):\n",
+    "    if i > 0:\n",
+    "        gs = gs2[i-1]\n",
+    "    else:\n",
+    "        gs = gs1[1]\n",
+    "        \n",
+    "    \n",
+    "    plot_feature(figure=fig,\n",
+    "                 scores=normalized_weights[:,i].flatten(), \n",
+    "                 feature_values=ts_instance.iloc[-relevant_history:, i],\n",
+    "                 gs=gs,\n",
+    "                 title=\"{} - {}\".format(selected_feature_names[i], feature_col),\n",
+    "                 legend=(i==0))\n",
+    "\n",
+    "fig.suptitle(\"Time Series Lime Explanation Plot for test point i={} with forecast={}\".format(str(indx), str(instance_prediction)), fontsize=\"x-large\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fa09fee2-4451-4098-9cd4-ce9a3b5bdd2e",
+   "metadata": {},
+   "source": [
+    "The above plot shows the normalized weights for each time point in relevant(selected) history window. Weights are normalized/scaled using mean absolute over all the weights."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "15b1ca83-234b-49f3-a924-b3594fb1c88c",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "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.10.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/tslime/tslime_univariate_demo.ipynb b/examples/tslime/tslime_univariate_demo.ipynb
new file mode 100644
index 0000000..2e2ef6b
--- /dev/null
+++ b/examples/tslime/tslime_univariate_demo.ipynb
@@ -0,0 +1,623 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "48f88759-48eb-4f4f-a896-3b60aa00e003",
+   "metadata": {},
+   "source": [
+    "# TSLimeExplainer For Univariate\n",
+    "\n",
+    "Advanced time series models are complex and often hard to interpret. Time Series Local Interpretable Model-agnostic Explainer (TSLime) is a model-agnostic local time series explainer. It explains a time series model behavior using an approximate linear model as surrogate. TSLime approximates model response by evaluating the model over time series samples generated by applying time series perturbation techniques. The explanation produced by TSLime is the weights of the linear model over different time point observations. The relative signed value of the explanation is indicative of model sensitivity at temporal resolution. TSLime uses the recent time context length for the local surrogate model fitting.\n",
+    "\n",
+    "TSLime supports univariate and multi-variate use cases related to forecasting, time series classification, regression and anomaly detection. This notebook demonstrates usage of TSLimeExplainer for Univariate data using [FordA dataset](http://www.timeseriesclassification.com/description.php?Dataset=FordA)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "45c39595-265b-4480-b6c1-20339113ed33",
+   "metadata": {},
+   "source": [
+    "<a id='notebook_workflow'></a>\n",
+    "## Notebook Workflow\n",
+    "- [Imports](#imports)\n",
+    "- [Load Dataset](#load_dataset)\n",
+    "- [Train Classifier](#train_classifier)\n",
+    "- [Initialize TSLimeExplainer](#initialize_tslime)\n",
+    "- [Compute Explanation](#compute_explanation)\n",
+    "- [Plot Explanation](#plot_explanation)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "21e3e84e-ece2-43bb-a11c-9d7dff21bc13",
+   "metadata": {},
+   "source": [
+    "<a id='imports'></a>\n",
+    "### Imports\n",
+    "\n",
+    "The example model is a pre-trained keras model and hosted on huggingface hub. So, this notebook requires to install tensorflow 2.4+ and huggingface_hub packages."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "95272a35-1111-4140-8a07-c0f15e78145d",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "# to suppress unrelated tensorflow warnings while importing aix360.datasets\n",
+    "os.environ[\"TF_CPP_MIN_LOG_LEVEL\"] = \"3\"\n",
+    "\n",
+    "import logging\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "import tensorflow as tf\n",
+    "from tensorflow import keras\n",
+    "from huggingface_hub import from_pretrained_keras\n",
+    "from aix360.datasets import FordDataset\n",
+    "from aix360.algorithms.tsutils.tsframe import tsFrame\n",
+    "from aix360.algorithms.tsutils.model_wrappers import Tensor_Based_Classification_Model\n",
+    "from aix360.algorithms.tslime.tslime import TSLimeExplainer\n",
+    "from huggingface_hub.utils import logging as h_logging\n",
+    "\n",
+    "# huggingface hub warnings\n",
+    "h_logging.set_verbosity_error()\n",
+    "\n",
+    "# tensorflow warnings\n",
+    "logger = tf.get_logger()\n",
+    "logger.setLevel(logging.ERROR)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "207c0083-17cc-41ad-aeab-e0fbe033def8",
+   "metadata": {},
+   "source": [
+    "<a id='load_dataset'></a>\n",
+    "### Load Dataset\n",
+    "\n",
+    "The dataset is from [UCR archive](), [timeseriesclassification Datasets](http://www.timeseriesclassification.com/description.php?Dataset=FordA) and was used in IEEE World Congress on Computational Intelligence, 2008. As described in the prior websites, the classification problem is to diagnose whether a certain symptom exists or does not exist in an automotive subsystem. Each case consists of 500 measurements of engine noise and a classification. There are two separate problems. The current notebook uses FordA dataset. Train and test data sets were collected in typical operating conditions, with minimal noise contamination. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "6e89c0e5-33eb-470b-98e6-b07135171170",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "input_length = 500\n",
+    "x_train, x_test, y_train, y_test = FordDataset().load_data()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "5ac94776-d8ef-478b-bf16-8027a8e6b25a",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1500x300 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "_ = pd.DataFrame(x_train[0]).plot(figsize=(15, 3), title=\"FordA - 1 Time Series Reading of 500 Measurements\", legend=False)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1e50af8b-2ca8-45e4-8a6f-48492ce7a084",
+   "metadata": {},
+   "source": [
+    "<a id='train_classifier'></a>\n",
+    "### Download Pre-Trained Model\n",
+    "Use a pre-trained model from Keras/HuggingFace.\n",
+    "\n",
+    "The pre-trained model is from: https://keras.io/examples/timeseries/timeseries_transformer_classification/\n",
+    "The Hugging face model url is: https://huggingface.co/keras-io/timeseries_transformer_classification"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "4660c52f-b3e8-4848-b2c0-372673dc9495",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "f8832cb4da3c452095767e4e0f16c216",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Fetching 6 files:   0%|          | 0/6 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "model = from_pretrained_keras(\"keras-io/timeseries_transformer_classification\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "2cb11700-e7b4-40f7-a5d1-0359515c84a3",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model: \"model\"\n",
+      "__________________________________________________________________________________________________\n",
+      " Layer (type)                   Output Shape         Param #     Connected to                     \n",
+      "==================================================================================================\n",
+      " input_1 (InputLayer)           [(None, 500, 1)]     0           []                               \n",
+      "                                                                                                  \n",
+      " layer_normalization (LayerNorm  (None, 500, 1)      2           ['input_1[0][0]']                \n",
+      " alization)                                                                                       \n",
+      "                                                                                                  \n",
+      " multi_head_attention (MultiHea  (None, 500, 1)      7169        ['layer_normalization[0][0]',    \n",
+      " dAttention)                                                      'layer_normalization[0][0]']    \n",
+      "                                                                                                  \n",
+      " dropout (Dropout)              (None, 500, 1)       0           ['multi_head_attention[0][0]']   \n",
+      "                                                                                                  \n",
+      " tf.__operators__.add (TFOpLamb  (None, 500, 1)      0           ['dropout[0][0]',                \n",
+      " da)                                                              'input_1[0][0]']                \n",
+      "                                                                                                  \n",
+      " layer_normalization_1 (LayerNo  (None, 500, 1)      2           ['tf.__operators__.add[0][0]']   \n",
+      " rmalization)                                                                                     \n",
+      "                                                                                                  \n",
+      " conv1d (Conv1D)                (None, 500, 4)       8           ['layer_normalization_1[0][0]']  \n",
+      "                                                                                                  \n",
+      " dropout_1 (Dropout)            (None, 500, 4)       0           ['conv1d[0][0]']                 \n",
+      "                                                                                                  \n",
+      " conv1d_1 (Conv1D)              (None, 500, 1)       5           ['dropout_1[0][0]']              \n",
+      "                                                                                                  \n",
+      " tf.__operators__.add_1 (TFOpLa  (None, 500, 1)      0           ['conv1d_1[0][0]',               \n",
+      " mbda)                                                            'tf.__operators__.add[0][0]']   \n",
+      "                                                                                                  \n",
+      " layer_normalization_2 (LayerNo  (None, 500, 1)      2           ['tf.__operators__.add_1[0][0]'] \n",
+      " rmalization)                                                                                     \n",
+      "                                                                                                  \n",
+      " multi_head_attention_1 (MultiH  (None, 500, 1)      7169        ['layer_normalization_2[0][0]',  \n",
+      " eadAttention)                                                    'layer_normalization_2[0][0]']  \n",
+      "                                                                                                  \n",
+      " dropout_2 (Dropout)            (None, 500, 1)       0           ['multi_head_attention_1[0][0]'] \n",
+      "                                                                                                  \n",
+      " tf.__operators__.add_2 (TFOpLa  (None, 500, 1)      0           ['dropout_2[0][0]',              \n",
+      " mbda)                                                            'tf.__operators__.add_1[0][0]'] \n",
+      "                                                                                                  \n",
+      " layer_normalization_3 (LayerNo  (None, 500, 1)      2           ['tf.__operators__.add_2[0][0]'] \n",
+      " rmalization)                                                                                     \n",
+      "                                                                                                  \n",
+      " conv1d_2 (Conv1D)              (None, 500, 4)       8           ['layer_normalization_3[0][0]']  \n",
+      "                                                                                                  \n",
+      " dropout_3 (Dropout)            (None, 500, 4)       0           ['conv1d_2[0][0]']               \n",
+      "                                                                                                  \n",
+      " conv1d_3 (Conv1D)              (None, 500, 1)       5           ['dropout_3[0][0]']              \n",
+      "                                                                                                  \n",
+      " tf.__operators__.add_3 (TFOpLa  (None, 500, 1)      0           ['conv1d_3[0][0]',               \n",
+      " mbda)                                                            'tf.__operators__.add_2[0][0]'] \n",
+      "                                                                                                  \n",
+      " layer_normalization_4 (LayerNo  (None, 500, 1)      2           ['tf.__operators__.add_3[0][0]'] \n",
+      " rmalization)                                                                                     \n",
+      "                                                                                                  \n",
+      " multi_head_attention_2 (MultiH  (None, 500, 1)      7169        ['layer_normalization_4[0][0]',  \n",
+      " eadAttention)                                                    'layer_normalization_4[0][0]']  \n",
+      "                                                                                                  \n",
+      " dropout_4 (Dropout)            (None, 500, 1)       0           ['multi_head_attention_2[0][0]'] \n",
+      "                                                                                                  \n",
+      " tf.__operators__.add_4 (TFOpLa  (None, 500, 1)      0           ['dropout_4[0][0]',              \n",
+      " mbda)                                                            'tf.__operators__.add_3[0][0]'] \n",
+      "                                                                                                  \n",
+      " layer_normalization_5 (LayerNo  (None, 500, 1)      2           ['tf.__operators__.add_4[0][0]'] \n",
+      " rmalization)                                                                                     \n",
+      "                                                                                                  \n",
+      " conv1d_4 (Conv1D)              (None, 500, 4)       8           ['layer_normalization_5[0][0]']  \n",
+      "                                                                                                  \n",
+      " dropout_5 (Dropout)            (None, 500, 4)       0           ['conv1d_4[0][0]']               \n",
+      "                                                                                                  \n",
+      " conv1d_5 (Conv1D)              (None, 500, 1)       5           ['dropout_5[0][0]']              \n",
+      "                                                                                                  \n",
+      " tf.__operators__.add_5 (TFOpLa  (None, 500, 1)      0           ['conv1d_5[0][0]',               \n",
+      " mbda)                                                            'tf.__operators__.add_4[0][0]'] \n",
+      "                                                                                                  \n",
+      " layer_normalization_6 (LayerNo  (None, 500, 1)      2           ['tf.__operators__.add_5[0][0]'] \n",
+      " rmalization)                                                                                     \n",
+      "                                                                                                  \n",
+      " multi_head_attention_3 (MultiH  (None, 500, 1)      7169        ['layer_normalization_6[0][0]',  \n",
+      " eadAttention)                                                    'layer_normalization_6[0][0]']  \n",
+      "                                                                                                  \n",
+      " dropout_6 (Dropout)            (None, 500, 1)       0           ['multi_head_attention_3[0][0]'] \n",
+      "                                                                                                  \n",
+      " tf.__operators__.add_6 (TFOpLa  (None, 500, 1)      0           ['dropout_6[0][0]',              \n",
+      " mbda)                                                            'tf.__operators__.add_5[0][0]'] \n",
+      "                                                                                                  \n",
+      " layer_normalization_7 (LayerNo  (None, 500, 1)      2           ['tf.__operators__.add_6[0][0]'] \n",
+      " rmalization)                                                                                     \n",
+      "                                                                                                  \n",
+      " conv1d_6 (Conv1D)              (None, 500, 4)       8           ['layer_normalization_7[0][0]']  \n",
+      "                                                                                                  \n",
+      " dropout_7 (Dropout)            (None, 500, 4)       0           ['conv1d_6[0][0]']               \n",
+      "                                                                                                  \n",
+      " conv1d_7 (Conv1D)              (None, 500, 1)       5           ['dropout_7[0][0]']              \n",
+      "                                                                                                  \n",
+      " tf.__operators__.add_7 (TFOpLa  (None, 500, 1)      0           ['conv1d_7[0][0]',               \n",
+      " mbda)                                                            'tf.__operators__.add_6[0][0]'] \n",
+      "                                                                                                  \n",
+      " global_average_pooling1d (Glob  (None, 500)         0           ['tf.__operators__.add_7[0][0]'] \n",
+      " alAveragePooling1D)                                                                              \n",
+      "                                                                                                  \n",
+      " dense (Dense)                  (None, 128)          64128       ['global_average_pooling1d[0][0]'\n",
+      "                                                                 ]                                \n",
+      "                                                                                                  \n",
+      " dropout_8 (Dropout)            (None, 128)          0           ['dense[0][0]']                  \n",
+      "                                                                                                  \n",
+      " dense_1 (Dense)                (None, 2)            258         ['dropout_8[0][0]']              \n",
+      "                                                                                                  \n",
+      "==================================================================================================\n",
+      "Total params: 93,130\n",
+      "Trainable params: 93,130\n",
+      "Non-trainable params: 0\n",
+      "__________________________________________________________________________________________________\n"
+     ]
+    }
+   ],
+   "source": [
+    "model.summary()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "803929a3-e7e4-4982-8e76-89c998595c23",
+   "metadata": {},
+   "source": [
+    "As the model inputs are tensor based, we are selecting Tensor_Based_Classification_Model from aix360 to wrap the model. The wrapper manages the input and output shapes between the original model and the explainer."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "98259808-59cd-4647-b948-938a754db0a5",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "class_pos = 0 # to select class probability for explanation\n",
+    "binary_model = Tensor_Based_Classification_Model(model, \n",
+    "                                                 class_pos=class_pos, \n",
+    "                                                 input_length=input_length, \n",
+    "                                                 n_features=1)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4badaa80-e5e9-4900-a3bc-7785adc1a400",
+   "metadata": {},
+   "source": [
+    "Model accuracy for selected test samples."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "88d267e8-9825-4f49-91f1-85c9f3ad5e02",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "model accuracy for 10 samples: 0.9.\n"
+     ]
+    }
+   ],
+   "source": [
+    "from sklearn.metrics import accuracy_score\n",
+    "\n",
+    "test_sample_size = 10\n",
+    "y_pred = binary_model.predict(x_test[0:test_sample_size,...], verbose=0)\n",
+    "\n",
+    "print(\"model accuracy for {} samples: {}.\".format(test_sample_size, accuracy_score(y_test[:test_sample_size], y_pred.astype(int))))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "64b6fb0f-c9dd-4243-bd5b-c6c44d8160cd",
+   "metadata": {},
+   "source": [
+    "<a id='initialize_tslime'></a>\n",
+    "### Initialize TSLimeExplainer\n",
+    "\n",
+    "`TSLimeExplainer` requires a model function which is to be explained and input (history) length used for the input model. The explanation is for selected latest window of length `relevant_history`. If `input_length=20` and `relevant_history=10`, explanation is computed for last 10 time points. The default linear model used for explanation is sklearn's LinearRegression. If a different linear interpretable model is to be used, the model can be wrapped with `aix360.algorithms.tslime.surrogate.LinearSurrogateModel` and provided as param `local_interpretable_model`. \n",
+    "\n",
+    "The explainer uses TSPerturber for generating perturbed/simulated time series data to train the linear interpretable model. Available perturbers are \"block-bootstrap\", \"frequency\", \"moving_average\", \"shift\". "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "4345dff3-2e33-4a44-a548-403679c94e0a",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "import functools\n",
+    "from aix360.algorithms.tsutils.tsperturbers import BlockBootstrapPerturber\n",
+    "\n",
+    "relevant_history = 100\n",
+    "explainer = TSLimeExplainer(\n",
+    "    model= functools.partial(binary_model.predict_proba, verbose = 0),\n",
+    "    input_length= x_test.shape[1],\n",
+    "    relevant_history=relevant_history,\n",
+    "    perturbers=[\n",
+    "        BlockBootstrapPerturber(window_length=min(10, input_length-1), block_length=20, block_swap=2),\n",
+    "    ],\n",
+    "    n_perturbations=1000,\n",
+    "    random_seed=22,\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d6144697-4b3d-4945-85dc-56e087ccd65c",
+   "metadata": {},
+   "source": [
+    "<a id='compute_explanation'></a>\n",
+    "### Compute Explanation\n",
+    "\n",
+    "Compute lime weights for a given input timeseries. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "2e8e46f4-371d-402b-b886-9c2d08052559",
+   "metadata": {
+    "tags": []
+   },
+   "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>X_1</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>time</th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>1.240282</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>1.331189</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>1.386596</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>1.383220</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>1.305979</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>495</th>\n",
+       "      <td>-1.146352</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>496</th>\n",
+       "      <td>-1.011328</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>497</th>\n",
+       "      <td>-0.931222</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>498</th>\n",
+       "      <td>-0.934498</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>499</th>\n",
+       "      <td>-1.001288</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>500 rows × 1 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "           X_1\n",
+       "time          \n",
+       "0     1.240282\n",
+       "1     1.331189\n",
+       "2     1.386596\n",
+       "3     1.383220\n",
+       "4     1.305979\n",
+       "...        ...\n",
+       "495  -1.146352\n",
+       "496  -1.011328\n",
+       "497  -0.931222\n",
+       "498  -0.934498\n",
+       "499  -1.001288\n",
+       "\n",
+       "[500 rows x 1 columns]"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "indx = 3\n",
+    "instance = x_test[indx, ...]\n",
+    "\n",
+    "ts_instance = tsFrame(instance) # tsFrame instance\n",
+    "ts_instance.index = pd.to_numeric(ts_instance.index)\n",
+    "ts_instance"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5a7a9119-878d-437c-9b56-f13edc0831b4",
+   "metadata": {},
+   "source": [
+    "Explanation object `explanation` contains the history weights computed for selected time window (relevant history) and surrogate prediction for this selected time window."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "80bd35e3-cd19-4999-86c8-5517efd661d0",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "explanation = explainer.explain_instance(ts_instance)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b531066b-b407-4704-9bbd-6a25ccfba8f2",
+   "metadata": {
+    "tags": []
+   },
+   "source": [
+    "<a id='plot_explanation'></a>\n",
+    "### Plot Explanation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "5a8209e4-b341-474c-a535-3222697046eb",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1500x400 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "relevant_df = ts_instance[-relevant_history:]\n",
+    "\n",
+    "figsize = (15,4)\n",
+    "plt.figure(figsize=figsize, layout='constrained')\n",
+    "plt.plot(relevant_df, label='Input Time Series', marker='o')\n",
+    "plt.gca().invert_yaxis()\n",
+    "\n",
+    "normalized_weights = (explanation[\"history_weights\"] / np.mean(np.abs(explanation[\"history_weights\"]))).flatten()\n",
+    "\n",
+    "plt.bar(ts_instance.index[-relevant_history:], normalized_weights, 0.4, label = 'TSLime Weights (Normalized)', color='red')\n",
+    "plt.axhline(y=0, color='r', linestyle='-', alpha=0.4)\n",
+    "plt.title(\"Time Series Lime Explanation Plot\")\n",
+    "plt.legend(bbox_to_anchor=(1.25, 1.0), loc='upper right')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a2cd77b8-8513-4bad-ae9e-e7a88241da4e",
+   "metadata": {},
+   "source": [
+    "The above plot shows the normalized weights for each time point in relevant(selected) history window. Weights are normalized/scaled using mean absolute over all the weights."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "be099bdc-17ff-4129-a6f9-dfee9be0dbe8",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "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.10.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/setup.py b/setup.py
index e2029ad..cd0e728 100644
--- a/setup.py
+++ b/setup.py
@@ -18,6 +18,7 @@
         "scipy>=0.17",
         "scikit-learn<1.2.0",
         "cvxpy>=1.1",
+        "numpy<=1.24.3",
     ],
     "profwt": [
         "keras==2.3.1",
@@ -83,15 +84,15 @@
     ],
     "tsice": [
         "pandas<=1.4.3",
-        "scikit-learn",
         "scipy",
-        "plotly",  # required for example notebook
-        "ipython",  # required for example notebook
-        "kaleido",  # required for example notebook
-        "requests",  # for dataset
+        "plotly",  # required for units
+        "ipython",  # required for units
+        "kaleido",  # required for units
+        "requests",  # required for dataset and units
     ],
     "tssaliency": [
-        "pandas<=1.4.3"
+        "pandas<=1.4.3",
+        "requests",  # required for dataset and units
     ],
     "imd": [
         "numpy",
@@ -100,8 +101,13 @@
         "matplotlib",
         "networkx",
         "graphviz",
-        "pygraphviz"  # for creating graph visualization
-    ]
+        "pygraphviz",  # for creating graph visualization
+    ],
+    "tslime": [
+        "pandas<=1.4.3",
+        "scipy",
+        "requests",  # required for dataset and units
+    ],
 }
 
 # minimal dependencies in install_requires
diff --git a/tests/tslime/__init__.py b/tests/tslime/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/tests/tslime/test_tslime.py b/tests/tslime/test_tslime.py
new file mode 100644
index 0000000..f8869e4
--- /dev/null
+++ b/tests/tslime/test_tslime.py
@@ -0,0 +1,104 @@
+import os
+import unittest
+import numpy as np
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from sklearn.ensemble import RandomForestRegressor
+from aix360.algorithms.tsutils.tsframe import tsFrame
+from aix360.datasets import SunspotDataset
+from aix360.algorithms.tslime import TSLimeExplainer
+from aix360.algorithms.tsutils.tsperturbers import BlockBootstrapPerturber
+
+# transform a time series dataset into a supervised learning dataset
+# below sample forecaster is from: https://machinelearningmastery.com/random-forest-for-time-series-forecasting/
+class RandomForestUniVariateForecaster:
+    def __init__(self, n_past=4, n_future=1, RFparams={"n_estimators": 250}):
+        self.n_past = n_past
+        self.n_future = n_future
+        self.model = RandomForestRegressor(**RFparams)
+
+    def fit(self, X):
+        train = self._series_to_supervised(X, n_in=self.n_past, n_out=self.n_future)
+        trainX, trainy = train[:, : -self.n_future], train[:, -self.n_future :]
+        self.model = self.model.fit(trainX, trainy)
+        return self
+
+    def _series_to_supervised(self, data, n_in=1, n_out=1, dropnan=True):
+        n_vars = 1 if type(data) is list else data.shape[1]
+        df = pd.DataFrame(data)
+        cols = list()
+
+        # input sequence (t-n, ... t-1)
+        for i in range(n_in, 0, -1):
+            cols.append(df.shift(i))
+        # forecast sequence (t, t+1, ... t+n)
+        for i in range(0, n_out):
+            cols.append(df.shift(-i))
+        # put it all together
+        agg = pd.concat(cols, axis=1)
+        # drop rows with NaN values
+        if dropnan:
+            agg.dropna(inplace=True)
+        return agg.values
+
+    def predict(self, X):
+        row = X[-self.n_past :].flatten()
+        y_pred = self.model.predict(np.asarray([row]))
+        return y_pred
+
+
+class TestTSLimeExplainer(unittest.TestCase):
+    def setUp(self):
+
+        # load data
+        df, schema = SunspotDataset().load_data()
+        ts = tsFrame(
+            df, timestamp_column=schema["timestamp"], columns=schema["targets"]
+        )
+
+        (self.ts_train, self.ts_test) = train_test_split(
+            ts, shuffle=False, stratify=None, test_size=0.15, train_size=None
+        )
+
+    def test_tslime(self):
+
+        # load model
+        input_length = 24
+        forecast_horizon = 4
+        forecaster = RandomForestUniVariateForecaster(
+            n_past=input_length, n_future=forecast_horizon
+        )
+
+        forecaster.fit(self.ts_train.iloc[-200:])
+
+        # initialize/fit explainer
+
+        relevant_history = 12
+        explainer = TSLimeExplainer(
+            model=forecaster.predict,
+            input_length=input_length,
+            relevant_history=relevant_history,
+            perturbers=[
+                BlockBootstrapPerturber(
+                    window_length=min(4, input_length - 1), block_length=2, block_swap=2
+                ),
+            ],
+            n_perturbations=10,
+            random_seed=22,
+        )
+
+        # compute explanations
+        test_window = self.ts_test.iloc[:input_length]
+        explanation = explainer.explain_instance(
+            ts=test_window,
+        )
+
+        # validate explanation structure
+        self.assertIn("input_data", explanation)
+        self.assertIn("history_weights", explanation)
+        self.assertIn("x_perturbations", explanation)
+        self.assertIn("y_perturbations", explanation)
+        self.assertIn("model_prediction", explanation)
+        self.assertIn("surrogate_prediction", explanation)
+
+        self.assertEqual(explanation["history_weights"].shape[0], relevant_history)