tsCaptum 0.0.1__tar.gz

tscaptum-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 MLGIG: Machine Learning Georgiana Ifrim Group
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

tscaptum-0.0.1/PKG-INFO

@@ -0,0 +1,54 @@
+Metadata-Version: 2.1
+Name: tsCaptum
+Version: 0.0.1
+Summary: A Captum wrapper for Time Series XAI
+Author-email: Davide Serramazza <davide.serramazza@ucdconnect.ie>
+Project-URL: Homepage, https://github.com/mlgig/tscaptum/
+Requires-Python: <3.12,>=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: scikit-learn
+Requires-Dist: aeon
+Requires-Dist: openpyxl
+Requires-Dist: tqdm
+Requires-Dist: torch>=2.0.0
+Requires-Dist: captum==0.7.0
+
+# tsCaptum - A library for univariate and multivariate time series explanation
+
+tsCaptum is a library that adapts the popular post-hoc attribution methods implemented in the Captum
+framework to work with time series. Unlike previous libraries tsCaptum is :
+1) Fully compatible with scikit-learn and popular time-series frameworks such as aeon and sktime (e.g., so it is easy to combine ROCKET with SHAP).
+2) Takes advantage of TS locality by using time series segmentation (so SHAP runs fast with long time series and suffers less from vanishing attribution weights) 
+3) It's extremely easy to use requiring almost no effort by the users
+
+```
+from aeon.classification.convolution_based import RocketClassifier
+clf = RocketClassifier(n_jobs=-1)
+clf.fit(MP_X_train,MP_y_train)
+
+from tsCaptum.explainers import Feature_Ablation
+myFA = Feature_Ablation(clf)
+exp = myFA.explain(samples=CMJ_X_test_samples, labels=CMJ_y_test_samples, n_segments=10, normalise=False, baseline=0)
+
+from tsCaptum.explainers import Shapley_Value_Sampling as SHAP
+mySHAP = SHAP(clf)
+exp = mySHAP.explain(CMJ_X_test_samples, labels=CMJ_y_test_samples,  n_segments=10, normalise=False, baseline=0)
+
+```
+
+It can be installed by typing the command "pip install tsCaptum" or in case you have problems 
+installing torch (e.g. you use Linux as OS and you want a lighter installation) use 
+"pip3 install torch --index-url https://download.pytorch.org/whl/cpu && pip install tsCaptum"
+
+In case you use this library please cite:
+```
+@misc{tsCaptum,
+    author = {Davide Italo Serramazza, Thach Le Nguyen, Georgiana Ifrim},
+    title = {tsCaptum: adapting Captum explainers for time series and scikit-learn-like predictors},
+    howpublished = {GitHub},
+    year = {2024},
+    note = {Temporary bibitex entry},
+    url = { https://github.com/mlgig/tscaptum },
+}
+```

tscaptum-0.0.1/README.md

@@ -0,0 +1,38 @@
+# tsCaptum - A library for univariate and multivariate time series explanation
+
+tsCaptum is a library that adapts the popular post-hoc attribution methods implemented in the Captum
+framework to work with time series. Unlike previous libraries tsCaptum is :
+1) Fully compatible with scikit-learn and popular time-series frameworks such as aeon and sktime (e.g., so it is easy to combine ROCKET with SHAP).
+2) Takes advantage of TS locality by using time series segmentation (so SHAP runs fast with long time series and suffers less from vanishing attribution weights) 
+3) It's extremely easy to use requiring almost no effort by the users
+
+```
+from aeon.classification.convolution_based import RocketClassifier
+clf = RocketClassifier(n_jobs=-1)
+clf.fit(MP_X_train,MP_y_train)
+
+from tsCaptum.explainers import Feature_Ablation
+myFA = Feature_Ablation(clf)
+exp = myFA.explain(samples=CMJ_X_test_samples, labels=CMJ_y_test_samples, n_segments=10, normalise=False, baseline=0)
+
+from tsCaptum.explainers import Shapley_Value_Sampling as SHAP
+mySHAP = SHAP(clf)
+exp = mySHAP.explain(CMJ_X_test_samples, labels=CMJ_y_test_samples,  n_segments=10, normalise=False, baseline=0)
+
+```
+
+It can be installed by typing the command "pip install tsCaptum" or in case you have problems 
+installing torch (e.g. you use Linux as OS and you want a lighter installation) use 
+"pip3 install torch --index-url https://download.pytorch.org/whl/cpu && pip install tsCaptum"
+
+In case you use this library please cite:
+```
+@misc{tsCaptum,
+    author = {Davide Italo Serramazza, Thach Le Nguyen, Georgiana Ifrim},
+    title = {tsCaptum: adapting Captum explainers for time series and scikit-learn-like predictors},
+    howpublished = {GitHub},
+    year = {2024},
+    note = {Temporary bibitex entry},
+    url = { https://github.com/mlgig/tscaptum },
+}
+```

