# STUMPY API¶

Overview

 stumpy.stump Compute the z-normalized matrix profile stumpy.stumped Compute the z-normalized matrix profile with a distributed dask cluster stumpy.gpu_stump Compute the z-normalized matrix profile with one or more GPU devices stumpy.mass Compute the distance profile using the MASS algorithm stumpy.scrump Compute an approximate z-normalized matrix profile stumpy.stumpi Compute an incremental z-normalized matrix profile for streaming data stumpy.mstump Compute the multi-dimensional z-normalized matrix profile stumpy.mstumped Compute the multi-dimensional z-normalized matrix profile with a distributed dask cluster stumpy.subspace Compute the k-dimensional matrix profile subspace for a given subsequence index and its nearest neighbor index stumpy.atsc Compute the anchored time series chain (ATSC) stumpy.allc Compute the all-chain set (ALLC) stumpy.fluss Compute the Fast Low-cost Unipotent Semantic Segmentation (FLUSS) for static data (i.e., batch processing) stumpy.floss Compute the Fast Low-cost Online Semantic Segmentation (FLOSS) for streaming data stumpy.ostinato Find the z-normalized consensus motif of multiple time series stumpy.ostinatoed Find the z-normalized consensus motif of multiple time series with a distributed dask cluster stumpy.gpu_ostinato Find the z-normalized consensus motif of multiple time series with one or more GPU devices stumpy.mpdist Compute the z-normalized matrix profile distance (MPdist) measure between any two time series stumpy.mpdisted Compute the z-normalized matrix profile distance (MPdist) measure between any two time series with a distributed dask cluster stumpy.gpu_mpdist Compute the z-normalized matrix profile distance (MPdist) measure between any two time series with one or more GPU devices stumpy.motifs Discover the top motifs for time series T stumpy.match Find all matches of a query Q in a time series T stumpy.snippets Identify the top k snippets that best represent the time series, T stumpy.stimp Compute the Pan Matrix Profile stumpy.stimped Compute the Pan Matrix Profile with a distributed dask cluster stumpy.gpu_stimp Compute the Pan Matrix Profile with with one or more GPU devices

## stump¶

stumpy.stump(T_A, m, T_B=None, ignore_trivial=True, normalize=True)[source]

Compute the z-normalized matrix profile

This is a convenience wrapper around the Numba JIT-compiled parallelized _stump function which computes the matrix profile according to STOMPopt with Pearson correlations.

Parameters
• T_A (numpy.ndarray) – The time series or sequence for which to compute the matrix profile

• m (int) – Window size

• T_B (numpy.ndarray, default None) – The time series or sequence that will be used to annotate T_A. For every subsequence in T_A, its nearest neighbor in T_B will be recorded. Default is None which corresponds to a self-join.

• ignore_trivial (bool, default True) – Set to True if this is a self-join. Otherwise, for AB-join, set this to False. Default is True.

• normalize (bool, default True) – When set to True, this z-normalizes subsequences prior to computing distances. Otherwise, this function gets re-routed to its complementary non-normalized equivalent set in the @core.non_normalized function decorator.

Returns

out – The first column consists of the matrix profile, the second column consists of the matrix profile indices, the third column consists of the left matrix profile indices, and the fourth column consists of the right matrix profile indices.

Return type

numpy.ndarray

stumpy.stumped()

Compute the z-normalized matrix profile with a distributed dask cluster

stumpy.gpu_stump()

Compute the z-normalized matrix profile with one or more GPU devices

stumpy.scrump()

Compute an approximate z-normalized matrix profile

Notes

DOI: 10.1007/s10115-017-1138-x

See Section 4.5

The above reference outlines a general approach for traversing the distance matrix in a diagonal fashion rather than in a row-wise fashion.

DOI: 10.1145/3357223.3362721

See Section 3.1 and Section 3.3

The above reference outlines the use of the Pearson correlation via Welford’s centered sum-of-products along each diagonal of the distance matrix in place of the sliding window dot product found in the original STOMP method.

DOI: 10.1109/ICDM.2016.0085

See Table II

Timeseries, T_A, will be annotated with the distance location (or index) of all its subsequences in another times series, T_B.

Return: For every subsequence, Q, in T_A, you will get a distance and index for the closest subsequence in T_B. Thus, the array returned will have length T_A.shape[0]-m+1. Additionally, the left and right matrix profiles are also returned.

Note: Unlike in the Table II where T_A.shape is expected to be equal to T_B.shape, this implementation is generalized so that the shapes of T_A and T_B can be different. In the case where T_A.shape == T_B.shape, then our algorithm reduces down to the same algorithm found in Table II.

Additionally, unlike STAMP where the exclusion zone is m/2, the default exclusion zone for STOMP is m/4 (See Definition 3 and Figure 3).

For self-joins, set ignore_trivial = True in order to avoid the trivial match.

Note that left and right matrix profiles are only available for self-joins.

Examples

>>> import stumpy
>>> stumpy.stump(np.array([584., -11., 23., 79., 1001., 0., -19.]), m=3)
array([[0.11633857113691416, 4, -1, 4],
[2.694073918063438, 3, -1, 3],
[3.0000926340485923, 0, 0, 4],
[2.694073918063438, 1, 1, -1],
[0.11633857113691416, 0, 0, -1]], dtype=object)

## stumped¶

stumpy.stumped(dask_client, T_A, m, T_B=None, ignore_trivial=True, normalize=True)[source]

Compute the z-normalized matrix profile with a distributed dask cluster

This is a highly distributed implementation around the Numba JIT-compiled parallelized _stump function which computes the matrix profile according to STOMPopt with Pearson correlations.

Parameters

• T_A (numpy.ndarray) – The time series or sequence for which to compute the matrix profile

• m (int) – Window size

• T_B (numpy.ndarray, default None) – The time series or sequence that will be used to annotate T_A. For every subsequence in T_A, its nearest neighbor in T_B will be recorded. Default is None which corresponds to a self-join.

• ignore_trivial (bool, default True) – Set to True if this is a self-join. Otherwise, for AB-join, set this to False. Default is True.

• normalize (bool, default True) – When set to True, this z-normalizes subsequences prior to computing distances. Otherwise, this function gets re-routed to its complementary non-normalized equivalent set in the @core.non_normalized function decorator.

Returns

out – The first column consists of the matrix profile, the second column consists of the matrix profile indices, the third column consists of the left matrix profile indices, and the fourth column consists of the right matrix profile indices.

Return type

numpy.ndarray

stumpy.stump()

Compute the z-normalized matrix profile cluster

stumpy.gpu_stump()

Compute the z-normalized matrix profile with one or more GPU devices

stumpy.scrump()

Compute an approximate z-normalized matrix profile

Notes

DOI: 10.1007/s10115-017-1138-x

See Section 4.5

The above reference outlines a general approach for traversing the distance matrix in a diagonal fashion rather than in a row-wise fashion.

DOI: 10.1145/3357223.3362721

See Section 3.1 and Section 3.3

The above reference outlines the use of the Pearson correlation via Welford’s centered sum-of-products along each diagonal of the distance matrix in place of the sliding window dot product found in the original STOMP method.

