Add ECS dimension selector.

docs/more/whatsnew.rst

@@ -41,6 +41,10 @@ Wildboar 1.2 introduces several new models.
  the specified top `k` dimensions with the highest score.
  - :class:`~wildboar.dimension_selection.SelectDimensionPercentile`: only retain
  the dimensions with a `p-value` below the specified alpha level.
+ - :class:`~wildboar.dimension_selection.ECSSelector`: Select time series
+ dimensions based on the sum of distances between pairs of classes.
+
+
 
 - Add a new module :mod:`~wildboar.distance.lb` for distance lower bounds. The module
  contains four lower bounds.

src/wildboar/dimension_selection/__init__.py

@@ -7,6 +7,7 @@
  SelectDimensionSignificance,
  SelectDimensionTopK,
 )
+from ._ecp import ECSSelector
 from ._sequential import SequentialDimensionSelector
 from ._variance import DistanceVarianceThreshold
 
@@ -16,4 +17,5 @@
  "SelectDimensionPercentile",
  "SelectDimensionSignificance",
  "SelectDimensionTopK",
+ "ECSSelector",
 ]

src/wildboar/dimension_selection/_ecp.py

@@ -0,0 +1,140 @@
+# Authors: Isak Samsten
+# License: BSD 3 clause
+
+import abc
+import numbers
+
+import numpy as np
+from sklearn.base import _fit_context
+from sklearn.validation._parameter_constraints import Interval, StrOptions
+
+from ..base import BaseEstimator
+from ..distance._distance import pairwise_distance
+from ..distance.dtw import dtw_average
+from ..utils.validation import MetricOptions, check_classification_targets
+from ._base import DimensionSelectorMixin
+
+
+class _Prototype(metaclass=abc.ABCMeta):
+ def __init__(self, *args, **kwargs):
+ pass
+
+ @abc.abstractmethod
+ def create(self, X):
+ pass
+
+
+class _DtwPrototype(_Prototype):
+ def __init__(self, r):
+ self.r = r
+
+ def create(self, X):
+ return dtw_average(X, r=self.r)
+
+
+class _MeanPrototype(_Prototype):
+ def create(self, X):
+ return np.mean(X, axis=0)
+
+
+class _MedianPrototype(_Prototype):
+ def create(self, X):
+ return np.median(X, axis=0)
+
+
+_PROTOTYPE = {"mean": _MeanPrototype, "median": _MeanPrototype, "dtw": _DtwPrototype}
+
+
+class ECSSelector(DimensionSelectorMixin, BaseEstimator):
+ """
+ ElboxClassSum (ECS) dimension selector.
+
+ Select time series dimensions based on the sum of distances between pairs
+ of classes.
+
+ Parameters
+ ----------
+ prototype : {"mean", "median", "dtw"}, optional
+ The method for computing the class prototypes.
+ r : float, optional
+ The warping width if `prototype` is "dtw".
+ metric : str, optional
+ The distance metric.
+ metric_params : dict, optional
+ Optional parameters to the distance metric.
+
+ Read more about the metrics and their parameters in the
+ :ref:`User guide <list_of_metrics>`.
+ """
+
+ _parameter_constraints = {
+ "prototype": [StrOptions(_PROTOTYPE.keys())],
+ "r": [
+ None,
+ Interval(numbers.Integral, 0, None, closed="left"),
+ Interval(numbers.Real, 0, 1, closed="both"),
+ ],
+ "metric": [MetricOptions()],
+ "metric_params": [None, dict],
+ }
+
+ def __init__(
+ self, prototype="mean", r=None, metric="euclidean", metric_params=None
+ ):
+ self.prototype = prototype
+ self.metric = metric
+ self.metric_params = metric_params
+ self.r = r
+
+ @_fit_context(prefer_skip_nested_validation=True)
+ def fit(self, X, y):
+ """
+ Learn the dimensions to select.
+
+ Parameters
+ ----------
+ X : array-like of shape (n_samples, n_dims, n_timestep)
+ The training samples.
+ y : array-like of shape (n_samples, )
+ Ignored.
+
+ Returns
+ -------
+ object
+ The instance itself.
+ """
+ X, y = self._validate_data(X, y, allow_3d=True, ensure_min_dims=2)
+ check_classification_targets(y)
+ labels = np.unique(y)
+ n_labels = len(labels)
+ n_combinations = int(n_labels * (n_labels - 1) / 2)
+ _, n_dims, n_timestep = X.shape
+
+ prototype_factory = _PROTOTYPE[self.prototype](
+ self.r if self.r is not None else 1.0
+ )
+ prototypes = np.empty((n_dims, n_labels, n_timestep), dtype=X.dtype)
+ for i in range(n_labels):
+ for d in range(n_dims):
+ prototypes[d, i] = prototype_factory.create(X[y == labels[i], d])
+
+ proto_dist = np.empty((n_dims, n_combinations), dtype=float)
+ for d in range(n_dims):
+ k = 0
+ for i in range(n_labels):
+ for j in range(i + 1, n_labels):
+ proto_dist[d, k] = pairwise_distance(
+ prototypes[d, i], prototypes[d, j], metric=self.metric
+ )
+ k += 1
+
+ dim_sum = np.sum(proto_dist, axis=1)
+ self.dim_sort_ind_ = np.argsort(dim_sum)[::-1]
+ p = np.linspace(dim_sum.max(), dim_sum.min(), dim_sum.size)
+ self.elbow_ = np.abs(dim_sum[self.dim_sort_ind_] - p).argmax()
+ return self
+
+ def _get_dimensions(self):
+ mask = np.zeros(self.n_dims_in_, dtype=bool)
+ mask[self.dim_sort_ind_[: self.elbow_]] = True
+ return mask