tscaptum-0.0.1/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["setuptools>=69.5.1"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "tsCaptum"
+version = "0.0.1"
+authors = [  { name="Davide Serramazza", email="davide.serramazza@ucdconnect.ie" },]
+description = "A Captum wrapper for Time Series XAI"
+readme = "README.md"
+requires-python = ">=3.8,<3.12"
+dependencies = [
+	"scikit-learn",
+	"aeon",
+	"openpyxl",
+	"tqdm",
+	"torch>=2.0.0",
+	"captum==0.7.0"
+]
+
+[project.urls]
+"Homepage" = "https://github.com/mlgig/tscaptum/"

tscaptum-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

tscaptum-0.0.1/src/tsCaptum/_forwarder.py

@@ -0,0 +1,47 @@
+import numpy as np
+import torch
+
+
+# documentation for each method!
+
+class _Forwarder:
+	"""
+	class automatically detecting the right forward function to use with the captum explainers
+	"""
+
+	# TODO specify possible clf type as aeonClf | SktimeClf | ....
+
+	def __init__(self, predictor, predictor_type):
+		"""
+		init function for this class
+
+		:param predictor: the predictor to be explained
+		:
+		param predictor_type: (optional) the predictor variable's type i.e. regressor or classifier
+		"""
+		# TODO should I make the following two variables private?
+		self.predictor = predictor
+		if predictor_type == "regressor":
+			self.raw_result_func = self.predictor.predict
+		elif predictor_type == "classifier":
+			self.raw_result_func = self.predictor.predict_proba
+		else:
+			raise " provided model not recognized. Please specify whether is a classifier or regressor "
+
+	def forward(self, X):
+		"""
+		function adapting scikit-learn-like predictor to captum explainers
+
+		:param X: instances to be explained
+
+		:return: predictor's output as a torch tensor
+		"""
+
+		# convert X to pytorch tensor
+		X_numpy: np.array = X.detach().numpy()
+		# use the model forward function
+		preds: np.array = self.raw_result_func(X_numpy)
+		# return result as torch tensor as expected by captum attribution method
+		preds_torch: torch.tensor = torch.tensor(preds)
+
+		return preds_torch

tscaptum-0.0.1/src/tsCaptum/_tsCaptum_loader.py

@@ -0,0 +1,15 @@
+from torch.utils.data import Dataset
+
+
+class _tsCaptum_loader(Dataset):
+
+	def __init__(self, X, labels):
+		super().__init__()
+		self.X = X
+		self.labels = labels
+
+	def __len__(self):
+		return self.X.shape[0]
+
+	def __getitem__(self, idx):
+		return self.X[idx], self.labels[idx]

tscaptum-0.0.1/src/tsCaptum/_utils.py

@@ -0,0 +1,118 @@
+import numpy as np
+import torch
+from torch.utils.data import DataLoader
+from sklearn.preprocessing import LabelEncoder
+
+from ._tsCaptum_loader import _tsCaptum_loader
+
+
+# TODO check to aeon, sktime, torch and captum how function in utils are called (with or without leading _) ?
+
+def _equal_length_segmentation(n_chunks: int, n_channels: int, series_length: int):
+	r"""
+	function returning how to group time points into time Series accordingly to the given arguments
+	To be noted that it operates channel-wise i.e. each channel is divided into 'n_chunks' chunks
+
+	:param n_chunks:        number of chunks to be used
+
+	:param n_channels:      number of channel of each instance in the dataset
+
+	:param series_length:   length of each channel of each instance in the dataset
+
+	:return:                a torch tensor representing how to group time points
+	"""
+	quotient, reminder = np.floor(series_length / n_chunks).astype(int), series_length % n_chunks
+
+	first_group = np.array([[i + j * n_chunks for i in range(reminder)] for j in range(n_channels)])
+	first_group = np.expand_dims(np.repeat(first_group, (quotient + 1), axis=1), 0)
+
+	second_group = np.array([[i + j * n_chunks for i in range(reminder, n_chunks)] for j in range(n_channels)])
+	second_group = np.expand_dims(np.repeat(second_group, quotient, axis=1), 0)
+
+	final_group = np.concatenate((first_group, second_group), axis=-1)
+	return torch.tensor(final_group).to(torch.int64)
+
+
+def _normalise_result(X):
+	"""
+	function to normalize obtained saliency map
+
+	:param X: the saliency map to be normalized
+
+	:return: normalized version of X
+	"""
+
+	assert len(X.shape) == 3
+	results = []
+	for x in X:
+		scaling_factor = 1 / max(np.abs(x.max()), np.abs(x.min()))
+		results.append(scaling_factor * x)
+	return results
+
+
+def _check_labels(labels, predictor_type):
+	r"""
+	function checking the label argument provided to explain method and converting them into integer representation as
+	required by captum
+
+	:param labels:          provided labels
+
+	:param predictor_type:  predictor's type i.e. classifier or regressor
+
+	:return:                label encoder and relative integer indices
+	"""
+	if predictor_type == "classifier":
+		# transform to numeric labels
+		le = LabelEncoder()
+		labels_idx = torch.tensor(le.fit_transform(labels)).type(torch.int64)
+
+	elif predictor_type == "regressor":
+		if labels is not None:
+			raise ValueError(
+				"specified labels when predictor type is regressor"
+			)
+		le = None
+		labels_idx = None
+
+	else:
+		raise (
+			" provided predictor type not recognized. Please specify whether is a classifier or regressor "
+		)
+
+	return le, labels_idx
+
+
+def _check_convert_data_format(X, labels, batch_size):
+	r"""
+	function checking and converting provided samples and labels to explain method
+
+	:param X:           sample to explain. Can be provided as numpy array or as torch tensor
+
+	:param labels:      labels provided to explain method
+
+	:param batch_size:  batch size provided to explain method
+
+	:return:            data loader to be used in the explain method
+	"""
+
+	if X is None and labels is not None:
+		if X.shape[0] != labels.shape[0]:
+			# if both X and labels are provided having no matching dimensions
+			raise ValueError(
+				"provided samples and labels have different dimensions"
+			)
+
+	if isinstance(X, np.ndarray):
+		X = torch.tensor(X).type(torch.float)
+	elif isinstance(X, torch.Tensor):
+		X = X.type(torch.float)
+	else:
+		raise TypeError(
+			" Data format has to be either numpy array or torch tensor "
+		)
+
+	if labels is None:
+		labels = torch.ones(X.shape[0]) * -1
+	loader = DataLoader(_tsCaptum_loader(X, labels), shuffle=False, batch_size=batch_size)
+
+	return loader

tscaptum-0.0.1/src/tsCaptum/explainers.py

@@ -0,0 +1,231 @@
+from tqdm import tqdm
+import warnings
+
+from captum.attr._utils.attribution import PerturbationAttribution
+from captum.attr import (FeatureAblation as _FeatureAblationCaptum,
+                         FeaturePermutation as _FeaturePermutationCaptum,
+                         KernelShap as _KernelShapCaptum,
+                         Lime as _LimeCaptum,
+                         ShapleyValueSampling as _ShapleyValueSamplingCaptum)
+
+from ._forwarder import _Forwarder
+from ._utils import _check_convert_data_format, _check_labels, _normalise_result, _equal_length_segmentation
+from ._utils import *
+
+
+class _tsCaptum_Method:
+	"""
+	super class for all attribution methods
+	"""
+
+	def __init__(self, explainer, predictor, predictor_type: str = None):
+		r"""
+		init method for the superclass
+
+		:param explainer:       the actual explainer that will be used for computing the saliency maps.
+		Each subclass fix this argument as the corresponding Captum explainer
+
+		:param predictor:       the predictor that will be explained
+		:param predictor_type:  which type the predictor is i.e. classifier or regressor
+		"""
+
+		# check argument values
+		if not issubclass(explainer, PerturbationAttribution):
+			raise (
+				" provided explainer has to be an instance of 'captum.attr._utils.attribution.PerturbationAttribution' ")
+
+		if predictor_type not in ["classifier", "regressor", None]:
+			raise (
+				" clf_type argument has to be either  'classifier' or 'regressor' ")
+
+		# in case predictor_type argument isn't provided tell it calling the predict_proba method:
+		# if it's present the predictor is a classifier otherwise is a regressor
+		self.predictor_type = predictor_type
+		if self.predictor_type is None:
+			self.predictor_type = "classifier"
+			try:
+				predictor.predict_proba
+			except AttributeError:
+				self.predictor_type = "regressor"
+
+		# set also forward function and explainer to be used
+		self._Forwarder = _Forwarder(predictor, self.predictor_type)
+		self._explainer = explainer(self._Forwarder.forward)
+
+	def explain(self, samples, labels=None, batch_size=8, n_segments=10, normalise=False, baseline=0):
+		r"""
+		main method to get a saliency map by the selected explainer
+
+		:param samples:     samples to be explained
+
+		:param labels:      labels associated to samples in case of classification
+
+		:param batch_size:  the batch_size to be used i.e. number of samples to be explained at the same time
+
+		:param n_segments:  number of segments the timeseries is dived to. If you want to explain point-wise provide -1 as
+		value #TODO should we put more information about how it works?
+
+		:param normalise:   whether or not to normalise the result
+
+		:param baseline:    the baseline which will substitute time series's values when ablated. It can be either a scalar
+		(each time series's value is substituted by this scalar)  or a single time series
+		(both as numpy array or torch.tensor)
+
+		:return:    the saliency maps as a 3D tensor ( samples, channels, time points)
+		"""
+
+		# check arguments and get a DataLoader
+		n_2explain, n_channels, series_length = samples.shape
+		le, labels_idx = _check_labels(labels, self.predictor_type)
+		loader = _check_convert_data_format(samples, labels_idx, batch_size)
+
+		explanations = []
+		with tqdm(total=n_2explain) as pbar:
+			with torch.no_grad():
+				for n, (X, y) in enumerate(loader):
+					# fix kwargs for the relative captum method
+					kwargs = self._define_kwargs(baseline, n_channels, n_segments, series_length, y)
+					# get the current saliency maps, convert it to numpy array and store it to a temp list
+					current_exps = self._explainer.attribute(X, **kwargs)
+					explanations.append(
+						_normalise_result(current_exps.detach().numpy())) if normalise \
+						else explanations.append(current_exps.detach().numpy())
+					pbar.update(batch_size)
+		pbar.close()
+
+		# convert the list to numpy array and return it as result
+		explanations = np.concatenate(explanations)
+		return explanations
+
+	def _define_kwargs(self, baseline, n_channels, n_segments, series_length, y):
+		r"""
+		inner function that checking provided argument to explain, define the correct kwarg dictionary
+
+		:return: kwarg dictionary for the relative captum method
+		"""
+		kwargs = {}
+
+		# checking baseline
+		if not isinstance(self, Feature_Permutation):
+			if np.isscalar(baseline):
+				kwargs['baselines'] = baseline
+			elif type(baseline) is np.ndarray:
+				kwargs['baselines'] = torch.tensor(baseline)
+			elif type(baseline) is torch.Tensor:
+				kwargs['baselines'] = baseline
+
+		# labels
+		if self.predictor_type == "classifier":
+			kwargs['target'] = y
+
+		# define feature mask looking at the desired number of segment
+		if n_segments != -1:
+			groups = _equal_length_segmentation(n_segments, n_channels, series_length)
+			kwargs['feature_mask'] = groups
+
+		return kwargs
+
+
+class Feature_Ablation(_tsCaptum_Method):
+	r"""
+	Wrapper for Feature Ablation method
+	"""
+
+	def __init__(self, clf, clf_type=None):
+		super().__init__(_FeatureAblationCaptum, clf, clf_type)
+
+
+class Feature_Permutation(_tsCaptum_Method):
+	r"""
+	Wrapper for feature permutation method
+	"""
+
+	def __init__(self, clf, clf_type=None):
+		super().__init__(_FeaturePermutationCaptum, clf, clf_type)
+
+	def explain(self, samples, **kwargs):
+		r"""
+		extending _tsCaptum_Method's explain by fixing some arguments as defined by Captum implementation.
+		For Feature Permutation takes care of the batch_size > 2 and baseline which can't be provided
+
+		:param samples: samples to be explained
+
+		:param kwargs:  additional arguments
+
+		:calling:       _tsCaptum_Method'e explain
+		"""
+		if 'batch_size' in kwargs and kwargs['batch_size'] != 1:
+			warnings.warn(
+				"batch_size set to 2 as Feature Permutation require more than 1 sample to work"
+			)
+			kwargs['batch_size'] = 2
+
+		if 'baseline' in kwargs:
+			warnings.warn(
+				"specified baseline will be ignored as Feature Permutation algorithm has its own baseline"
+			)
+		return super().explain(samples, **kwargs)
+
+
+class Kernel_Shap(_tsCaptum_Method):
+	r"""
+	Wrapper for KernelSHAP method
+	"""
+
+	def __init__(self, clf, clf_type=None):
+		super().__init__(_KernelShapCaptum, clf, clf_type)
+
+	def explain(self, samples, **kwargs):
+		r"""
+		extending _tsCaptum_Method'e explain by fixing some arguments as defined by Captum implementation.
+		For KernelSHAP takes care of the batch_size suggested to be equal to 1
+
+		:param samples: samples to be explained
+
+		:param kwargs:  additional arguments
+
+		:calling:       _tsCaptum_Method's explain
+		"""
+		if 'batch_size' in kwargs and kwargs['batch_size'] != 1:
+			warnings.warn(
+				"batch_size set to 1 as suggested by Captum for Lime and KernelSHAP"
+			)
+		kwargs['batch_size'] = 1
+		return super().explain(samples, **kwargs)
+
+
+class LIME(_tsCaptum_Method):
+	r"""
+	Wrapper for LIME method
+	"""
+
+	def __init__(self, clf, clf_type=None):
+		super().__init__(_LimeCaptum, clf, clf_type)
+
+	def explain(self, samples, **kwargs):
+		r"""
+		extending _tsCaptum_Method'e explain by fixing some arguments as defined by Captum implementation.
+		For LIME takes care of the batch_size suggested to be equal to 1
+
+		:param samples: samples to be explained
+
+		:param kwargs:  additional arguments
+
+		:calling:       _tsCaptum_Method's explain
+		"""
+		if 'batch_size' in kwargs and kwargs['batch_size'] != 1:
+			warnings.warn(
+				"batch_size set to 1 as suggested by Captum for Lime and KernelSHAP"
+			)
+		kwargs['batch_size'] = 1
+		return super().explain(samples, **kwargs)
+
+
+class Shapley_Value_Sampling(_tsCaptum_Method):
+	r"""
+	Wrapper for Shapley Value Sampling method. Most of the time this is the best approximation of the intractable
+	Shapley values
+	"""
+
+	def __init__(self, clf, clf_type=None):
+		super().__init__(_ShapleyValueSamplingCaptum, clf, clf_type)

tscaptum-0.0.1/src/tsCaptum/visualization.py

@@ -0,0 +1,27 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from scipy.interpolate import interp1d
+
+def plot_saliency_map_uni(sample, attribution, title = 'Saliency map'):
+
+	def transform(X):
+		ma,mi = np.max(X), np.min(X)
+		X = (X - mi)/(ma-mi)
+		return X*100
+
+	weight = transform(abs(attribution))
+	ts = np.squeeze(sample)
+
+	max_length1, max_length2 = ts.shape[0],10000 #
+	x1 = np.linspace(0,max_length1,num = max_length1)
+	x2 = np.linspace(0,max_length1,num = max_length2)
+	y1 = ts
+
+	f = interp1d(x1, y1) # interpolate time series
+	fcas = interp1d(x1, weight) # interpolate weight color
+	weight = fcas(x2) # convert vector of original weight vector to new weight vector
+
+	plt.figure(figsize=(6, 2))
+	plt.scatter(x2,f(x2), c = weight, cmap = 'jet', marker='.', s= 1,vmin=0,vmax = 100)
+	plt.title(title)
+	plt.show()

tscaptum-0.0.1/src/tsCaptum.egg-info/PKG-INFO

@@ -0,0 +1,54 @@
+Metadata-Version: 2.1
+Name: tsCaptum
+Version: 0.0.1
+Summary: A Captum wrapper for Time Series XAI
+Author-email: Davide Serramazza <davide.serramazza@ucdconnect.ie>
+Project-URL: Homepage, https://github.com/mlgig/tscaptum/
+Requires-Python: <3.12,>=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: scikit-learn
+Requires-Dist: aeon
+Requires-Dist: openpyxl
+Requires-Dist: tqdm
+Requires-Dist: torch>=2.0.0
+Requires-Dist: captum==0.7.0
+
+# tsCaptum - A library for univariate and multivariate time series explanation
+
+tsCaptum is a library that adapts the popular post-hoc attribution methods implemented in the Captum
+framework to work with time series. Unlike previous libraries tsCaptum is :
+1) Fully compatible with scikit-learn and popular time-series frameworks such as aeon and sktime (e.g., so it is easy to combine ROCKET with SHAP).
+2) Takes advantage of TS locality by using time series segmentation (so SHAP runs fast with long time series and suffers less from vanishing attribution weights) 
+3) It's extremely easy to use requiring almost no effort by the users
+
+```
+from aeon.classification.convolution_based import RocketClassifier
+clf = RocketClassifier(n_jobs=-1)
+clf.fit(MP_X_train,MP_y_train)
+
+from tsCaptum.explainers import Feature_Ablation
+myFA = Feature_Ablation(clf)
+exp = myFA.explain(samples=CMJ_X_test_samples, labels=CMJ_y_test_samples, n_segments=10, normalise=False, baseline=0)
+
+from tsCaptum.explainers import Shapley_Value_Sampling as SHAP
+mySHAP = SHAP(clf)
+exp = mySHAP.explain(CMJ_X_test_samples, labels=CMJ_y_test_samples,  n_segments=10, normalise=False, baseline=0)
+
+```
+
+It can be installed by typing the command "pip install tsCaptum" or in case you have problems 
+installing torch (e.g. you use Linux as OS and you want a lighter installation) use 
+"pip3 install torch --index-url https://download.pytorch.org/whl/cpu && pip install tsCaptum"
+
+In case you use this library please cite:
+```
+@misc{tsCaptum,
+    author = {Davide Italo Serramazza, Thach Le Nguyen, Georgiana Ifrim},
+    title = {tsCaptum: adapting Captum explainers for time series and scikit-learn-like predictors},
+    howpublished = {GitHub},
+    year = {2024},
+    note = {Temporary bibitex entry},
+    url = { https://github.com/mlgig/tscaptum },
+}
+```

tscaptum-0.0.1/src/tsCaptum.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+src/tsCaptum/_forwarder.py
+src/tsCaptum/_tsCaptum_loader.py
+src/tsCaptum/_utils.py
+src/tsCaptum/explainers.py
+src/tsCaptum/visualization.py
+src/tsCaptum.egg-info/PKG-INFO
+src/tsCaptum.egg-info/SOURCES.txt
+src/tsCaptum.egg-info/dependency_links.txt
+src/tsCaptum.egg-info/requires.txt
+src/tsCaptum.egg-info/top_level.txt

tscaptum-0.0.1/src/tsCaptum.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

tscaptum-0.0.1/src/tsCaptum.egg-info/requires.txt

@@ -0,0 +1,6 @@
+scikit-learn
+aeon
+openpyxl
+tqdm
+torch>=2.0.0
+captum==0.7.0

tscaptum-0.0.1/src/tsCaptum.egg-info/top_level.txt

@@ -0,0 +1 @@
+tsCaptum