DOI: 10.1109/ICDM.2016.0085

See Table II

This is a Dask distributed implementation of stump that scales across multiple servers and is a convenience wrapper around the parallelized stump._stump function

Timeseries, T_A, will be annotated with the distance location (or index) of all its subsequences in another times series, T_B.

Return: For every subsequence, Q, in T_A, you will get a distance and index for the closest subsequence in T_B. Thus, the array returned will have length T_A.shape[0]-m+1. Additionally, the left and right matrix profiles are also returned.

Note: Unlike in the Table II where T_A.shape is expected to be equal to T_B.shape, this implementation is generalized so that the shapes of T_A and T_B can be different. In the case where T_A.shape == T_B.shape, then our algorithm reduces down to the same algorithm found in Table II.

Additionally, unlike STAMP where the exclusion zone is m/2, the default exclusion zone for STOMP is m/4 (See Definition 3 and Figure 3).

For self-joins, set ignore_trivial = True in order to avoid the trivial match.

Note that left and right matrix profiles are only available for self-joins.

Examples

>>> if __name__ == "__main__":
...     stumpy.stumped(
...         np.array([584., -11., 23., 79., 1001., 0., -19.]),
...         m=3)
array([[0.11633857113691416, 4, -1, 4],
[2.694073918063438, 3, -1, 3],
[3.0000926340485923, 0, 0, 4],
[2.694073918063438, 1, 1, -1],
[0.11633857113691416, 0, 0, -1]], dtype=object)

## gpu_stump¶

stumpy.gpu_stump(T_A, m, T_B=None, ignore_trivial=True, device_id=0, normalize=True)

Compute the z-normalized matrix profile with one or more GPU devices

This is a convenience wrapper around the Numba cuda.jit _gpu_stump function which computes the matrix profile according to GPU-STOMP.

Parameters
• T_A (numpy.ndarray) – The time series or sequence for which to compute the matrix profile

• m (int) – Window size

• T_B (numpy.ndarray, default None) – The time series or sequence that will be used to annotate T_A. For every subsequence in T_A, its nearest neighbor in T_B will be recorded. Default is None which corresponds to a self-join.

• ignore_trivial (bool, default True) – Set to True if this is a self-join. Otherwise, for AB-join, set this to False. Default is True.

• device_id (int or list, default 0) – The (GPU) device number to use. The default value is 0. A list of valid device ids (int) may also be provided for parallel GPU-STUMP computation. A list of all valid device ids can be obtained by executing [device.id for device in numba.cuda.list_devices()].

• normalize (bool, default True) – When set to True, this z-normalizes subsequences prior to computing distances. Otherwise, this function gets re-routed to its complementary non-normalized equivalent set in the @core.non_normalized function decorator.

Returns

out – The first column consists of the matrix profile, the second column consists of the matrix profile indices, the third column consists of the left matrix profile indices, and the fourth column consists of the right matrix profile indices.

Return type

numpy.ndarray

stumpy.stump()

Compute the z-normalized matrix profile

stumpy.stumped()

Compute the z-normalized matrix profile with a distributed dask cluster

stumpy.scrump()

Compute an approximate z-normalized matrix profile

Notes

DOI: 10.1109/ICDM.2016.0085

See Table II, Figure 5, and Figure 6

Timeseries, T_A, will be annotated with the distance location (or index) of all its subsequences in another times series, T_B.

Return: For every subsequence, Q, in T_A, you will get a distance and index for the closest subsequence in T_B. Thus, the array returned will have length T_A.shape[0]-m+1. Additionally, the left and right matrix profiles are also returned.

Note: Unlike in the Table II where T_A.shape is expected to be equal to T_B.shape, this implementation is generalized so that the shapes of T_A and T_B can be different. In the case where T_A.shape == T_B.shape, then our algorithm reduces down to the same algorithm found in Table II.

Additionally, unlike STAMP where the exclusion zone is m/2, the default exclusion zone for STOMP is m/4 (See Definition 3 and Figure 3).

For self-joins, set ignore_trivial = True in order to avoid the trivial match.

Note that left and right matrix profiles are only available for self-joins.

Examples

>>> from numba import cuda
>>> if __name__ == "__main__":
...     all_gpu_devices = [device.id for device in cuda.list_devices()]
...     stumpy.gpu_stump(
...         np.array([584., -11., 23., 79., 1001., 0., -19.]),
...         m=3,
...         device_id=all_gpu_devices)
array([[0.11633857113691416, 4, -1, 4],
[2.694073918063438, 3, -1, 3],
[3.0000926340485923, 0, 0, 4],
[2.694073918063438, 1, 1, -1],
[0.11633857113691416, 0, 0, -1]], dtype=object)

## mass¶

stumpy.mass(Q, T, M_T=None, Σ_T=None, normalize=True)[source]

Compute the distance profile using the MASS algorithm

This is a convenience wrapper around the Numba JIT compiled _mass function.

Parameters
• Q (numpy.ndarray) – Query array or subsequence

• T (numpy.ndarray) – Time series or sequence

• M_T (numpy.ndarray, default None) – Sliding mean of T

• Σ_T (numpy.ndarray, default None) – Sliding standard deviation of T

• normalize (bool, default True) – When set to True, this z-normalizes subsequences prior to computing distances. Otherwise, this function gets re-routed to its complementary non-normalized equivalent set in the @core.non_normalized function decorator.

Returns

distance_profile – Distance profile

Return type

numpy.ndarray

stumpy.motifs()

Discover the top motifs for time series T

stumpy.match()

Find all matches of a query Q in a time series T

Notes

DOI: 10.1109/ICDM.2016.0179

See Table II

Note that Q, T are not directly required to calculate D

Note: Unlike the Matrix Profile I paper, here, M_T, Σ_T can be calculated once for all subsequences of T and passed in so the redundancy is removed

Examples

>>> stumpy.mass(
...     np.array([-11.1, 23.4, 79.5, 1001.0]),
...     np.array([584., -11., 23., 79., 1001., 0., -19.]))
array([3.18792463e+00, 1.11297393e-03, 3.23874018e+00, 3.34470195e+00])

## scrump¶

stumpy.scrump(T_A, m, T_B=None, ignore_trivial=True, percentage=0.01, pre_scrump=False, s=None, normalize=True)[source]

Compute an approximate z-normalized matrix profile

This is a convenience wrapper around the Numba JIT-compiled parallelized _stump function which computes the matrix profile according to SCRIMP.

Parameters
• T_A (numpy.ndarray) – The time series or sequence for which to compute the matrix profile

• T_B (numpy.ndarray) – The time series or sequence that will be used to annotate T_A. For every subsequence in T_A, its nearest neighbor in T_B will be recorded.

• m (int) – Window size

• ignore_trivial (bool) – Set to True if this is a self-join. Otherwise, for AB-join, set this to False. Default is True.

• percentage (float) – Approximate percentage completed. The value is between 0.0 and 1.0.

• pre_scrump (bool) – A flag for whether or not to perform the PreSCRIMP calculation prior to computing SCRIMP. If set to True, this is equivalent to computing SCRIMP++ and may lead to faster convergence

