diff --git a/aeon/distances/_bounding_matrix.py b/aeon/distances/_bounding_matrix.py index ae2391f850..621f5330ea 100644 --- a/aeon/distances/_bounding_matrix.py +++ b/aeon/distances/_bounding_matrix.py @@ -10,7 +10,7 @@ def create_bounding_matrix( x_size: int, y_size: int, window: float = None, itakura_max_slope: float = None ): - """Create a bounding matrix for a elastic distance. + """Create a bounding matrix for an elastic distance. Parameters ---------- diff --git a/aeon/registry/_base_classes.py b/aeon/registry/_base_classes.py index 037dcbd38f..e04a30c2f3 100644 --- a/aeon/registry/_base_classes.py +++ b/aeon/registry/_base_classes.py @@ -42,6 +42,7 @@ from aeon.networks.base import BaseDeepNetwork from aeon.performance_metrics.base import BaseMetric from aeon.regression.base import BaseRegressor +from aeon.similarity_search.base import BaseSimiliaritySearch from aeon.transformations.base import BaseTransformer from aeon.transformations.collection import BaseCollectionTransformer @@ -63,6 +64,7 @@ BaseCollectionTransformer, "time series collection transformer", ), + ("similarity-search", BaseSimiliaritySearch, "similarity search"), ] diff --git a/aeon/registry/_tags.py b/aeon/registry/_tags.py index df05eaf985..fce62f2bb8 100644 --- a/aeon/registry/_tags.py +++ b/aeon/registry/_tags.py @@ -220,6 +220,7 @@ "early_classifier", "regressor", "transformer", + "similarity-search", ], "bool", "can the estimator classify time series with 2 or more variables?", diff --git a/aeon/registry/tests/test_lookup.py b/aeon/registry/tests/test_lookup.py index cdeb2ae1c7..a0bd8bb167 100644 --- a/aeon/registry/tests/test_lookup.py +++ b/aeon/registry/tests/test_lookup.py @@ -19,6 +19,7 @@ "network", "collection-transformer", "collection-estimator", + "similarity-search", ] # shorthands for easy reading diff --git a/aeon/similarity_search/__init__.py b/aeon/similarity_search/__init__.py new file mode 100644 index 0000000000..a91bb7355d --- /dev/null +++ b/aeon/similarity_search/__init__.py @@ -0,0 +1,7 @@ +"""BaseSimilaritySearch.""" + +__author__ = ["baraline"] +__all__ = ["BaseSimiliaritySearch", "TopKSimilaritySearch"] + +from aeon.similarity_search.base import BaseSimiliaritySearch +from aeon.similarity_search.top_k_similarity import TopKSimilaritySearch diff --git a/aeon/similarity_search/_dummy.py b/aeon/similarity_search/_dummy.py new file mode 100644 index 0000000000..a4462631c9 --- /dev/null +++ b/aeon/similarity_search/_dummy.py @@ -0,0 +1,114 @@ +"""Dummy similarity seach estimator.""" + +__author__ = ["baraline"] +__all__ = ["DummySimilaritySearch"] + + +from aeon.similarity_search.base import BaseSimiliaritySearch + + +class DummySimilaritySearch(BaseSimiliaritySearch): + """ + DummySimilaritySearch for testing of the BaseSimiliaritySearch class. + + Parameters + ---------- + distance : str, default ="euclidean" + Name of the distance function to use. + normalize : bool, default = False + Whether the distance function should be z-normalized. + store_distance_profile : bool, default = =False. + Whether to store the computed distance profile in the attribute + "_distance_profile" after calling the predict method. + + Attributes + ---------- + _X : array, shape (n_instances, n_channels, n_timestamps) + The input time series stored during the fit method. + distance_profile_function : function + The function used to compute the distance profile affected + during the fit method based on the distance and normalize + parameters. + + Examples + -------- + >>> from aeon.similarity_search._dummy import DummySimilaritySearch + >>> from aeon.datasets import load_unit_test + >>> X_train, y_train = load_unit_test(split="train") + >>> X_test, y_test = load_unit_test(split="test") + >>> clf = DummySimilaritySearch() + >>> clf.fit(X_train, y_train) + DummySimilaritySearch(...) + >>> q = X_test[0, :, 5:15] + >>> y_pred = clf.predict(q) + """ + + def __init__( + self, distance="euclidean", normalize=False, store_distance_profile=False + ): + super(DummySimilaritySearch, self).__init__( + distance=distance, + normalize=normalize, + store_distance_profile=store_distance_profile, + ) + + def _fit(self, X, y): + """ + Private fit method, does nothing more than the base class. + + Parameters + ---------- + X : array, shape (n_instances, n_channels, n_timestamps) + Input array to used as database for the similarity search + y : optional + Not used. + + Returns + ------- + self + + """ + return self + + def _predict(self, q, mask): + """ + Private predict method for DummySimilaritySearch. + + It compute the distance profiles and then returns the best match + + Parameters + ---------- + q : array, shape (n_channels, q_length) + Input query used for similarity search. + mask : array, shape (n_instances, n_channels, n_timestamps - (q_length - 1)) + Boolean mask of the shape of the distance profile indicating for which part + of it the distance should be computed. + + Returns + ------- + array + An array containing the index of the best match between q and _X. + + """ + if self.normalize: + distance_profile = self.distance_profile_function( + self._X, + q, + mask, + self._X_means, + self._X_stds, + self._q_means, + self._q_stds, + ) + else: + distance_profile = self.distance_profile_function(self._X, q, mask) + + if self.store_distance_profile: + self._distance_profile = distance_profile + + # For now, deal with the multidimensional case as "dependent", so we sum. + search_size = distance_profile.shape[-1] + distance_profile = distance_profile.sum(axis=1) + _id_best = distance_profile.argmin(axis=None) + + return [(_id_best // search_size, _id_best % search_size)] diff --git a/aeon/similarity_search/base.py b/aeon/similarity_search/base.py new file mode 100644 index 0000000000..3ecff52861 --- /dev/null +++ b/aeon/similarity_search/base.py @@ -0,0 +1,233 @@ +"""Base class for similarity search.""" + +__author__ = ["baraline"] + +from abc import ABC, abstractmethod +from collections.abc import Iterable +from typing import final + +import numpy as np + +from aeon.base import BaseEstimator +from aeon.similarity_search.distance_profiles import ( + naive_euclidean_profile, + normalized_naive_euclidean_profile, +) +from aeon.utils.numba.general import sliding_mean_std_one_series + + +class BaseSimiliaritySearch(BaseEstimator, ABC): + """ + BaseSimilaritySearch. + + Parameters + ---------- + distance : str, default ="euclidean" + Name of the distance function to use. + normalize : bool, default = False + Whether the distance function should be z-normalized. + store_distance_profile : bool, default = False. + Whether to store the computed distance profile in the attribute + "_distance_profile" after calling the predict method. + + Attributes + ---------- + _X : array, shape (n_instances, n_channels, n_timestamps) + The input time series stored during the fit method. + distance_profile_function : function + The function used to compute the distance profile affected + during the fit method based on the distance and normalize + parameters. + """ + + _tags = { + "capability:multivariate": True, + "capability:missing_values": False, + } + + def __init__( + self, distance="euclidean", normalize=False, store_distance_profile=False + ): + self.distance = distance + self.normalize = normalize + self.store_distance_profile = store_distance_profile + super(BaseSimiliaritySearch, self).__init__() + + def _get_distance_profile_function(self): + dist_profile = DISTANCE_PROFILE_DICT.get(self.distance) + if dist_profile is None: + raise ValueError( + f"Unknown or unsupported distance profile function {dist_profile}" + ) + return dist_profile[self.normalize] + + def _store_mean_std_from_inputs(self, q_length): + n_instances, n_channels, X_length = self._X.shape + search_space_size = X_length - q_length + 1 + + means = np.zeros((n_instances, n_channels, search_space_size)) + stds = np.zeros((n_instances, n_channels, search_space_size)) + + for i in range(n_instances): + _mean, _std = sliding_mean_std_one_series(self._X[i], q_length, 1) + stds[i] = _std + means[i] = _mean + + self._X_means = means + self._X_stds = stds + + @final + def fit(self, X, y=None): + """ + Fit method: store the input data and get the distance profile function. + + Parameters + ---------- + X : array, shape (n_instances, n_channels, n_timestamps) + Input array to used as database for the similarity search + y : optional + Not used. + + Raises + ------ + TypeError + If the input X array is not 3D raise an error. + + Returns + ------- + self + + """ + # For now force (n_instances, n_channels, n_timestamps), we could convert 2D + # (n_channels, n_timestamps) to 3D with a warning + if not isinstance(X, np.ndarray) or X.ndim != 3: + raise TypeError( + "Error, only supports 3D numpy of shape" + "(n_instances, n_channels, n_timestamps)." + ) + + # Get distance function + self.distance_profile_function = self._get_distance_profile_function() + + self._X = X.astype(float) + self._fit(X, y) + return self + + @final + def predict(self, q, q_index=None, exclusion_factor=2.0): + """ + Predict method: Check the shape of q and call _predict to perform the search. + + If the distance profile function is normalized, it stores the mean and stds + from q and _X. + + Parameters + ---------- + q : array, shape (n_channels, q_length) + Input query used for similarity search. + q_index : Iterable, default=None + An Interable (tuple, list, array) used to specify the index of Q if it is + extracted from the input data X given during the fit method. + Given the tuple (id_sample, id_timestamp), the similarity search will define + an exclusion zone around the q_index in order to avoid matching q with + itself. If None, it is considered that the query is not extracted from X. + exclusion_factor : float, default=2. + The factor to apply to the query length to define the exclusion zone. The + exclusion zone is define from id_timestamp - q_length//exclusion_factor to + id_timestamp + q_length//exclusion_factor + + Raises + ------ + TypeError + If the input q array is not 2D raise an error. + ValueError + If the length of the query is greater + + Returns + ------- + array + An array containing the indexes of the matches between q and _X. + The decision of wheter a candidate of size q_length from _X is matched with + Q depends on the subclasses that implent the _predict method + (e.g. top-k, threshold, ...). + + """ + if not isinstance(q, np.ndarray) or q.ndim != 2: + raise TypeError( + "Error, only supports 2D numpy atm. If q is univariate" + " do q.reshape(1,-1)." + ) + + q_dim, q_length = q.shape + if q_length >= self._X.shape[-1]: + raise ValueError( + "The length of the query should be inferior or equal to the length of" + "data (X) provided during fit, but got {} for q and {} for X".format( + q_length, self._X.shape[-1] + ) + ) + + if q_dim != self._X.shape[1]: + raise ValueError( + "The number of feature should be the same for the query q and the data" + "(X) provided during fit, but got {} for q and {} for X".format( + q_dim, self._X.shape[1] + ) + ) + + n_instances, _, n_timestamps = self._X.shape + mask = np.ones((n_instances, q_dim, n_timestamps), dtype=bool) + + if q_index is not None: + if isinstance(q_index, Iterable): + if len(q_index) != 2: + raise ValueError( + "The q_index should contain an interable of size 2 such as" + "(id_sample, id_timestamp), but got an iterable of" + "size {}".format(len(q_index)) + ) + else: + raise TypeError( + "If not None, the q_index parameter should be an iterable, here" + " q_index is of type {}".format(type(q_index)) + ) + + if exclusion_factor <= 0: + raise ValueError( + "The value of exclusion_factor should be superior to 0, but got" + "{}".format(len(exclusion_factor)) + ) + + i_instance, i_timestamp = q_index + profile_length = n_timestamps - (q_length - 1) + exclusion_LB = max(0, int(i_timestamp - q_length // exclusion_factor)) + exclusion_UB = min( + profile_length, int(i_timestamp + q_length // exclusion_factor) + ) + mask[i_instance, :, exclusion_LB:exclusion_UB] = False + + if self.normalize: + self._q_means = np.mean(q, axis=-1) + self._q_stds = np.std(q, axis=-1) + self._store_mean_std_from_inputs(q_length) + + return self._predict(q.astype(float), mask) + + @abstractmethod + def _fit(self, X, y): + ... + + @abstractmethod + def _predict(self, q): + ... + + +# Dictionary structure : +# 1st lvl key : distance function used +# 2nd lvl key : boolean indicating whether distance is normalized +DISTANCE_PROFILE_DICT = { + "euclidean": { + True: normalized_naive_euclidean_profile, + False: naive_euclidean_profile, + } +} diff --git a/aeon/similarity_search/distance_profiles/__init__.py b/aeon/similarity_search/distance_profiles/__init__.py new file mode 100644 index 0000000000..35ea299261 --- /dev/null +++ b/aeon/similarity_search/distance_profiles/__init__.py @@ -0,0 +1,12 @@ +"""Distance profiles.""" + +__author__ = ["baraline"] +__all__ = ["naive_euclidean_profile", "normalized_naive_euclidean_profile"] + + +from aeon.similarity_search.distance_profiles.naive_euclidean import ( + naive_euclidean_profile, +) +from aeon.similarity_search.distance_profiles.normalized_naive_euclidean import ( + normalized_naive_euclidean_profile, +) diff --git a/aeon/similarity_search/distance_profiles/_commons.py b/aeon/similarity_search/distance_profiles/_commons.py new file mode 100644 index 0000000000..660ea8dbf5 --- /dev/null +++ b/aeon/similarity_search/distance_profiles/_commons.py @@ -0,0 +1,145 @@ +"""Helper and common function for similarity search distance profiles.""" + +import numpy as np +from numba import njit +from scipy.signal import convolve + +AEON_SIMSEARCH_STD_THRESHOLD = 1e-7 + + +@njit(cache=True) +def _get_input_sizes(X, q): + """ + Get sizes of the input and search space for similarity search. + + Parameters + ---------- + X : array, shape (n_instances, n_channels, series_length) + The input samples. + q : array, shape (n_channels, series_length) + The input query + + Returns + ------- + n_instances : int + Number of samples in X. + n_channels : int + Number of channels in X. + X_length : int + Number of timestamps in X. + q_length : int + Number of timestamps in q + profile_size : int + Size of the search space for similarity search for each sample in X + + """ + n_instances, n_channels, X_length = X.shape + q_length = q.shape[-1] + profile_size = X_length - q_length + 1 + return (n_instances, n_channels, X_length, q_length, profile_size) + + +@njit(fastmath=True, cache=True) +def _z_normalize_2D_series_with_mean_std(X, mean, std, copy=True): + """ + Z-normalize a 2D series given the mean and std of each channel. + + Parameters + ---------- + X : array, shape = (n_channels, n_timestamps) + Input array to normalize. + mean : array, shape = (n_channels) + Mean of each channel of X. + std : array, shape = (n_channels) + Std of each channel of X. + copy : bool, optional + Wheter to copy the input X to avoid modifying the values of the array it refers + to (if it is a reference). The default is True. + + Returns + ------- + X : array, shape = (n_channels, n_timestamps) + The normalized array + """ + if copy: + X = X.copy() + for i_channel in range(X.shape[0]): + X[i_channel] = (X[i_channel] - mean[i_channel]) / std[i_channel] + return X + + +@njit(fastmath=True, cache=True) +def _z_normalize_1D_series_with_mean_std(X, mean, std, copy=True): + """ + Z-normalize a 2D series given the mean and std of each channel. + + Parameters + ---------- + X : array, shape = (n_timestamps) + Input array to normalize. + mean : float + Mean of X. + std : float + Std of X. + copy : bool, optional + Wheter to copy the input X to avoid modifying the values of the array it refers + to (if it is a reference). The default is True. + + Returns + ------- + X : array, shape = (n_channels, n_timestamps) + The normalized array + """ + if copy: + X = X.copy() + X = (X - mean) / std + return X + + +def fft_sliding_dot_product(X, q): + """ + Use FFT convolution to calculate the sliding window dot product. + + Parameters + ---------- + X : array, shape=(n_features, n_timestamps) + Input time series + + q : array, shape=(n_features, q_length) + Input query + + Returns + ------- + output : shape=(n_features, n_timestamps - (length - 1)) + Sliding dot product between q and X. + """ + n_features, n_timestamps = X.shape[0] + length = q.shape[1] + out = np.zeros((n_features, n_timestamps - (length - 1))) + for i in range(n_features): + out[i, :] = convolve(np.flipud(q[i, :]), X[i, :], mode="valid").real + return out + + +def rolling_window_stride_trick(X, window): + """ + Use strides to generate rolling/sliding windows for a numpy array. + + Parameters + ---------- + X : numpy.ndarray + numpy array + + window : int + Size of the rolling window + + Returns + ------- + output : numpy.ndarray + This will be a new view of the original input array. + """ + a = np.asarray(X) + shape = a.shape[:-1] + (a.shape[-1] - window + 1, window) + strides = a.strides + (a.strides[-1],) + + return np.lib.stride_tricks.as_strided(a, shape=shape, strides=strides) diff --git a/aeon/similarity_search/distance_profiles/naive_euclidean.py b/aeon/similarity_search/distance_profiles/naive_euclidean.py new file mode 100644 index 0000000000..d61d2c15c8 --- /dev/null +++ b/aeon/similarity_search/distance_profiles/naive_euclidean.py @@ -0,0 +1,63 @@ +"""Naive Euclidean distance profile.""" + +__author__ = ["baraline"] + +import numpy as np +from numba import njit + +from aeon.distances import euclidean_distance +from aeon.similarity_search.distance_profiles._commons import _get_input_sizes + + +def naive_euclidean_profile(X, q, mask): + r""" + Compute a euclidean distance profile in a brute force way. + + It computes the distance profiles between the input time series and the query using + the Euclidean distance. The search is made in a brute force way without any + optimizations and can thus be slow. + + A distance profile between a (univariate) time series :math:`X_i = {x_1, ..., x_m}` + and a query :math:`Q = {q_1, ..., q_m}` is defined as a vector of size :math:`m-( + l-1)`, such as :math:`P(X_i, Q) = {d(C_1, Q), ..., d(C_m-(l-1), Q)}` with d the + Euclidean distance, and :math:`C_j = {x_j, ..., x_{j+(l-1)}}` the j-th candidate + subsequence of size :math:`l` in :math:`X_i`. + + Parameters + ---------- + X: array shape (n_cases, n_channels, series_length) + The input samples. + q : np.ndarray shape (n_channels, query_length) + The query used for similarity search. + mask : array, shape (n_instances, n_channels, n_timestamps - (q_length - 1)) + Boolean mask of the shape of the distance profile indicating for which part + of it the distance should be computed. + + Returns + ------- + distance_profile : np.ndarray + shape (n_cases, n_channels, series_length - query_length + 1) + The distance profile between q and the input time series X independently + for each channel. + + """ + return _naive_euclidean_profile(X, q, mask) + + +@njit(cache=True, fastmath=True) +def _naive_euclidean_profile(X, q, mask): + n_instances, n_channels, X_length, q_length, profile_size = _get_input_sizes(X, q) + distance_profile = np.full((n_instances, n_channels, profile_size), np.inf) + + for i_instance in range(n_instances): + for i_channel in range(n_channels): + for i_candidate in range(profile_size): + if mask[i_instance, i_channel, i_candidate]: + distance_profile[ + i_instance, i_channel, i_candidate + ] = euclidean_distance( + q[i_channel], + X[i_instance, i_channel, i_candidate : i_candidate + q_length], + ) + + return distance_profile diff --git a/aeon/similarity_search/distance_profiles/normalized_naive_euclidean.py b/aeon/similarity_search/distance_profiles/normalized_naive_euclidean.py new file mode 100644 index 0000000000..27649ac4a5 --- /dev/null +++ b/aeon/similarity_search/distance_profiles/normalized_naive_euclidean.py @@ -0,0 +1,86 @@ +"""normalized_naive_euclidean_profile.""" + +__author__ = ["baraline"] + +import numpy as np +from numba import njit + +from aeon.distances import euclidean_distance +from aeon.similarity_search.distance_profiles._commons import ( + AEON_SIMSEARCH_STD_THRESHOLD, + _get_input_sizes, + _z_normalize_1D_series_with_mean_std, + _z_normalize_2D_series_with_mean_std, +) + + +def normalized_naive_euclidean_profile(X, q, mask, X_means, X_stds, q_means, q_stds): + """ + Compute a euclidean distance profile in a brute force way. + + It computes the distance profiles between the input time series and the query using + the euclidean distance. The search is made in a brute force way without any + optimizations and can thus be slow. + + A distance profile between a (univariate) time series :math:`X_i = {x_1, ..., x_m}` + and a query :math:`Q = {q_1, ..., q_m}` is defined as a vector of size :math:`m-( + l-1)`, such as :math:`P(X_i, Q) = {d(C_1, Q), ..., d(C_m-(l-1), Q)}` with d the + Euclidean distance, and :math:`C_j = {x_j, ..., x_{j+(l-1)}}` the j-th candidate + subsequence of size :math:`l` in :math:`X_i`. + + Parameters + ---------- + X : array, shape (n_instances, n_channels, series_length) + The input samples. + q : array, shape (n_channels, query_length) + The query used for similarity search. + mask : array, shape (n_instances, n_channels, n_timestamps - (q_length - 1)) + Boolean mask of the shape of the distance profile indicating for which part + of it the distance should be computed. + X_means : array, shape (n_instances, n_channels, series_length - (query_length-1)) + Means of each subsequences of X of size query_length + X_stds : array, shape (n_instances, n_channels, series_length - (query_length-1)) + Stds of each subsequences of X of size query_length + q_means : array, shape (n_channels) + Means of the query q + q_stds : array, shape (n_channels) + Stds of the query q + + Returns + ------- + distance_profile : np.ndarray + shape (n_instances, n_channels, series_length - query_length + 1). + The distance profile between q and the input time series X independently + for each channel. + + """ + # Make STDS inferior to the threshold to 1 to avoid division per 0 error. + q_stds[q_stds < AEON_SIMSEARCH_STD_THRESHOLD] = 1 + X_stds[X_stds < AEON_SIMSEARCH_STD_THRESHOLD] = 1 + + return _normalized_naive_euclidean_profile( + X, q, mask, X_means, X_stds, q_means, q_stds + ) + + +@njit(cache=True, fastmath=True) +def _normalized_naive_euclidean_profile(X, q, mask, X_means, X_stds, q_means, q_stds): + n_instances, n_channels, X_length, q_length, profile_size = _get_input_sizes(X, q) + q = _z_normalize_2D_series_with_mean_std(q, q_means, q_stds) + distance_profile = np.full((n_instances, n_channels, profile_size), np.inf) + + # Compute euclidean distance for all candidate in a "brute force" way + for i_instance in range(n_instances): + for i_channel in range(n_channels): + for i_candidate in range(profile_size): + if mask[i_instance, i_channel, i_candidate]: + # Extract and normalize the candidate + _C = _z_normalize_1D_series_with_mean_std( + X[i_instance, i_channel, i_candidate : i_candidate + q_length], + X_means[i_instance, i_channel, i_candidate], + X_stds[i_instance, i_channel, i_candidate], + ) + distance_profile[ + i_instance, i_channel, i_candidate + ] = euclidean_distance(q[i_channel], _C) + return distance_profile diff --git a/aeon/similarity_search/distance_profiles/tests/__init__.py b/aeon/similarity_search/distance_profiles/tests/__init__.py new file mode 100644 index 0000000000..566dda7367 --- /dev/null +++ b/aeon/similarity_search/distance_profiles/tests/__init__.py @@ -0,0 +1 @@ +"""Tests for distance profiles.""" diff --git a/aeon/similarity_search/distance_profiles/tests/test_naive_euclidean.py b/aeon/similarity_search/distance_profiles/tests/test_naive_euclidean.py new file mode 100644 index 0000000000..dd568b5124 --- /dev/null +++ b/aeon/similarity_search/distance_profiles/tests/test_naive_euclidean.py @@ -0,0 +1,62 @@ +"""Tests for naive Euclidean distance profile.""" + +__author__ = ["baraline"] + +import numpy as np +import pytest +from numpy.testing import assert_array_almost_equal, assert_array_equal + +from aeon.distances import euclidean_distance +from aeon.similarity_search.distance_profiles.naive_euclidean import ( + naive_euclidean_profile, +) + +DATATYPES = ["float64"] + + +@pytest.mark.parametrize("dtype", DATATYPES) +def test_naive_euclidean(dtype): + X = np.asarray( + [[[1, 2, 3, 4, 5, 6, 7, 8]], [[1, 2, 4, 4, 5, 6, 5, 4]]], dtype=dtype + ) + q = np.asarray([[3, 4, 5]], dtype=dtype) + + mask = np.ones(X.shape, dtype=bool) + dist_profile = naive_euclidean_profile(X, q, mask).sum(axis=1) + + expected = np.array( + [ + [ + euclidean_distance(q, X[j, :, i : i + q.shape[-1]]) + for i in range(X.shape[-1] - q.shape[-1] + 1) + ] + for j in range(X.shape[0]) + ] + ) + assert_array_almost_equal(dist_profile, expected) + + +@pytest.mark.parametrize("dtype", DATATYPES) +def test_naive_euclidean_constant_case(dtype): + # Test constant case + X = np.ones((2, 1, 10), dtype=dtype) + q = np.zeros((1, 3), dtype=dtype) + + mask = np.ones(X.shape, dtype=bool) + dist_profile = naive_euclidean_profile(X, q, mask).sum(axis=1) + # Should be full array for sqrt(3) as q is zeros of length 3 and X is full ones + search_space_size = X.shape[-1] - q.shape[-1] + 1 + expected = np.array([[3**0.5] * search_space_size] * X.shape[0]) + assert_array_almost_equal(dist_profile, expected) + + +def test_non_alteration_of_inputs_naive_euclidean(): + X = np.asarray([[[1, 2, 3, 4, 5, 6, 7, 8]], [[1, 2, 4, 4, 5, 6, 5, 4]]]) + X_copy = np.copy(X) + q = np.asarray([[3, 4, 5]]) + q_copy = np.copy(q) + + mask = np.ones(X.shape, dtype=bool) + _ = naive_euclidean_profile(X, q, mask) + assert_array_equal(q, q_copy) + assert_array_equal(X, X_copy) diff --git a/aeon/similarity_search/distance_profiles/tests/test_normalized_naive_euclidean.py b/aeon/similarity_search/distance_profiles/tests/test_normalized_naive_euclidean.py new file mode 100644 index 0000000000..28da06cc58 --- /dev/null +++ b/aeon/similarity_search/distance_profiles/tests/test_normalized_naive_euclidean.py @@ -0,0 +1,110 @@ +"""Tests for naive normalized Euclidean distance profile.""" + +__author__ = ["baraline"] + +import numpy as np +import pytest +from numpy.testing import assert_array_almost_equal, assert_array_equal + +from aeon.distances import euclidean_distance +from aeon.similarity_search.distance_profiles.normalized_naive_euclidean import ( + normalized_naive_euclidean_profile, +) +from aeon.utils.numba.general import sliding_mean_std_one_series + +DATATYPES = ["float64"] + + +@pytest.mark.parametrize("dtype", DATATYPES) +def test_normalized_naive_euclidean(dtype): + X = np.asarray( + [[[1, 2, 3, 4, 5, 6, 7, 8]], [[1, 2, 4, 4, 5, 6, 5, 4]]], dtype=dtype + ) + q = np.asarray([[3, 4, 5]], dtype=dtype) + + search_space_size = X.shape[-1] - q.shape[-1] + 1 + + X_means = np.zeros((X.shape[0], X.shape[1], search_space_size)) + X_stds = np.zeros((X.shape[0], X.shape[1], search_space_size)) + + for i in range(X.shape[0]): + _mean, _std = sliding_mean_std_one_series(X[i], q.shape[-1], 1) + X_stds[i] = _std + X_means[i] = _mean + + q_means = q.mean(axis=-1) + q_stds = q.std(axis=-1) + mask = np.ones(X.shape, dtype=bool) + + dist_profile = normalized_naive_euclidean_profile( + X, q, mask, X_means, X_stds, q_means, q_stds + ) + dist_profile = dist_profile.sum(axis=1) + + _q = q.copy() + for k in range(q.shape[0]): + _q[k] = (_q[k] - q_means[k]) / q_stds[k] + + expected = np.full(dist_profile.shape, np.inf) + for i in range(X.shape[0]): + for j in range(search_space_size): + _C = X[i, :, j : j + q.shape[-1]].copy() + for k in range(X.shape[1]): + _C[k] = (_C[k] - X_means[i, k, j]) / X_stds[i, k, j] + expected[i, j] = euclidean_distance(_q, _C) + + assert_array_almost_equal(dist_profile, expected) + + +@pytest.mark.parametrize("dtype", DATATYPES) +def test_normalized_naive_euclidean_constant_case(dtype): + # Test constant case + X = np.ones((2, 2, 10), dtype=dtype) + q = np.zeros((2, 3), dtype=dtype) + + search_space_size = X.shape[-1] - q.shape[-1] + 1 + + q_means = q.mean(axis=-1, keepdims=True) + q_stds = q.std(axis=-1, keepdims=True) + + X_means = np.zeros((X.shape[0], X.shape[1], search_space_size)) + X_stds = np.zeros((X.shape[0], X.shape[1], search_space_size)) + for i in range(X.shape[0]): + _mean, _std = sliding_mean_std_one_series(X[i], q.shape[-1], 1) + X_stds[i] = _std + X_means[i] = _mean + + mask = np.ones(X.shape, dtype=bool) + dist_profile = normalized_naive_euclidean_profile( + X, q, mask, X_means, X_stds, q_means, q_stds + ).sum(axis=1) + # Should be full array for 0 + + expected = np.array([[0] * search_space_size] * X.shape[0]) + assert_array_almost_equal(dist_profile, expected) + + +def test_non_alteration_of_inputs_normalized_naive_euclidean(): + X = np.asarray([[[1, 2, 3, 4, 5, 6, 7, 8]], [[1, 2, 4, 4, 5, 6, 5, 4]]]) + X_copy = np.copy(X) + q = np.asarray([[3, 4, 5]]) + q_copy = np.copy(q) + + search_space_size = X.shape[-1] - q.shape[-1] + 1 + + X_means = np.zeros((X.shape[0], X.shape[1], search_space_size)) + X_stds = np.zeros((X.shape[0], X.shape[1], search_space_size)) + + for i in range(X.shape[0]): + _mean, _std = sliding_mean_std_one_series(X[i], q.shape[-1], 1) + X_stds[i] = _std + X_means[i] = _mean + + q_means = q.mean(axis=-1, keepdims=True) + q_stds = q.std(axis=-1, keepdims=True) + + mask = np.ones(X.shape, dtype=bool) + _ = normalized_naive_euclidean_profile(X, q, mask, X_means, X_stds, q_means, q_stds) + + assert_array_equal(q, q_copy) + assert_array_equal(X, X_copy) diff --git a/aeon/similarity_search/tests/__init__.py b/aeon/similarity_search/tests/__init__.py new file mode 100644 index 0000000000..0ddd46e48e --- /dev/null +++ b/aeon/similarity_search/tests/__init__.py @@ -0,0 +1 @@ +"""Similarity search Tests.""" diff --git a/aeon/similarity_search/tests/test_dummy.py b/aeon/similarity_search/tests/test_dummy.py new file mode 100644 index 0000000000..c05db2e7c4 --- /dev/null +++ b/aeon/similarity_search/tests/test_dummy.py @@ -0,0 +1,36 @@ +"""Tests for DummySimilaritySearch.""" + +__author__ = ["baraline"] + + +import numpy as np +import pytest +from numpy.testing import assert_array_equal + +from aeon.similarity_search._dummy import DummySimilaritySearch + +DATATYPES = ["int64", "float64"] + + +@pytest.mark.parametrize("dtype", DATATYPES) +def test_DummySimilaritySearch(dtype): + X = np.asarray( + [[[1, 2, 3, 4, 5, 6, 7, 8]], [[1, 2, 4, 4, 5, 6, 5, 4]]], dtype=dtype + ) + q = np.asarray([[3, 4, 5]], dtype=dtype) + + search = DummySimilaritySearch() + search.fit(X) + idx = search.predict(q) + assert_array_equal(idx, [(0, 2)]) + + search = DummySimilaritySearch(normalize=True) + search.fit(X) + q = np.asarray([[8, 8, 10]], dtype=dtype) + idx = search.predict(q) + assert_array_equal(idx, [(1, 2)]) + + search = DummySimilaritySearch(normalize=True) + search.fit(X) + idx = search.predict(q, q_index=(1, 2)) + assert_array_equal(idx, [(1, 0)]) diff --git a/aeon/similarity_search/tests/test_top_k_similarity.py b/aeon/similarity_search/tests/test_top_k_similarity.py new file mode 100644 index 0000000000..b8945c90a4 --- /dev/null +++ b/aeon/similarity_search/tests/test_top_k_similarity.py @@ -0,0 +1,40 @@ +"""Tests for TopKSimilaritySearch.""" + +__author__ = ["baraline"] + +import numpy as np +import pytest +from numpy.testing import assert_array_equal + +from aeon.similarity_search.top_k_similarity import TopKSimilaritySearch + +DATATYPES = ["int64", "float64"] + + +@pytest.mark.parametrize("dtype", DATATYPES) +def test_TopKSimilaritySearch(dtype): + X = np.asarray( + [[[1, 2, 3, 4, 5, 6, 7, 8]], [[1, 2, 4, 4, 5, 6, 5, 4]]], dtype=dtype + ) + q = np.asarray([[3, 4, 5]], dtype=dtype) + + search = TopKSimilaritySearch(k=1) + search.fit(X) + idx = search.predict(q) + assert_array_equal(idx, [(0, 2)]) + + search = TopKSimilaritySearch(k=3) + search.fit(X) + idx = search.predict(q) + assert_array_equal(idx, [(0, 2), (1, 2), (1, 1)]) + + search = TopKSimilaritySearch(k=1, normalize=True) + search.fit(X) + q = np.asarray([[8, 8, 10]], dtype=dtype) + idx = search.predict(q) + assert_array_equal(idx, [(1, 2)]) + + search = TopKSimilaritySearch(k=1, normalize=True) + search.fit(X) + idx = search.predict(q, q_index=(1, 2)) + assert_array_equal(idx, [(1, 0)]) diff --git a/aeon/similarity_search/top_k_similarity.py b/aeon/similarity_search/top_k_similarity.py new file mode 100644 index 0000000000..963a490e7a --- /dev/null +++ b/aeon/similarity_search/top_k_similarity.py @@ -0,0 +1,121 @@ +"""TopKSimilaritySearch.""" + +__author__ = ["baraline"] + +from aeon.similarity_search.base import BaseSimiliaritySearch + + +class TopKSimilaritySearch(BaseSimiliaritySearch): + """ + Top-K similarity search method. + + Finds the closest k series to the query series based on a distance function. + + Parameters + ---------- + k : int, default=1 + The number of nearest matches from Q to return. + distance : str, default ="euclidean" + Name of the distance function to use. + normalize : bool, default = False + Whether the distance function should be z-normalized. + store_distance_profile : bool, default = =False. + Whether to store the computed distance profile in the attribute + "_distance_profile" after calling the predict method. + + Attributes + ---------- + _X : array, shape (n_instances, n_channels, n_timestamps) + The input time series stored during the fit method. + distance_profile_function : function + The function used to compute the distance profile affected + during the fit method based on the distance and normalize + parameters. + + Examples + -------- + >>> from aeon.similarity_search import TopKSimilaritySearch + >>> from aeon.datasets import load_unit_test + >>> X_train, y_train = load_unit_test(split="train") + >>> X_test, y_test = load_unit_test(split="test") + >>> clf = TopKSimilaritySearch(k=1) + >>> clf.fit(X_train, y_train) + TopKSimilaritySearch(...) + >>> q = X_test[0, :, 5:15] + >>> y_pred = clf.predict(q) + """ + + def __init__( + self, k=1, distance="euclidean", normalize=False, store_distance_profile=False + ): + self.k = k + super(TopKSimilaritySearch, self).__init__( + distance=distance, + normalize=normalize, + store_distance_profile=store_distance_profile, + ) + + def _fit(self, X, y): + """ + Private fit method, does nothing more than the base class. + + Parameters + ---------- + X : array, shape (n_instances, n_channels, n_timestamps) + Input array to used as database for the similarity search + y : optional + Not used. + + Returns + ------- + self + + """ + return self + + def _predict(self, q, mask): + """ + Private predict method for TopKSimilaritySearch. + + It compute the distance profiles and return the top k matches + + Parameters + ---------- + q : array, shape (n_channels, q_length) + Input query used for similarity search. + mask : array, shape (n_instances, n_channels, n_timestamps - (q_length - 1)) + Boolean mask of the shape of the distance profile indicating for which part + of it the distance should be computed. + + Returns + ------- + array + An array containing the indexes of the best k matches between q and _X. + + """ + if self.normalize: + distance_profile = self.distance_profile_function( + self._X, + q, + mask, + self._X_means, + self._X_stds, + self._q_means, + self._q_stds, + ) + else: + distance_profile = self.distance_profile_function(self._X, q, mask) + + if self.store_distance_profile: + self._distance_profile = distance_profile + + # For now, deal with the multidimensional case as "dependent", so we sum. + distance_profile = distance_profile.sum(axis=1) + + search_size = distance_profile.shape[-1] + _argsort = distance_profile.argsort(axis=None)[: self.k] + + return [ + (_argsort[i] // search_size, _argsort[i] % search_size) + for i in range(self.k) + ] diff --git a/docs/api_reference.md b/docs/api_reference.md index e71b3f0736..f2ac63ac2c 100644 --- a/docs/api_reference.md +++ b/docs/api_reference.md @@ -24,6 +24,7 @@ api_reference/forecasting api_reference/networks api_reference/performance_metrics api_reference/regression +api_reference/similarity_search api_reference/transformations api_reference/utils api_reference/file_specifications/ts diff --git a/docs/api_reference/similarity_search.rst b/docs/api_reference/similarity_search.rst new file mode 100644 index 0000000000..a9880c1e58 --- /dev/null +++ b/docs/api_reference/similarity_search.rst @@ -0,0 +1,43 @@ +.. _similarity_search_ref: + +Time series Similarity Search +========================== + +The :mod:`aeon.similarity_search` module contains algorithms and tools for similarity search tasks. + + +Similarity search with a known query +------------------------------------ + +.. currentmodule:: aeon.similarity_search + +.. autosummary:: + :toctree: auto_generated/ + :template: class.rst + + TopKSimilaritySearch + + +Distance profile functions +-------------------------- + +.. currentmodule:: aeon.similarity_search.distance_profiles + +.. autosummary:: + :toctree: auto_generated/ + :template: function.rst + + naive_euclidean_profile + normalized_naive_euclidean_profile + + +Base +---- + +.. currentmodule:: aeon.similarity_search + +.. autosummary:: + :toctree: auto_generated/ + :template: class.rst + + BaseSimiliaritySearch diff --git a/docs/getting_started.md b/docs/getting_started.md index 79fc11aff2..112938ce2c 100644 --- a/docs/getting_started.md +++ b/docs/getting_started.md @@ -22,6 +22,8 @@ instance are used to predict a continuous target value. instances with similar time series. - {term}`Time series annotation` which is focused on outlier detection, anomaly detection, change point detection and segmentation. +- {term}`Time series similarity search` where the goal is to evaluate the similarity +between a time series against a collection of other time series. Additionally, it provides numerous algorithms for {term}`time series transformation`, altering time series into different representations and domains or processing @@ -632,3 +634,44 @@ the available `scikit-learn` functionality. >>> gscv.best_params_ {'distance': 'euclidean', 'n_neighbors': 5} ``` + +## Time series similarity search + +The similarity search module in `aeon` offers a set of functions and estimators to solve +tasks related to time series similarity search. The estimators can be used standalone +or as parts of pipelines, while the functions give you to the tools to build your own +estimators that would rely on similarity search at some point. + +The estimators are inheriting from the [BaseSimiliaritySearch](similarity_search.base.BaseSimiliaritySearch) +class accept 3D collection of time series as input types. This collection asked for the +fit method is stored as a database, which will be used in the predict method. The +predict method expect a single 2D time series. All inputs are expected to be in numpy +array format. Then length of the time series in the 3D collection should be superior or +equal to the length of the 2D time series given in the predict method. + +Given those two inputs, the predict method should return the set of most similar +candidates to the 2D series in the 3D collection. The following example shows how to use +the [TopKSimilaritySearch](similarity_search.top_k_similarity.TopKSimilaritySearch) +class to extract the best `k` matches, using the Euclidean distance as similarity +function. + +```{code-block} python +>>> import numpy as np +>>> from aeon.similarity_search import TopKSimilaritySearch +>>> X = [[[1, 2, 3, 4, 5, 6, 7]], # 3D array example (univariate) +... [[4, 4, 4, 5, 6, 7, 3]]] # Two samples, one channel, seven series length +>>> X = np.array(X) # X is of shape (2, 1, 7) : (n_samples, n_channels, n_timestamps) +>>> topk = TopKSimilaritySearch(distance="euclidean",k=2) +>>> topk.fit(X) # fit the estimator on train data +... +>>> q = np.array([[4, 5, 6]]) # q is of shape (1,3) : +>>> topk.predict(q) # Identify the two (k=2) most similar subsequences of length 3 in X +[(0, 3), (1, 2)] +``` +The output of predict gives a list of size `k`, where each element is a set indicating +the location of the best matches in X as `(id_sample, id_timestamp)`. This is equivalent +to the subsequence `X[id_sample, :, id_timestamps:id_timestamp + q.shape[0]]`. + +Note that you can still use univariate time series as inputs, you will just have to +convert them to multivariate time series with one feature prior to using the similarity +search module. diff --git a/docs/glossary.md b/docs/glossary.md index fdf314862d..b687fd27a7 100644 --- a/docs/glossary.md +++ b/docs/glossary.md @@ -93,6 +93,12 @@ Time series transformers See {term}`series-to-series transformation` and {term}`series-to-features transformation` for types of transformer. +Time series similarity search + A task focused on finding the most similar candidates to a given + {term}`time series` of length `l`, called the query. The candidates are + extracted from a collection of {term}`time series` of length equal or + superior to `l`. + Collection transformers {term}`Time series transformers` that take a {term}`time series collection` as input. While these transformers only accept collections, a wrapper is provided to diff --git a/docs/index.md b/docs/index.md index 4b69d58e79..bc108668a0 100644 --- a/docs/index.md +++ b/docs/index.md @@ -167,6 +167,26 @@ Annotation ::: +:::{grid-item-card} +:img-top: examples/similarity_search/img/sim_search.png +:class-img-top: aeon-card-image +:text-align: center + + +Similarity search + ++++ + +```{button-ref} /examples/similarity_search/similarity_search.ipynb +:color: primary +:click-parent: +:expand: + +Similarity search +``` + +::: + :::{grid-item-card} :img-top: examples/datasets/img/data.png :class-img-top: aeon-card-image diff --git a/examples/similarity_search/code_speed.ipynb b/examples/similarity_search/code_speed.ipynb new file mode 100644 index 0000000000..de3df5c860 --- /dev/null +++ b/examples/similarity_search/code_speed.ipynb @@ -0,0 +1,177 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "599bd2b3-ed7b-42b4-b886-991e9a05688c", + "metadata": {}, + "source": [ + "# Analysis of the speedups provided by similarity search module" + ] + }, + { + "cell_type": "markdown", + "id": "5a57d08d-a74a-453a-a17c-4e359d5f88ee", + "metadata": {}, + "source": [ + "In this notebook, we will explore the gains in time and memory of the different methods we use in the similarity search module." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "38d4fd81-15e4-4139-a761-6ba7005d352e", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "from matplotlib import pyplot as plt\n", + "\n", + "from aeon.similarity_search.distance_profiles._commons import (\n", + " rolling_window_stride_trick,\n", + ")\n", + "from aeon.utils.numba.general import sliding_mean_std_one_series\n", + "\n", + "sns.set()\n", + "sns.set_context()" + ] + }, + { + "cell_type": "markdown", + "id": "a40f071d-0672-4242-9c8c-e8d4a62c7a4d", + "metadata": {}, + "source": [ + "## Computing means and standard deviations for all subsequences" + ] + }, + { + "cell_type": "markdown", + "id": "a55ec2d8-e8e5-4ca6-8792-16cd93a2c705", + "metadata": {}, + "source": [ + "When we want to compute a normalized distance, given a time series `X` of size `m` and a query `q` of size `l`, we have to compute the mean and standard deviation for all subsequences of size `l` in `X`. One could do this task by doing the following:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "e2b76314-ccf4-4c6d-96bc-0b1cb3c97f6b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(1, 91)\n" + ] + } + ], + "source": [ + "def get_means_stds(X, q_length):\n", + " windows = rolling_window_stride_trick(X, q_length)\n", + " return windows.mean(axis=-1), windows.std(axis=-1)\n", + "\n", + "\n", + "rng = np.random.default_rng()\n", + "size = 100\n", + "q_length = 10\n", + "\n", + "# Create a random series with 1 feature and 'size' timesteps\n", + "X = rng.random((1, size))\n", + "means, stds = get_means_stds(X, q_length)\n", + "print(means.shape)" + ] + }, + { + "cell_type": "markdown", + "id": "98e7aa71-65e6-4975-bea0-2188368eed9a", + "metadata": {}, + "source": [ + "One issue with this code is that it actually recompute a lot of information between the computation of mean and std of each windows. Suppose that the window we compute the mean for `W_i = {x_i, ..., x_{i+(l-1)}`, to do this, we sum all the elements and divide them by `l`. You then want to compute the mean for `W_{i+1} = {x_{i+1}, ..., x_{i+1+(l-1)}`, which shares most of its values with `W_i` expect for `x_i` and `x_{i+1+(l-1)`. \n", + "\n", + "The optimization here consists in keeping a rolling sum, we only compute the full sum of the `l` values for the first window `W_0`, then to obtain the sum for `W_1`, we remove `x_0` and add `x_{1+(l-1)}` from the sum of `W_0`. We can also a rolling squared sum to compute the standard deviation.\n", + "\n", + "The `sliding_mean_std_one_series` function implement the computation of the means and standard deviations using these two rolling sums. The last argument indicates the dilation to apply to the subsequence, which is not used here, hence the value of 1 in the code bellow." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "5c48986d-dca0-44f2-9d7a-a67fc32731e9", + "metadata": {}, + "outputs": [], + "source": [ + "sizes = [500, 1000, 5000, 10000, 50000]\n", + "q_lengths = [50, 100, 250, 500]\n", + "times = pd.DataFrame(\n", + " index=pd.MultiIndex(levels=[[], []], codes=[[], []], names=[\"size\", \"q_length\"])\n", + ")\n", + "# A first run for numba compilations if needed\n", + "sliding_mean_std_one_series(rng.random((1, 50)), 10, 1)\n", + "for size in sizes:\n", + " for q_length in q_lengths:\n", + " X = rng.random((1, size))\n", + " _times = %timeit -r 7 -n 10 -q -o get_means_stds(X, q_length)\n", + " times.loc[(size, q_length), \"full computation\"] = _times.average\n", + " _times = %timeit -r 7 -n 10 -q -o sliding_mean_std_one_series(X, q_length, 1)\n", + " times.loc[(size, q_length), \"sliding_computation\"] = _times.average" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "01e14732-7675-463f-a4ed-2f903d12142f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(ncols=len(q_lengths), figsize=(20, 5), dpi=200)\n", + "for j, (i, grp) in enumerate(times.groupby(\"q_length\")):\n", + " grp.droplevel(1).plot(label=i, ax=ax[j])\n", + " ax[j].set_title(f\"query length {i}\")\n", + "ax[0].set_ylabel(\"time in seconds\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "75f15e37-5735-4d33-b2cf-70235420b724", + "metadata": {}, + "source": [ + "As you can see, the larger the size of `q`, the greater the speedups. This is because the larger the size of `q`, the more recomputation we avoid by using a sliding sum." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (Spyder)", + "language": "python3", + "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.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/similarity_search/distance_profiles.ipynb b/examples/similarity_search/distance_profiles.ipynb new file mode 100644 index 0000000000..25ca2fe6f7 --- /dev/null +++ b/examples/similarity_search/distance_profiles.ipynb @@ -0,0 +1,67 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "2be06527-dbbe-4c32-af27-0b0ff904311d", + "metadata": {}, + "source": [ + "# Deep dive in the distance profiles" + ] + }, + { + "cell_type": "markdown", + "id": "d778bc25-a0c4-46b5-a14b-b0c92a1e5f3a", + "metadata": {}, + "source": [ + "In this notebook, we will talk more about the theory behind distance profile, how they are computed, and how they can be optimized. For practical experiments on the speedups implemented in aeon, refer to the notebook on the [Analysis of the speedups provided by similarity search module](code_speed.ipynb) notebook." + ] + }, + { + "cell_type": "markdown", + "id": "39d92f2c-e323-4f16-b1cf-d4ef09b15b05", + "metadata": {}, + "source": [ + "## What are distance profiles ?" + ] + }, + { + "cell_type": "markdown", + "id": "fad95e02-3d0e-46d7-98bc-7ba6aac66bd3", + "metadata": {}, + "source": [ + "In the context of similarity search, where we have as input a time series $X = \\{x_1, \\ldots, x_m\\}$ and a query $Q = \\{q_1, \\ldots, q_l\\}$, a distance profile is defined as a vector containing the similarity of $Q$ to every subsequence of size $l$ in $X$, with the $i^{th}$ subsequence denoted by $W_i = \\{x_i, \\ldots, x_{i+(l-1)}\\}$.\n", + "\n", + "Given a distance or dissimilarity function $dist$, such as the Euclidean distance, the distance profile $P(X,Q)$ is expressed as :\n", + "$$P(X, Q) = \\{dist(W_1, Q), \\ldots, dist(W_{m-(l-1)}, Q)\\}$$\n", + "\n", + "We can then find the \"best match\" between $Q$ and $X$ by looking at the distance profile minimum value and extract the subsequence $W_{\\text{argmin} P(X,Q)}$ as the best match.\n", + "\n", + "### Trivial matches\n", + "One should be careful of what is called \"trivial matches\" in this situation. If $Q$ is extracted from $X$, it is extremely likely that it will match with itself, as $dist(Q,Q)=0$. To avoid this, it is common to set the parts of the distance profile that are neighbors to $Q$ to $\\infty$. This is the role of the `q_index` parameter in the similarity search `predict` methods. The `exclusion_factor` parameter is used to define the neighbors of $Q$ that will also get $\\infty$ value.\n", + "\n", + "For example, if $Q$ was extracted at index $i$ in $X$ (i.e. $Q = \\{x_i, \\ldots, x_{i+(l-1)}\\}$), then all points in the interval `[i - l//exclusion_factor, i + l//exclusion_factor]` will the set to $\\infty$ in the distance profile to avoid a trivial match.\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (Spyder)", + "language": "python3", + "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.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/similarity_search/img/sim_search.png b/examples/similarity_search/img/sim_search.png new file mode 100644 index 0000000000..fe5fe146d3 Binary files /dev/null and b/examples/similarity_search/img/sim_search.png differ diff --git a/examples/similarity_search/similarity_search.ipynb b/examples/similarity_search/similarity_search.ipynb new file mode 100644 index 0000000000..79fc4e21ca --- /dev/null +++ b/examples/similarity_search/similarity_search.ipynb @@ -0,0 +1,252 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "5083d23c-e27f-4d14-a8d2-12e11a6aff42", + "metadata": {}, + "source": [ + "# Time Series Similarity search with aeon\n", + "\n", + "The goal of Time Series Similarity search is to asses the similarities between a time series, denoted as a query `q` of length `l`, and a collection of time series, denoted as `X`, which lengths are superior or equal to `l`. In this context, the notion of similiarity between `q` and the other series in `X` is quantified by similarity functions. Those functions are most of the time defined as distance function, such as the Euclidean distance. Knowing the similarity between `q` and other admissible candidates, we can then perform many other tasks for \"free\", such as anomaly or motif detection.\n", + "\n", + "\"time" + ] + }, + { + "cell_type": "markdown", + "id": "7e06b213-6038-4901-b98e-2433625115c4", + "metadata": {}, + "source": [ + "## Similarity search Notebooks\n", + "\n", + "This notebook gives an overview of similarity search module and the available estimators. The following notebooks are avaiable to go more in depth with specific subject of similarity search in aeon:\n", + "\n", + "- [Deep dive in the distance profiles](distance_profiles.ipynb)\n", + "- [Analysis of the speedups provided by similarity search module](code_speed.ipynb)" + ] + }, + { + "cell_type": "markdown", + "id": "ca967c08-9a05-411a-a09a-ad8a13c0adb9", + "metadata": {}, + "source": [ + "## Expected inputs and format\n" + ] + }, + { + "cell_type": "markdown", + "id": "d1fd75ae-84c2-40be-95f6-bd7de409317d", + "metadata": {}, + "source": [ + "## Available estimators\n", + "\n", + "All estimators of the similarity search module in aeon inherit from the `BaseSimilaritySearch` class, which requires the following arguments:\n", + "- `distance` : a string indicating which distance function to use as similarity function. By default this is `\"euclidean\"`, which means that the Euclidean distance is used.\n", + "- `normalize` : a boolean indicating whether this similarity function should be z-normalized. This means that the scale of the two series being compared will be ignored, and that, loosely speaking, we will only focus on their shape during the comparison. By default, this parameter is set `False`.\n", + "\n", + "Another parameter, which has no effect on the output of the estimators, is a boolean named `store_distance_profile`, set to `False` by default. If set to `True`, the estimators will expose an attribute named `_distance_profile` after the `predict` function is called. This attribute will contain the computed distance profile for query given as input to the `predict` function.\n", + "\n", + "To illustrate how to work with similarity search estimators in aeon, we will now present some example use cases." + ] + }, + { + "cell_type": "markdown", + "id": "01fa67c2-0126-4152-98a9-fa0df84c4629", + "metadata": {}, + "source": [ + "### Top-K similarity search" + ] + }, + { + "cell_type": "markdown", + "id": "8e99b251-d156-4989-b5a0-3a2c79cb75d4", + "metadata": {}, + "source": [ + "We will use the GunPoint dataset for this example, which can be loaded using the `load_classification` function." + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "f8a6bb7e-b219-41f1-b508-b849c45672eb", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "from matplotlib import pyplot as plt\n", + "\n", + "from aeon.datasets import load_classification\n", + "\n", + "# Load GunPoint dataset\n", + "X, y, _ = load_classification(\"GunPoint\")\n", + "\n", + "classes = np.unique(y)\n", + "\n", + "fig, ax = plt.subplots(figsize=(20, 5), ncols=len(classes))\n", + "for i_class, _class in enumerate(classes):\n", + " for i_x in np.where(y == _class)[0][0:2]:\n", + " ax[i_class].plot(X[i_x, 0], label=f\"sample {i_x}\")\n", + " ax[i_class].legend()\n", + " ax[i_class].set_title(f\"class {_class}\")\n", + "plt.suptitle(\"Example samples for the GunPoint dataset\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "5392f7f4-1825-4b15-9248-27eeecb1af3c", + "metadata": {}, + "source": [ + "The GunPoint dataset is composed of two classes which are discriminated by the \"bumps\" located before and after the central peak. These bumps correspond to an actor drawing a fake gun from a holster before pointing it (hence the name \"GunPoint\" !). In the second class, the actor simply points his fingers without making the motion of taking the gun out of the holster.\n", + "\n", + "Suppose that we define our input query for the similarity search task as one of these bumps:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "a494a0be-4459-414d-9fc2-1400feefd171", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "q = X[3, :, 20:55]\n", + "plt.plot(q[0])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "fcf10a34-930a-4fce-86f8-4dfa207cad11", + "metadata": {}, + "source": [ + "Then, we can use the `TopKSimilaritySearch` class to search for the top `k` matches of this query in a collection of series. The training data for `TopKSimilaritySearch` can be seen as the database in which want to search for the query on." + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "80eaab8f-204f-439f-84c8-ad3462f1575e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[(195, 26), (92, 23), (154, 22)]\n" + ] + } + ], + "source": [ + "from aeon.similarity_search import TopKSimilaritySearch\n", + "\n", + "# Here, the distance function (distance and normalize arguments)\n", + "top_k_search = TopKSimilaritySearch(k=3, distance=\"euclidean\")\n", + "\n", + "mask = np.ones(X.shape[0], dtype=bool)\n", + "mask[3] = False\n", + "# Use this mask to exluce the sample from which we extracted the query\n", + "X_train = X[mask]\n", + "# Call fit to store X_train as the database to search in\n", + "top_k_search.fit(X_train)\n", + "best_matches = top_k_search.predict(q)\n", + "print(best_matches)" + ] + }, + { + "cell_type": "markdown", + "id": "3dc402cf-80b7-4d0c-b07c-2f8e7822ac97", + "metadata": {}, + "source": [ + "The similarity search estimators return a list of size `k`, which contains a tuple containing the location of the best matches as `(id_sample, id_timestamp)`. We can then plot the results as:" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "23efe48e-8257-4ecc-93a2-d72f19024ab5", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(20, 5), ncols=3)\n", + "for i_k, (id_sample, id_timestamp) in enumerate(best_matches):\n", + " # plot the sample of the best match\n", + " ax[i_k].plot(top_k_search._X[id_sample, 0], linewidth=2)\n", + " # plot the location of the best match on it\n", + " ax[i_k].plot(\n", + " range(id_timestamp, id_timestamp + q.shape[1]),\n", + " top_k_search._X[id_sample, 0, id_timestamp : id_timestamp + q.shape[1]],\n", + " linewidth=7,\n", + " alpha=0.5,\n", + " color=\"green\",\n", + " label=\"best match location\",\n", + " )\n", + " # plot the query on the location of the best match\n", + " ax[i_k].plot(\n", + " range(id_timestamp, id_timestamp + q.shape[1]),\n", + " q[0],\n", + " linewidth=5,\n", + " alpha=0.5,\n", + " color=\"red\",\n", + " label=\"query\",\n", + " )\n", + " ax[i_k].set_title(f\"best match {i_k}\")\n", + " ax[i_k].legend()\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (Spyder)", + "language": "python3", + "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.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}