• s (int) – The size of the PreSCRIMP fixed interval. If pre_scrump=True and s=None, then s will automatically be set to s=int(np.ceil(m / config.STUMPY_EXCL_ZONE_DENOM)), the size of the exclusion zone.

• normalize (bool, default True) – When set to True, this z-normalizes subsequences prior to computing distances. Otherwise, this class gets re-routed to its complementary non-normalized equivalent set in the @core.non_normalized class decorator.

stumpy.P_

The updated matrix profile

Type

numpy.ndarray

stumpy.I_

The updated matrix profile indices

Type

numpy.ndarray

stumpy.update()

Update the matrix profile and the matrix profile indices by computing additional new distances (limited by percentage) that make up the full distance matrix.

stumpy.stump()

Compute the z-normalized matrix profile

stumpy.stumped()

Compute the z-normalized matrix profile with a distributed dask cluster

stumpy.gpu_stump()

Compute the z-normalized matrix profile with one or more GPU devices

Notes

DOI: 10.1109/ICDM.2018.00099

See Algorithm 1 and Algorithm 2

Examples

>>> approx_mp = stumpy.scrump(
...     np.array([584., -11., 23., 79., 1001., 0., -19.]),
...     m=3)
>>> approx_mp.update()
>>> approx_mp._P
array([[2.982409  ,        inf, 2.982409  ],
[3.28412702,        inf, 3.28412702],
[       inf,        inf,        inf],
[2.982409  , 2.982409  ,        inf],
[3.28412702, 3.28412702,        inf]])
>>> approx_mp._I
array([[ 3, -1,  3],
[ 4, -1,  4],
[-1, -1, -1],
[ 0,  0, -1],
[ 1,  1, -1]])

## stumpi¶

stumpy.stumpi(T, m, egress=True, normalize=True)[source]

Compute an incremental z-normalized matrix profile for streaming data

This is based on the on-line STOMPI and STAMPI algorithms.

Parameters
• T (numpy.ndarray) – The time series or sequence for which the matrix profile and matrix profile indices will be returned

• m (int) – Window size

• egress (bool, default True) – If set to True, the oldest data point in the time series is removed and the time series length remains constant rather than forever increasing

• normalize (bool, default True) – When set to True, this z-normalizes subsequences prior to computing distances. Otherwise, this class gets re-routed to its complementary non-normalized equivalent set in the @core.non_normalized class decorator.

stumpy.P_

The updated matrix profile for T

Type

numpy.ndarray

stumpy.I_

The updated matrix profile indices for T

Type

numpy.ndarray

stumpy.left_P_

The updated left matrix profile for T

Type

numpy.ndarray

stumpy.left_I_

The updated left matrix profile indices for T

Type

numpy.ndarray

stumpy.T_

The updated time series or sequence for which the matrix profile and matrix profile indices are computed

Type

numpy.ndarray

stumpy.update(t)

Append a single new data point, t, to the time series, T, and update the matrix profile

Notes

DOI: 10.1007/s10618-017-0519-9

See Table V

Note that line 11 is missing an important sqrt operation!

Examples

>>> stream = stumpy.stumpi(
...     np.array([584., -11., 23., 79., 1001., 0.]),
...     m=3)
>>> stream.update(-19.0)
>>> stream.left_P_
array([       inf, 3.00009263, 2.69407392, 3.05656417])
>>> stream.left_I_
array([-1,  0,  1,  2])

## mstump¶

stumpy.mstump(T, m, include=None, discords=False, normalize=True)[source]

Compute the multi-dimensional z-normalized matrix profile

This is a convenience wrapper around the Numba JIT-compiled parallelized _mstump function which computes the multi-dimensional matrix profile and multi-dimensional matrix profile index according to mSTOMP, a variant of mSTAMP. Note that only self-joins are supported.

Parameters
• T (numpy.ndarray) – The time series or sequence for which to compute the multi-dimensional matrix profile. Each row in T represents data from a different dimension while each column in T represents data from the same dimension.

• m (int) – Window size

• include (list, numpy.ndarray, default None) –

A list of (zero-based) indices corresponding to the dimensions in T that must be included in the constrained multidimensional motif search. For more information, see Section IV D in:

DOI: 10.1109/ICDM.2017.66

• discords (bool, default False) – When set to True, this reverses the distance matrix which results in a multi-dimensional matrix profile that favors larger matrix profile values (i.e., discords) rather than smaller values (i.e., motifs). Note that indices in include are still maintained and respected.

• normalize (bool, default True) – When set to True, this z-normalizes subsequences prior to computing distances. Otherwise, this function gets re-routed to its complementary non-normalized equivalent set in the @core.non_normalized function decorator.

Returns

• P (numpy.ndarray) – The multi-dimensional matrix profile. Each row of the array corresponds to each matrix profile for a given dimension (i.e., the first row is the 1-D matrix profile and the second row is the 2-D matrix profile).

• I (numpy.ndarray) – The multi-dimensional matrix profile index where each row of the array corresponds to each matrix profile index for a given dimension.

stumpy.mstumped()

Compute the multi-dimensional z-normalized matrix profile with a distributed dask cluster

stumpy.subspace()

Compute the k-dimensional matrix profile subspace for a given subsequence index and its nearest neighbor index

Notes

DOI: 10.1109/ICDM.2017.66

See mSTAMP Algorithm

Examples

>>> stumpy.mstump(
...     np.array([[584., -11., 23., 79., 1001., 0., -19.],
...               [  1.,   2.,  4.,  8.,   16., 0.,  32.]]),
...     m=3)
(array([[0.        , 1.43947142, 0.        , 2.69407392, 0.11633857],
[0.777905  , 2.36179922, 1.50004632, 2.92246722, 0.777905  ]]),
array([[2, 4, 0, 1, 0],
[4, 4, 0, 1, 0]]))

## mstumped¶

stumpy.mstumped(dask_client, T, m, include=None, discords=False, normalize=True)[source]

Compute the multi-dimensional z-normalized matrix profile with a distributed dask cluster

This is a highly distributed implementation around the Numba JIT-compiled parallelized _mstump function which computes the multi-dimensional matrix profile according to STOMP. Note that only self-joins are supported.

Parameters

• T (numpy.ndarray) – The time series or sequence for which to compute the multi-dimensional matrix profile. Each row in T represents data from a different dimension while each column in T represents data from the same dimension.

• m (int) – Window size

• include (list, numpy.ndarray, default None) –

A list of (zero-based) indices corresponding to the dimensions in T that must be included in the constrained multidimensional motif search. For more information, see Section IV D in:

DOI: 10.1109/ICDM.2017.66

• discords (bool, default False) – When set to True, this reverses the distance matrix which results in a multi-dimensional matrix profile that favors larger matrix profile values (i.e., discords) rather than smaller values (i.e., motifs). Note that indices in include are still maintained and respected.

• normalize (bool, default True) – When set to True, this z-normalizes subsequences prior to computing distances. Otherwise, this function gets re-routed to its complementary non-normalized equivalent set in the @core.non_normalized function decorator.

Returns

• P (numpy.ndarray) – The multi-dimensional matrix profile. Each row of the array corresponds to each matrix profile for a given dimension (i.e., the first row is the 1-D matrix profile and the second row is the 2-D matrix profile).

• I (numpy.ndarray) – The multi-dimensional matrix profile index where each row of the array corresponds to each matrix profile index for a given dimension.

stumpy.mstump()

Compute the multi-dimensional z-normalized matrix profile

stumpy.subspace()

Compute the k-dimensional matrix profile subspace for a given subsequence index and its nearest neighbor index

Notes

DOI: 10.1109/ICDM.2017.66

See mSTAMP Algorithm

Examples

>>> if __name__ == "__main__":
...     stumpy.mstumped(
...         np.array([[584., -11., 23., 79., 1001., 0., -19.],
...                   [  1.,   2.,  4.,  8.,   16., 0.,  32.]]),
...         m=3)
(array([[0.        , 1.43947142, 0.        , 2.69407392, 0.11633857],
[0.777905  , 2.36179922, 1.50004632, 2.92246722, 0.777905  ]]),
array([[2, 4, 0, 1, 0],
[4, 4, 0, 1, 0]]))

## subspace¶

stumpy.subspace(T, m, subseq_idx, nn_idx, k, include=None, discords=False, normalize=True)[source]

Compute the k-dimensional matrix profile subspace for a given subsequence index and its nearest neighbor index

Parameters
• T (numpy.ndarray) – The time series or sequence for which the multi-dimensional matrix profile, multi-dimensional matrix profile indices were computed

• m (int) – Window size

• subseq_idx (int) – The subsequence index in T

• nn_idx (int) – The nearest neighbor index in T

• k (int) – The subset number of dimensions out of D = T.shape[0]-dimensions to return the subspace for

• include (numpy.ndarray, default None) –

A list of (zero-based) indices corresponding to the dimensions in T that must be included in the constrained multidimensional motif search. For more information, see Section IV D in:

DOI: 10.1109/ICDM.2017.66

• discords (bool, default False) – When set to True, this reverses the distance profile to favor discords rather than motifs. Note that indices in include are still maintained and respected.

• normalize (bool, default True) – When set to True, this z-normalizes subsequences prior to computing distances. Otherwise, this function gets re-routed to its complementary non-normalized equivalent set in the @core.non_normalized function decorator.

Returns

• S (numpy.ndarray)

• An array of that contains the kth-dimensional subspace for the subsequence

• with index equal to motif_idx

stumpy.mstump()

Compute the multi-dimensional z-normalized matrix profile

stumpy.mstumped()

Compute the multi-dimensional z-normalized matrix profile with a distributed dask cluster

Examples

>>> mps, indices = stumpy.mstump(
...     np.array([[584., -11., 23., 79., 1001., 0., -19.],
...               [  1.,   2.,  4.,  8.,   16., 0.,  32.]]),
...     m=3)
>>> motifs_idx = np.argsort(mps, axis=1)[:, :2]
>>> stumpy.subspace(
...     np.array([[584., -11., 23., 79., 1001., 0., -19.],
...               [  1.,   2.,  4.,  8.,   16., 0.,  32.]],
...     m=3,
...     subseq_idx=motifs_idx[k][0],
...     nn_idx=indices[k][motifs_idx[k][0]],
...     k=1)
array([0, 1])

## atsc¶

stumpy.atsc(IL, IR, j)[source]

Compute the anchored time series chain (ATSC)

Note that since the matrix profile indices, IL and IR, are pre-computed, this function is agnostic to subsequence normalization.

Parameters
• IL (numpy.ndarray) – Left matrix profile indices

• IR (numpy.ndarray) – Right matrix profile indices

• j (int) – The index value for which to compute the ATSC

Returns

out – Anchored time series chain for index, j

Return type

numpy.ndarray

stumpy.allc()

Compute the all-chain set (ALLC)

Notes

DOI: 10.1109/ICDM.2017.79

See Table I

This is the implementation for the anchored time series chains (ATSC).

Unlike the original paper, we’ve replaced the while-loop with a more stable for-loop.

Examples

>>> mp = stumpy.stump(np.array([584., -11., 23., 79., 1001., 0., -19.]), m=3)
>>> stumpy.atsc(mp[:, 2], mp[:, 3], 1)
array([1, 3])

## allc¶

stumpy.allc(IL, IR)[source]

Compute the all-chain set (ALLC)

Note that since the matrix profile indices, IL and IR, are pre-computed, this function is agnostic to subsequence normalization.

Parameters
• IL (numpy.ndarray) – Left matrix profile indices

• IR (numpy.ndarray) – Right matrix profile indices

Returns

• S (list(numpy.ndarray)) – All-chain set

• C (numpy.ndarray) – Anchored time series chain for the longest chain (also known as the unanchored chain)

stumpy.atsc()

Compute the anchored time series chain (ATSC)

Notes

DOI: 10.1109/ICDM.2017.79

See Table II

Unlike the original paper, we’ve replaced the while-loop with a more stable for-loop.

This is the implementation for the all-chain set (ALLC) and the unanchored chain is simply the longest one among the all-chain set. Both the all-chain set and unanchored chain are returned.

The all-chain set, S, is returned as a list of unique numpy arrays.

Examples

>>> mp = stumpy.stump(np.array([584., -11., 23., 79., 1001., 0., -19.]), m=3)
>>> stumpy.allc(mp[:, 2], mp[:, 3])
([array([1, 3]), array([2]), array([0, 4])], array([0, 4]))

## fluss¶

stumpy.fluss(I, L, n_regimes, excl_factor=5, custom_iac=None)[source]

Compute the Fast Low-cost Unipotent Semantic Segmentation (FLUSS) for static data (i.e., batch processing)

Essentially, this is a wrapper to compute the corrected arc curve and regime locations. Note that since the matrix profile indices, I, are pre-computed, this function is agnostic to subsequence normalization.

Parameters
• I (numpy.ndarray) – The matrix profile indices for the time series of interest

• L (int) – The subsequence length that is set roughly to be one period length. This is likely to be the same value as the window size, m, used to compute the matrix profile and matrix profile index but it can be different since this is only used to manage edge effects and has no bearing on any of the IAC or CAC core calculations.

• n_regimes (int) – The number of regimes to search for. This is one more than the number of regime changes as denoted in the original paper.

• excl_factor (int, default 5) – The multiplying factor for the regime exclusion zone

• custom_iac (numpy.ndarray, default None) – A custom idealized arc curve (IAC) that will used for correcting the arc curve

Returns

• cac (numpy.ndarray) – A corrected arc curve (CAC)

• regime_locs (numpy.ndarray) – The locations of the regimes

stumpy.floss()

Compute the Fast Low-Cost Online Semantic Segmentation (FLOSS) for streaming data

Notes

DOI: 10.1109/ICDM.2017.21

See Section A

This is the implementation for Fast Low-cost Unipotent Semantic Segmentation (FLUSS).

Examples

>>> mp = stumpy.stump(np.array([584., -11., 23., 79., 1001., 0., -19.]), m=3)
>>> stumpy.fluss(mp[:, 0], 3, 2)
(array([1., 1., 1., 1., 1.]), array([0]))

## floss¶

stumpy.floss(mp, T, m, L, excl_factor=5, n_iter=1000, n_samples=1000, custom_iac=None, normalize=True)[source]

Compute the Fast Low-cost Online Semantic Segmentation (FLOSS) for streaming data

Parameters
• mp (numpy.ndarray) – The first column consists of the matrix profile, the second column consists of the matrix profile indices, the third column consists of the left matrix profile indices, and the fourth column consists of the right matrix profile indices.

• T (numpy.ndarray) – A 1-D time series data used to generate the matrix profile and matrix profile indices found in mp. Note that the the right matrix profile index is used and the right matrix profile is intelligently recomputed on the fly from T instead of using the bidirectional matrix profile.

• m (int) – The window size for computing sliding window mass. This is identical to the window size used in the matrix profile calculation. For managing edge effects, see the L parameter.

• L (int) – The subsequence length that is set roughly to be one period length. This is likely to be the same value as the window size, m, used to compute the matrix profile and matrix profile index but it can be different since this is only used to manage edge effects and has no bearing on any of the IAC or CAC core calculations.

• excl_factor (int, default 5) – The multiplying factor for the regime exclusion zone. Note that this is unrelated to the excl_zone used in to compute the matrix profile.

• n_iter (int, default 1000) – Number of iterations to average over when determining the parameters for the IAC beta distribution

• n_samples (int, default 1000) – Number of distribution samples to draw during each iteration when computing the IAC

• custom_iac (numpy.ndarray, default None) – A custom idealized arc curve (IAC) that will used for correcting the arc curve

• normalize (bool, default True) – When set to True, this z-normalizes subsequences prior to computing distances

stumpy.cac_1d_

A 1-dimensional corrected arc curve (CAC) updated as a result of ingressing a single new data point and egressing a single old data point.

Type

numpy.ndarray

stumpy.P_

The matrix profile updated as a result of ingressing a single new data point and egressing a single old data point.

Type

numpy.ndarray

stumpy.I_

The (right) matrix profile indices updated as a result of ingressing a single new data point and egressing a single old data point.

Type

numpy.ndarray

stumpy.T_

The updated time series, T

Type

numpy.ndarray

stumpy.update(t)

Ingress a new data point, t, onto the time series, T, followed by egressing the oldest single data point from T. Then, update the 1-dimensional corrected arc curve (CAC_1D) and the matrix profile.

stumpy.fluss()

Compute the Fast Low-cost Unipotent Semantic Segmentation (FLUSS) for static data (i.e., batch processing)

Notes

DOI: 10.1109/ICDM.2017.21 <https://www.cs.ucr.edu/~eamonn/Segmentation_ICDM.pdf>__

See Section C

This is the implementation for Fast Low-cost Online Semantic Segmentation (FLOSS).

Examples

>>> mp = stumpy.stump(np.array([584., -11., 23., 79., 1001., 0.]), m=3)
>>> stream = stumpy.floss(
...     mp,
...     np.array([584., -11., 23., 79., 1001., 0.]),
...     m=3,
...     L=3)
>>> stream.update(19.)
>>> stream.cac_1d_
array([1., 1., 1., 1.])

## ostinato¶

stumpy.ostinato(Ts, m, normalize=True)[source]

Find the z-normalized consensus motif of multiple time series

This is a wrapper around the vanilla version of the ostinato algorithm which finds the best radius and a helper function that finds the most central conserved motif.

Parameters
• Ts (list) – A list of time series for which to find the most central consensus motif

• m (int) – Window size

• normalize (bool, default True) – When set to True, this z-normalizes subsequences prior to computing distances. Otherwise, this function gets re-routed to its complementary non-normalized equivalent set in the @core.non_normalized function decorator.

Returns

• central_Ts_idx (int) – The time series index in Ts which contains the most central consensus motif

• central_subseq_idx (int) – The subsequence index within time series Ts[central_motif_Ts_idx] the contains most central consensus motif

stumpy.ostinatoed()

Find the z-normalized consensus motif of multiple time series with a distributed dask cluster

stumpy.gpu_ostinato()

Find the z-normalized consensus motif of multiple time series with one or more GPU devices

Notes

DOI: 10.1109/ICDM.2019.00140

See Table 2

The ostinato algorithm proposed in the paper finds the best radius in Ts. Intuitively, the radius is the minimum distance of a subsequence to encompass at least one nearest neighbor subsequence from all other time series. The best radius in Ts is the minimum radius amongst all radii. Some data sets might contain multiple subsequences which have the same optimal radius. The greedy Ostinato algorithm only finds one of them, which might not be the most central motif. The most central motif amongst the subsequences with the best radius is the one with the smallest mean distance to nearest neighbors in all other time series. To find this central motif it is necessary to search the subsequences with the best radius via stumpy.ostinato._get_central_motif

Examples

>>> stumpy.ostinato(
...     [np.array([584., -11., 23., 79., 1001., 0., 19.]),
...      np.array([600., -10., 23., 17.]),
...      np.array([  1.,   9.,  6.,  0.])],
...     m=3)
(1.2370237678153826, 0, 4)

## ostinatoed¶

Find the z-normalized consensus motif of multiple time series with a distributed dask cluster

This is a wrapper around the vanilla version of the ostinato algorithm which finds the best radius and a helper function that finds the most central conserved motif.

Parameters

• Ts (list) – A list of time series for which to find the most central consensus motif

• m (int) – Window size

• normalize (bool, default True) – When set to True, this z-normalizes subsequences prior to computing distances. Otherwise, this function gets re-routed to its complementary non-normalized equivalent set in the @core.non_normalized function decorator.

Returns

• central_Ts_idx (int) – The time series index in Ts which contains the most central consensus motif

• central_subseq_idx (int) – The subsequence index within time series Ts[central_motif_Ts_idx] the contains most central consensus motif

stumpy.ostinato()

Find the z-normalized consensus motif of multiple time series

stumpy.gpu_ostinato()

Find the z-normalized consensus motif of multiple time series with one or more GPU devices

Notes

DOI: 10.1109/ICDM.2019.00140

See Table 2

The ostinato algorithm proposed in the paper finds the best radius in Ts. Intuitively, the radius is the minimum distance of a subsequence to encompass at least one nearest neighbor subsequence from all other time series. The best radius in Ts is the minimum radius amongst all radii. Some data sets might contain multiple subsequences which have the same optimal radius. The greedy Ostinato algorithm only finds one of them, which might not be the most central motif. The most central motif amongst the subsequences with the best radius is the one with the smallest mean distance to nearest neighbors in all other time series. To find this central motif it is necessary to search the subsequences with the best radius via stumpy.ostinato._get_central_motif

>>> if __name__ == "__main__":
...     stumpy.ostinatoed(
...         [np.array([584., -11., 23., 79., 1001., 0., 19.]),
...          np.array([600., -10., 23., 17.]),
...          np.array([  1.,   9.,  6.,  0.])],
...         m=3)
(1.2370237678153826, 0, 4)

## gpu_ostinato¶

stumpy.gpu_ostinato(Ts, m, device_id=0, normalize=True)

Find the z-normalized consensus motif of multiple time series with one or more GPU devices

This is a wrapper around the vanilla version of the ostinato algorithm which finds the best radius and a helper function that finds the most central conserved motif.

Parameters
• Ts (list) – A list of time series for which to find the most central consensus motif

• m (int) – Window size

• device_id (int or list, default 0) – The (GPU) device number to use. The default value is 0. A list of valid device ids (int) may also be provided for parallel GPU-STUMP computation. A list of all valid device ids can be obtained by executing [device.id for device in numba.cuda.list_devices()].

• normalize (bool, default True) – When set to True, this z-normalizes subsequences prior to computing distances. Otherwise, this function gets re-routed to its complementary non-normalized equivalent set in the @core.non_normalized function decorator.

Returns

• central_Ts_idx (int) – The time series index in Ts which contains the most central consensus motif

• central_subseq_idx (int) – The subsequence index within time series Ts[central_motif_Ts_idx] the contains most central consensus motif

stumpy.ostinato()

Find the z-normalized consensus motif of multiple time series

stumpy.ostinatoed()

Find the z-normalized consensus motif of multiple time series with a distributed dask cluster

Notes

DOI: 10.1109/ICDM.2019.00140

See Table 2

The ostinato algorithm proposed in the paper finds the best radius in Ts. Intuitively, the radius is the minimum distance of a subsequence to encompass at least one nearest neighbor subsequence from all other time series. The best radius in Ts is the minimum radius amongst all radii. Some data sets might contain multiple subsequences which have the same optimal radius. The greedy Ostinato algorithm only finds one of them, which might not be the most central motif. The most central motif amongst the subsequences with the best radius is the one with the smallest mean distance to nearest neighbors in all other time series. To find this central motif it is necessary to search the subsequences with the best radius via stumpy.ostinato._get_central_motif

Examples

>>> from numba import cuda
>>> if __name__ == "__main__":
...     all_gpu_devices = [device.id for device in cuda.list_devices()]
...     stumpy.gpu_ostinatoe(
...         [np.array([584., -11., 23., 79., 1001., 0., 19.]),
...          np.array([600., -10., 23., 17.]),
...          np.array([  1.,   9.,  6.,  0.])],
...         m=3,
...         device_id=all_gpu_devices)
(1.2370237678153826, 0, 4)

## mpdist¶

stumpy.mpdist(T_A, T_B, m, percentage=0.05, k=None, normalize=True)[source]

Compute the z-normalized matrix profile distance (MPdist) measure between any two time series

The MPdist distance measure considers two time series to be similar if they share many subsequences, regardless of the order of matching subsequences. MPdist concatenates the output of an AB-join and a BA-join and returns the kth smallest value as the reported distance. Note that MPdist is a measure and not a metric. Therefore, it does not obey the triangular inequality but the method is highly scalable.

Parameters
• T_A (numpy.ndarray) – The first time series or sequence for which to compute the matrix profile

• T_B (numpy.ndarray) – The second time series or sequence for which to compute the matrix profile

• m (int) – Window size

• percentage (float, default 0.05) – The percentage of distances that will be used to report mpdist. The value is between 0.0 and 1.0.

• k (int) – Specify the kth value in the concatenated matrix profiles to return. When k is not None, then the percentage parameter is ignored.

• normalize (bool, default True) – When set to True, this z-normalizes subsequences prior to computing distances. Otherwise, this function gets re-routed to its complementary non-normalized equivalent set in the @core.non_normalized function decorator.

Returns

MPdist – The matrix profile distance

Return type

float

mpdisted()

Compute the z-normalized matrix profile distance (MPdist) measure between any two time series with a distributed dask cluster

gpu_mpdisted()

Compute the z-normalized matrix profile distance (MPdist) measure between any two time series with one or more GPU devices

Notes

DOI: 10.1109/ICDM.2018.00119

See Section III

Examples

>>> stumpy.mpdist(
...     np.array([-11.1, 23.4, 79.5, 1001.0]),
...     np.array([584., -11., 23., 79., 1001., 0., -19.]),
...     m=3)
0.00019935236191097894

## mpdisted¶

stumpy.mpdisted(dask_client, T_A, T_B, m, percentage=0.05, k=None, normalize=True)[source]

Compute the z-normalized matrix profile distance (MPdist) measure between any two time series with a distributed dask cluster

The MPdist distance measure considers two time series to be similar if they share many subsequences, regardless of the order of matching subsequences. MPdist concatenates the output of an AB-join and a BA-join and returns the kth smallest value as the reported distance. Note that MPdist is a measure and not a metric. Therefore, it does not obey the triangular inequality but the method is highly scalable.

Parameters

• T_A (numpy.ndarray) – The first time series or sequence for which to compute the matrix profile

• T_B (numpy.ndarray) – The second time series or sequence for which to compute the matrix profile

• m (int) – Window size

• percentage (float, default 0.05) – The percentage of distances that will be used to report mpdist. The value is between 0.0 and 1.0. This parameter is ignored when k is not None.

• k (int) – Specify the kth value in the concatenated matrix profiles to return. When k is not None, then the percentage parameter is ignored.

• normalize (bool, default True) – When set to True, this z-normalizes subsequences prior to computing distances. Otherwise, this function gets re-routed to its complementary non-normalized equivalent set in the @core.non_normalized function decorator.

Returns

MPdist – The matrix profile distance

Return type

float

mpdist()

Compute the z-normalized matrix profile distance (MPdist) measure between any two time series

gpu_mpdisted()

Compute the z-normalized matrix profile distance (MPdist) measure between any two time series with one or more GPU devices

Notes

DOI: 10.1109/ICDM.2018.00119

See Section III

Examples

>>> if __name__ == "__main__":
...     stumpy.mpdisted(
...         np.array([-11.1, 23.4, 79.5, 1001.0]),
...         np.array([584., -11., 23., 79., 1001., 0., -19.]),
...         m=3)
0.00019935236191097894

## gpu_mpdist¶

stumpy.gpu_mpdist(T_A, T_B, m, percentage=0.05, k=None, device_id=0, normalize=True)

Compute the z-normalized matrix profile distance (MPdist) measure between any two time series with one or more GPU devices

The MPdist distance measure considers two time series to be similar if they share many subsequences, regardless of the order of matching subsequences. MPdist concatenates and sorts the output of an AB-join and a BA-join and returns the value of the kth smallest number as the reported distance. Note that MPdist is a measure and not a metric. Therefore, it does not obey the triangular inequality but the method is highly scalable.

Parameters
• T_A (numpy.ndarray) – The first time series or sequence for which to compute the matrix profile

• T_B (numpy.ndarray) – The second time series or sequence for which to compute the matrix profile

• m (int) – Window size

• percentage (float, default 0.05) – The percentage of distances that will be used to report mpdist. The value is between 0.0 and 1.0. This parameter is ignored when k is not None.

• k (int, default None) – Specify the kth value in the concatenated matrix profiles to return. When k is not None, then the percentage parameter is ignored.

• device_id (int or list, default 0) – The (GPU) device number to use. The default value is 0. A list of valid device ids (int) may also be provided for parallel GPU-STUMP computation. A list of all valid device ids can be obtained by executing [device.id for device in numba.cuda.list_devices()].

• normalize (bool, default True) – When set to True, this z-normalizes subsequences prior to computing distances. Otherwise, this function gets re-routed to its complementary non-normalized equivalent set in the @core.non_normalized function decorator.

Returns

MPdist – The matrix profile distance

Return type

float

Notes

DOI: 10.1109/ICDM.2018.00119

See Section III

Examples

>>> from numba import cuda
>>> if __name__ == "__main__":
...     all_gpu_devices = [device.id for device in cuda.list_devices()]
...     stumpy.gpu_mpdist(
...         np.array([-11.1, 23.4, 79.5, 1001.0]),
...         np.array([584., -11., 23., 79., 1001., 0., -19.]),
...         m=3,
...         device_id=all_gpu_devices)
0.00019935236191097894

## motifs¶

stumpy.motifs(T, P, min_neighbors=1, max_distance=None, cutoff=None, max_matches=10, max_motifs=1, normalize=True)[source]

Discover the top motifs for time series T

A subsequence, Q, becomes a candidate motif if there are at least min_neighbor number of other subsequence matches in T (outside the exclusion zone) with a distance less or equal to max_distance.

Parameters
• T (numpy.ndarray) – The time series or sequence

• P (numpy.ndarray) – Matrix Profile of T

• min_neighbors (int, default 1) – The minimum number of similar matches a subsequence needs to have in order to be considered a motif. This defaults to 1, which means that a subsequence must have at least one similar match in order to be considered a motif.

• max_distance (float or function, default None) – For a candidate motif, Q, and a non-trivial subsequence, S, max_distance is the maximum distance allowed between Q and S so that S is considered a match of Q. If max_distance is a function, then it must be a function that accepts a single parameter, D, in its function signature, which is the distance profile between Q and T. If None, this defaults to np.nanmax([np.nanmean(D) - 2.0 * np.nanstd(D), np.nanmin(D)]).

• cutoff (float, default None) – The largest matrix profile value (distance) that a candidate motif is allowed to have. If None, this defaults to np.nanmax([np.nanmean(P) - 2.0 * np.nanstd(P), np.nanmin(P)])

• max_matches (int, default 10) – The maximum amount of similar matches of a motif representative to be returned. The resulting matches are sorted by distance, so a value of 10 means that the indices of the most similar 10 subsequences is returned. If None, all matches within max_distance of the motif representative will be returned. Note that the first match is always the self-match/trivial-match for each motif.

• max_motifs (int, default 1) – The maximum number of motifs to return

• normalize (bool, default True) – When set to True, this z-normalizes subsequences prior to computing distances. Otherwise, this function gets re-routed to its complementary non-normalized equivalent set in the @core.non_normalized function decorator.

Returns

• motif_distances (numpy.ndarray) – The distances corresponding to a set of subsequence matches for each motif. Note that the first column always corresponds to the distance for the self-match/trivial-match for each motif.

• motif_indices (numpy.ndarray) – The indices corresponding to a set of subsequences matches for each motif. Note that the first column always corresponds to the index for the self-match/trivial-match for each motif.

stumpy.match()

Find all matches of a query Q in a time series T

Examples

>>> mp = stumpy.stump(np.array([584., -11., 23., 79., 1001., 0., -19.]), m=3)
>>> stumpy.motifs(
...     np.array([584., -11., 23., 79., 1001., 0., -19.]),
...     mp[:, 0],
...     max_distance=2.0)
(array([[0.        , 0.11633857]]), array([[0, 4]]))

## match¶

stumpy.match(Q, T, M_T=None, Σ_T=None, max_distance=None, max_matches=None, normalize=True)[source]

Find all matches of a query Q in a time series T

The indices of subsequences whose distances to Q are less than or equal to max_distance, sorted by distance (lowest to highest). Around each occurrence an exclusion zone is applied before searching for the next.

Parameters
• Q (numpy.ndarray) – The query sequence. It doesn’t have to be a subsequence of T

• T (numpy.ndarray) – The time series of interest

• M_T (numpy.ndarray, default None) – Sliding mean of time series, T

• Σ_T (numpy.ndarray, default None) – Sliding standard deviation of time series, T

• max_distance (float or function, default None) – Maximum distance between Q and a subsequence S for S to be considered a match. If a function, then it has to be a function of one argument D, which will be the distance profile of Q with T (a 1D numpy array of size n-m+1). If None, this defaults to np.nanmax([np.nanmean(D) - 2 * np.nanstd(D), np.nanmin(D)]) (i.e. at least the closest match will be returned).

• max_matches (int, default None) – The maximum amount of similar occurrences to be returned. The resulting occurrences are sorted by distance, so a value of 10 means that the indices of the most similar 10 subsequences is returned. If None, then all occurrences are returned.

• normalize (bool, default True) – When set to True, this z-normalizes subsequences prior to computing distances. Otherwise, this function gets re-routed to its complementary non-normalized equivalent set in the @core.non_normalized function decorator.

Returns

out – The first column consists of distances of subsequences of T whose distances to Q are smaller than max_distance, sorted by distance (lowest to highest). The second column consists of the corresponding indices in T.

Return type

numpy.ndarray

stumpy.motifs()

Discover the top motifs for time series T

Examples

>>> stumpy.match(
...     np.array([-11.1, 23.4, 79.5, 1001.0]),
...     np.array([584., -11., 23., 79., 1001., 0., -19.])
...     )
array([[0.0011129739290248121, 1]], dtype=object)

## snippets¶

stumpy.snippets(T, m, k, percentage=1.0, s=None, mpdist_percentage=0.05, mpdist_k=None, normalize=True)[source]

Identify the top k snippets that best represent the time series, T

Parameters
• T (numpy.ndarray) – The time series or sequence for which to find the snippets

• m (int) – The snippet window size

• k (int) – The desired number of snippets

• percentage (float, default 1.0) – With the length of each non-overlapping subsequence, S[i], set to m, this is the percentage of S[i] (i.e., percentage * m) to set the s to. When percentage == 1.0, then the full length of S[i] is used to compute the mpdist_vect. When percentage < 1.0, then shorter subsequences from S[i] is used to compute mpdist_vect.

• s (int, default None) – With the length of each non-overlapping subsequence, S[i], set to m, this is essentially the sub-subsequence length (i.e., a shorter part of S[i]). When s == m, then the full length of S[i] is used to compute the mpdist_vect. When s < m, then shorter subsequences with length s from each S[i] is used to compute mpdist_vect. When s is not None, then the percentage parameter is ignored.

• mpdist_percentage (float, default 0.05) – The percentage of distances that will be used to report mpdist. The value is between 0.0 and 1.0.

• mpdist_k (int) – Specify the kth value in the concatenated matrix profiles to return. When `mpdist_k is not None, then the mpdist_percentage parameter is ignored.

• normalize (bool, default True) – When set to True, this z-normalizes subsequences prior to computing distances. Otherwise, this function gets re-routed to its complementary non-normalized equivalent set in the @core.non_normalized function decorator.

Returns

• snippets (numpy.ndarray) – The top k snippets

• snippets_indices (numpy.ndarray) – The index locations for each of top k snippets

• snippets_profiles (numpy.ndarray) – The MPdist profiles for each of the top k snippets

• snippets_fractions (numpy.ndarray) – The fraction of data that each of the top k snippets represents

• snippets_areas (numpy.ndarray) – The area under the curve corresponding to each profile for each of the top k snippets

• snippets_regimes (numpy.ndarray) – The index slices corresponding to the set of regimes for each of the top k snippets. The first column is the (zero-based) snippet index while the second and third columns correspond to the (inclusive) regime start indices and the (exclusive) regime stop indices, respectively.

Notes

DOI: 10.1109/ICBK.2018.00058

See Table I

Examples

>>> stumpy.snippets(np.array([584., -11., 23., 79., 1001., 0., -19.]), m=3, k=2)
(array([[ 584.,  -11.,   23.],
[  79., 1001.,    0.]]),
array([0, 3]),
array([[0.        , 3.2452632 , 3.00009263, 2.982409  , 0.11633857],
[2.982409  , 2.69407392, 3.01719586, 0.        , 2.92154586]]),
array([0.6, 0.4]),
array([9.3441034 , 5.81050512]),
array([[0, 0, 1],
[0, 2, 3],
[0, 4, 5],
[1, 1, 2],
[1, 3, 4]]))

## stimp¶

stumpy.stimp(T, min_m=3, max_m=None, step=1, percentage=0.01, pre_scrump=True)[source]

Compute the Pan Matrix Profile

This is based on the SKIMP algorithm.

Parameters
• T (numpy.ndarray) – The time series or sequence for which to compute the pan matrix profile

• m_start (int, default 3) – The starting (or minimum) subsequence window size for which a matrix profile may be computed

• m_stop (int, default None) – The stopping (or maximum) subsequence window size for which a matrix profile may be computed. When m_stop = Non, this is set to the maximum allowable subsequence window size

• m_step (int, default 1) – The step between subsequence window sizes

• percentage (float, default 0.01) – The percentage of the full matrix profile to compute for each subsequence window size. When percentage < 1.0, then the scrump algorithm is used. Otherwise, the stump algorithm is used when the exact matrix profile is requested.

• pre_scrump (bool, default True) – A flag for whether or not to perform the PreSCRIMP calculation prior to computing SCRIMP. If set to True, this is equivalent to computing SCRIMP++. This parameter is ignored when percentage = 1.0.

stumpy.PAN_

The transformed (i.e., normalized, contrasted, binarized, and repeated) pan matrix profile

Type

numpy.ndarray

stumpy.M_

The full list of (breadth first search (level) ordered) subsequence window sizes

Type

numpy.ndarray

update():

Compute the next matrix profile using the next available (breadth-first-search (level) ordered) subsequence window size and update the pan matrix profile

stumpy.stimped()

Compute the Pan Matrix Profile with a distributed dask cluster

stumpy.gpu_stimp()

Compute the Pan Matrix Profile with with one or more GPU devices

Notes

DOI: 10.1109/ICBK.2019.00031

See Table 2

Examples

>>> pmp = stumpy.stimp(np.array([584., -11., 23., 79., 1001., 0., -19.]))
>>> pmp.update()
>>> pmp.PAN_
array([[0., 1., 1., 1., 1., 1., 1.],
[0., 1., 1., 1., 1., 1., 1.]])

## stimped¶

Compute the Pan Matrix Profile with a distributed dask cluster

This is based on the SKIMP algorithm.

Parameters

• T (numpy.ndarray) – The time series or sequence for which to compute the pan matrix profile

• m_start (int, default 3) – The starting (or minimum) subsequence window size for which a matrix profile may be computed

• m_stop (int, default None) – The stopping (or maximum) subsequence window size for which a matrix profile may be computed. When m_stop = Non, this is set to the maximum allowable subsequence window size

• m_step (int, default 1) – The step between subsequence window sizes

stumpy.PAN_

The transformed (i.e., normalized, contrasted, binarized, and repeated) pan matrix profile

Type

numpy.ndarray

stumpy.M_

The full list of (breadth first search (level) ordered) subsequence window sizes

Type

numpy.ndarray

update():

Compute the next matrix profile using the next available (breadth-first-search (level) ordered) subsequence window size and update the pan matrix profile

stumpy.stimp()

Compute the Pan Matrix Profile

stumpy.gpu_stimp()

Compute the Pan Matrix Profile with with one or more GPU devices

Notes

DOI: 10.1109/ICBK.2019.00031

See Table 2

Examples

>>> if __name__ == "__main__":
...     pmp = stumpy.stimped(
...         np.array([584., -11., 23., 79., 1001., 0., -19.]))
...     pmp.update()
...     pmp.PAN_
array([[0., 1., 1., 1., 1., 1., 1.],
[0., 1., 1., 1., 1., 1., 1.]])

## gpu_stimp¶

stumpy.gpu_stimp(T, min_m=3, max_m=None, step=1, device_id=0)

Compute the Pan Matrix Profile with with one or more GPU devices

This is based on the SKIMP algorithm.

Parameters
• T (numpy.ndarray) – The time series or sequence for which to compute the pan matrix profile

• m_start (int, default 3) – The starting (or minimum) subsequence window size for which a matrix profile may be computed

• m_stop (int, default None) – The stopping (or maximum) subsequence window size for which a matrix profile may be computed. When m_stop = Non, this is set to the maximum allowable subsequence window size

• m_step (int, default 1) – The step between subsequence window sizes

• device_id (int or list, default 0) – The (GPU) device number to use. The default value is 0. A list of valid device ids (int) may also be provided for parallel GPU-STUMP computation. A list of all valid device ids can be obtained by executing [device.id for device in numba.cuda.list_devices()].

stumpy.PAN_

The transformed (i.e., normalized, contrasted, binarized, and repeated) pan matrix profile

Type

numpy.ndarray

stumpy.M_

The full list of (breadth first search (level) ordered) subsequence window sizes

Type

numpy.ndarray

update():

Compute the next matrix profile using the next available (breadth-first-search (level) ordered) subsequence window size and update the pan matrix profile

stumpy.stimp()

Compute the Pan Matrix Profile

stumpy.stimped()

Compute the Pan Matrix Profile with a distributed dask cluster

Notes

DOI: 10.1109/ICBK.2019.00031

See Table 2

Examples

>>> from numba import cuda
>>> if __name__ == "__main__":
...     all_gpu_devices = [device.id for device in cuda.list_devices()]
...     pmp = stumpy.gpu_stimp(
...         np.array([584., -11., 23., 79., 1001., 0., -19.]),
...         device_id=all_gpu_devices)
...     pmp.update()
...     pmp.PAN_
array([[0., 1., 1., 1., 1., 1., 1.],
[0., 1., 1., 1., 1., 1., 1.]])