STUMPY API#
有问题吗？#
概述
计算z标准化的矩阵轮廓 |
|
使用 |
|
使用一个或多个GPU设备计算z标准化矩阵剖面 |
|
使用MASS算法计算距离轮廓 |
|
一个用于计算近似z标准化矩阵轮廓的类 |
|
用于计算流数据增量z标准化矩阵轮廓的类 |
|
计算多维z标准化矩阵剖面 |
|
计算多维z标准化矩阵轮廓，使用一个 |
|
计算给定子序列索引及其最近邻索引的 |
|
计算使用最小描述长度 (MDL) 压缩一个多维子序列与另一个子序列所需的多维位数 |
|
计算锚定时间序列链（ATSC） |
|
计算所有链集合（ALLC） |
|
计算快速低成本单一语义分割（FLUSS）用于静态数据（即批处理） |
|
一个计算快速低成本在线语义分割（FLOSS）以进行流数据处理的类 |
|
查找多个时间序列的z标准化共识特征 |
|
在一个 |
|
找到多个时间序列的z标准化共识模式，使用一个或多个GPU设备 |
|
计算任意两个时间序列之间的z标准化矩阵轮廓距离（MPdist）度量 |
|
计算任意两个时间序列之间的z标准化矩阵轮廓距离（MPdist）度量，使用 |
|
计算任意两个时间序列之间的z标准化矩阵剖面距离（MPdist）测量，使用一个或多个GPU设备 |
|
发现时间序列的顶级模式 |
|
在时间序列 |
|
发现多维时间序列 |
|
识别最佳代表时间序列的前 |
|
一个用于计算全景矩阵剖面的类 |
|
一个用于计算 Pan 矩阵轮廓的类，使用一个 |
|
用于计算潘矩阵轮廓的类，支持一个或多个GPU设备 |
树桩#
- stumpy.stump(T_A, m, T_B=None, ignore_trivial=True, normalize=True, p=2.0, k=1, T_A_subseq_isconstant=None, T_B_subseq_isconstant=None)[源]#
计算z标准化矩阵剖面
这是一个方便的包装，围绕着Numba JIT编译的并行化
_stump函数，该函数根据STOMPopt和Pearson相关性计算 (top-k) 矩阵轮廓。- Parameters:
- T_Anumpy.ndarray
要计算矩阵剖面的时间序列或序列。
- mint
窗口大小。
- T_Bnumpy.ndarray, default None
将用于注释
T_A的时间序列或序列。对于T_A中的每个子序列，将记录其在T_B中的最近邻。默认为None，这对应于自连接。- ignore_trivialbool, default True
如果这是自连接，设置为
True。否则，对于AB连接，将其设置为False。- normalizebool, default True
当设置为
True时，先对子序列进行z标准化，然后再计算距离。否则，此函数将被重定向到其对应的非标准化等效函数，该函数设置在@core.non_normalized函数装饰器中。- pfloat, default 2.0
用于计算闵可夫斯基距离的 p-范数。闵可夫斯基距离通常使用
p为1或2，分别对应于曼哈顿距离和欧几里得距离。当normalize == True时，此参数将被忽略。- kint, default 1
用于构建矩阵剖面的最小距离的前
k个数量。请注意，当k > 1时，这将增加总计算时间和内存使用。如果您可以使用 GPU 设备，那么您可能能够利用gpu_stump来获得更好的性能和可扩展性。- T_A_subseq_isconstantnumpy.ndarray or function, default None
一个布尔数组，指示在
T_A中的一个子序列是否是常量 (True)。或者，一个自定义的用户定义函数，返回一个 布尔数组，指示在T_A中的一个子序列是否是常量 (True)。该函数必须仅接受两个参数，a，一个一维数组， 和w，窗口大小，而额外的参数可以通过使用functools.partial对用户定义函数进行柯里化来指定。 任何包含至少一个np.nan/np.inf的子序列将自动在此布尔数组中 其对应值设置为False。- T_B_subseq_isconstantnumpy.ndarray or function, default None
一个布尔数组，指示在
T_B中的一个子序列是否为常数 (True)。或者，一个自定义的用户定义函数，返回一个 布尔数组，指示在T_B中的一个子序列是否为常数 (True)。该函数必须仅接受两个参数，a，一个一维数组， 和w，窗口大小，同时可以通过使用functools.partial对用户定义函数进行柯里化来指定其他参数。 任何具有至少一个np.nan/np.inf的子序列将在此布尔数组中自动将 其对应的值设置为False。
- Returns:
- outnumpy.ndarray
当
k = 1（默认情况下），第一列由矩阵配置组成，第二列由矩阵配置索引组成，第三列由左矩阵配置索引组成，第四列由右矩阵配置索引组成。然而，当k > 1时，输出数组将包含精确的2 * k + 2列。前k列（即，out[:, :k]）包含前-k 矩阵配置，下一组k列（即，out[:, k : 2 * k]）包含相应的前-k 矩阵配置索引，最后两列（即，out[:, 2 * k]和out[:, 2 * k + 1]或，等效地，out[:, -2]和out[:, -1]）分别对应于前-1 左矩阵配置索引和前-1 右矩阵配置索引。为了方便，可以通过对应的命名数组属性访问矩阵剖面（距离）和矩阵剖面索引，即
.P_和.I_。同样，可以通过.left_I_和.right_I_数组属性访问对应的左侧矩阵剖面索引和右侧矩阵剖面索引。请参见下面的示例。
另见
stumpy.stumped使用
dask/ray集群计算 z 标准化矩阵轮廓stumpy.gpu_stump计算使用一个或多个GPU设备的z标准化矩阵轮廓
stumpy.scrump计算近似z标准化矩阵剖面
备注
DOI: 10.1007/s10115-017-1138-x
见第4.5节
上述参考概述了一种以对角线方式遍历距离矩阵的一般方法，而不是按行方式进行。
参见第3.1节和第3.3节
上述参考文献概述了通过 Welford 的集中乘积和在距离矩阵的每个对角线上使用 Pearson 相关性，以替代原始 STOMP 方法中找到的滑动窗口点积。
见表 II
时间序列，
T_A，将被注释为在另一个时间序列T_B中所有其子序列的距离位置（或索引）。返回：对于每个子序列，
Q，在T_A中，您将获得与T_B中最近子序列的距离和索引。因此，返回的数组长度为T_A.shape[0] - m + 1。此外，左矩阵和右矩阵的特征也将返回。注意：与表II不同，在表II中期望
T_A.shape等于T_B.shape，该实现是通用的，因此T_A和T_B的形状可以不同。在T_A.shape == T_B.shape的情况下，我们的算法简化为表II中找到的相同算法。此外，与STAMP不同的是，排除区域是
m/2，STOMP的默认排除区域是m/4（见定义3和图3）。对于自连接，设置
ignore_trivial = True以避免简单匹配。注意，左矩阵剖面和右矩阵剖面仅在自连接时可用。
示例
>>> import stumpy >>> import numpy as np >>> mp = stumpy.stump(np.array([584., -11., 23., 79., 1001., 0., -19.]), m=3) >>> mp mparray([[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) >>> >>> mp.P_ mparray([0.11633857, 2.69407392, 3.00009263, 2.69407392, 0.11633857]) >>> mp.I_ mparray([4, 3, 0, 1, 0])
困惑#
- stumpy.stumped(client, T_A, m, T_B=None, ignore_trivial=True, normalize=True, p=2.0, k=1, T_A_subseq_isconstant=None, T_B_subseq_isconstant=None)[源]#
使用
dask/ray集群计算z标准化矩阵轮廓这是一个高度分布式的实现，围绕着Numba JIT编译的并行化
_stump函数，该函数根据STOMPopt使用Pearson相关性计算（前k个）矩阵轮廓。- Parameters:
- clientclient
A
dask/ray客户端。设置集群超出了该库的范围。请参考dask/ray文档。- T_Anumpy.ndarray
要计算矩阵剖面的时间序列或序列。
- mint
窗口大小。
- T_Bnumpy.ndarray, default None
将用于注释
T_A的时间序列或序列。对于T_A中的每个子序列，将记录其在T_B中的最近邻。默认为None，这对应于自连接。- ignore_trivialbool, default True
如果这是自连接，设置为
True。否则，对于AB连接，将其设置为False。- normalizebool, default True
当设置为
True时，先对子序列进行z标准化，然后再计算距离。否则，此函数将被重定向到其对应的非标准化等效函数，该函数设置在@core.non_normalized函数装饰器中。- pfloat, default 2.0
用于计算闵可夫斯基距离的 p-范数。闵可夫斯基距离通常使用
p为1或2，分别对应于曼哈顿距离和欧几里得距离。当normalize == True时，此参数将被忽略。- kint, default 1
用于构建矩阵剖面的最小距离的前
k个数量。请注意，当k > 1时，这将增加总计算时间和内存使用。如果您可以使用 GPU 设备，那么您可能能够利用gpu_stump来获得更好的性能和可扩展性。- T_A_subseq_isconstantnumpy.ndarray or function, default None
一个布尔数组，指示在
T_A中的一个子序列是否是常量 (True)。或者，一个自定义的用户定义函数，返回一个 布尔数组，指示在T_A中的一个子序列是否是常量 (True)。该函数必须仅接受两个参数，a，一个一维数组， 和w，窗口大小，而额外的参数可以通过使用functools.partial对用户定义函数进行柯里化来指定。 任何包含至少一个np.nan/np.inf的子序列将自动在此布尔数组中 其对应值设置为False。- T_B_subseq_isconstantnumpy.ndarray or function, default None
一个布尔数组，指示在
T_B中的一个子序列是否为常数 (True)。或者，一个自定义的用户定义函数，返回一个 布尔数组，指示在T_B中的一个子序列是否为常数 (True)。该函数必须仅接受两个参数，a，一个一维数组， 和w，窗口大小，同时可以通过使用functools.partial对用户定义函数进行柯里化来指定其他参数。 任何具有至少一个np.nan/np.inf的子序列将在此布尔数组中自动将 其对应的值设置为False。
- Returns:
- outnumpy.ndarray
当
k = 1（默认值）时，第一列由矩阵剖面组成，第二列由矩阵剖面索引组成，第三列由左矩阵剖面索引组成，第四列由右矩阵剖面索引用组成。然而，当k > 1时，输出数组将包含准确的2 * k + 2列。前k列（即，out[:, :k]）由前-k矩阵剖面组成，接下来的k列（即，out[:, k : 2 * k]）由相应的前-k矩阵剖面索引组成，最后两列（即，out[:, 2 * k]和out[:, 2 * k + 1]或等效的out[:, -2]和out[:, -1]）分别对应于前-1的左矩阵剖面索引和前-1的右矩阵剖面索引。为了方便，矩阵剖面（距离）和矩阵剖面索引也可以通过其相应的命名数组属性访问，
.P_和.I_，分别。类似地，相应的左矩阵剖面索引和右矩阵剖面索引也可以通过.left_I_和.right_I_数组属性访问。请参见下面的示例。
另见
stumpy.stump计算z标准化矩阵轮廓聚类
stumpy.gpu_stump计算使用一个或多个GPU设备的z标准化矩阵轮廓
stumpy.scrump计算近似z标准化矩阵剖面
备注
DOI: 10.1007/s10115-017-1138-x
见第4.5节
上述参考概述了一种以对角线方式遍历距离矩阵的一般方法，而不是按行方式进行。
参见第3.1节和第3.3节
上述参考文献概述了通过 Welford 的集中乘积和在距离矩阵的每个对角线上使用 Pearson 相关性，以替代原始 STOMP 方法中找到的滑动窗口点积。
见表 II
这是一个
dask/ray的 stump 实现，可以跨多台服务器扩展，并且是对并行化的stump._stump函数的便利封装时间序列，
T_A，将被注释为在另一个时间序列T_B中所有其子序列的距离位置（或索引）。返回：对于每个子序列，
Q，在T_A中，您将获得一个距离和最近子序列在T_B中的索引。因此，返回的数组长度将为T_A.shape[0] - m + 1。此外，左矩阵和右矩阵的轮廓也将被返回。注意：与表 II 中
T_A.shape被期望等于T_B.shape不同，本实现是广义的，因此T_A和T_B的形状可以不同。在T_A.shape == T_B.shape的情况下，我们的算法简化为表 II 中的相同算法。此外，与STAMP不同的是，排除区域是
m/2，STOMP的默认排除区域是m/4（见定义3和图3）。对于自连接，设置
ignore_trivial = True以避免简单匹配。注意，左矩阵剖面和右矩阵剖面仅在自连接时可用。
示例
>>> import stumpy >>> import numpy as np >>> from dask.distributed import Client >>> if __name__ == "__main__": ... with Client() as dask_client: ... stumpy.stumped( ... dask_client, ... np.array([584., -11., 23., 79., 1001., 0., -19.]), ... m=3) mparray([[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) >>> >>> mp.P_ mparray([0.11633857, 2.69407392, 3.00009263, 2.69407392, 0.11633857]) >>> mp.I_ mparray([4, 3, 0, 1, 0])
或者，你也可以使用 ray
>>> import ray >>> if __name__ == "__main__": >>> ray.init() >>> stumpy.stumped( ... ray, ... np.array([584., -11., 23., 79., 1001., 0., -19.]), ... m=3) >>> ray.shutdown()
gpu_stump#
- stumpy.gpu_stump(T_A, m, T_B=None, ignore_trivial=True, device_id=0, normalize=True, p=2.0, k=1, T_A_subseq_isconstant=None, T_B_subseq_isconstant=None)#
计算使用一个或多个GPU设备的z标准化矩阵轮廓
这是一个方便的包装器，围绕着Numba
cuda.jit_gpu_stump函数，按照GPU-STOMP计算矩阵分析。默认的每块线程数设置为512，可以通过将全局参数config.STUMPY_THREADS_PER_BLOCK设置为基于您的GPU硬件的适当数字来更改。- Parameters:
- T_Anumpy.ndarray
要计算矩阵剖面的时间序列或序列。
- mint
窗口大小。
- T_Bnumpy.ndarray, default None
将用于注释
T_A的时间序列或序列。对于T_A中的每个子序列，其在T_B中的最近邻将被记录。默认是None，这对应于自连接。- ignore_trivialbool, default True
如果这是自连接，设置为
True。否则，对于AB连接，将其设置为False。- device_idint or list, default 0
要使用的 (GPU) 设备编号。默认值为
0。还可以提供有效设备 ID 的列表 (int) 以进行并行 GPU-STUMP 计算。可以通过执行[device.id for device in numba.cuda.list_devices()]获得所有有效设备 ID 的列表。- normalizebool, default True
当设置为
True时，先对子序列进行z标准化，然后再计算距离。否则，此函数将被重定向到其对应的非标准化等效函数，该函数设置在@core.non_normalized函数装饰器中。- pfloat, default 2.0
用于计算闵可夫斯基距离的 p-范数。闵可夫斯基距离通常使用
p为1或2，分别对应于曼哈顿距离和欧几里得距离。当normalize == True时，此参数将被忽略。- kint, default 1
用于构建矩阵轮廓的最小距离的前
k个数量。请注意，当k > 1时，这将增加总的计算时间和内存使用。- T_A_subseq_isconstantnumpy.ndarray or function, default None
一个布尔数组，指示在
T_A中的一个子序列是否是常量 (True)。或者，一个自定义的用户定义函数，返回一个 布尔数组，指示在T_A中的一个子序列是否是常量 (True)。该函数必须仅接受两个参数，a，一个一维数组， 和w，窗口大小，而额外的参数可以通过使用functools.partial对用户定义函数进行柯里化来指定。 任何包含至少一个np.nan/np.inf的子序列将自动在此布尔数组中 其对应值设置为False。- T_B_subseq_isconstantnumpy.ndarray or function, default None
一个布尔数组，指示在
T_B中的一个子序列是否为常数 (True)。或者，一个自定义的用户定义函数，返回一个 布尔数组，指示在T_B中的一个子序列是否为常数 (True)。该函数必须仅接受两个参数，a，一个一维数组， 和w，窗口大小，同时可以通过使用functools.partial对用户定义函数进行柯里化来指定其他参数。 任何具有至少一个np.nan/np.inf的子序列将在此布尔数组中自动将 其对应的值设置为False。
- Returns:
- outnumpy.ndarray
当
k = 1（默认值）时，第一列包含矩阵剖面，第二列包含矩阵剖面索引，第三列包含左矩阵剖面索引，第四列包含右矩阵剖面索引。然而，当k > 1时，输出数组将包含正好2 * k + 2列。前k列（即，out[:, :k]）包含前 k 个矩阵剖面，接下来的k列（即，out[:, k : 2 * k）包含对应的前 k 个矩阵剖面索引，最后两列（即，out[:, 2 * k]和out[:, 2 * k + 1]，或等效地out[:, -2]和out[:, -1]）分别对应于前 1 个左矩阵剖面索引和前 1 个右矩阵剖面索引。为了方便，矩阵剖面（距离）和矩阵剖面索引也可以通过其相应的命名数组属性访问，
.P_和.I_，分别。类似地，相应的左矩阵剖面索引和右矩阵剖面索引也可以通过.left_I_和.right_I_数组属性访问。请参见下面的示例。
另见
stumpy.stump计算z标准化矩阵剖面
stumpy.stumped使用
dask/ray集群计算 z 标准化矩阵轮廓stumpy.scrump计算近似z标准化矩阵剖面
备注
请参见表 II、图 5 和图 6
时间序列，
T_A，将被注释为在另一个时间序列T_B中所有其子序列的距离位置（或索引）。返回：对于每个子序列，
Q，在T_A中，您将获得与T_B中最近子序列的距离和索引。因此，返回的数组长度为T_A.shape[0] - m + 1。此外，左矩阵和右矩阵的特征也将返回。注意：与表 II 中
T_A.shape被期望等于T_B.shape不同，本实现是广义的，因此T_A和T_B的形状可以不同。在T_A.shape == T_B.shape的情况下，我们的算法简化为表 II 中的相同算法。此外，与STAMP不同的是，排除区域是
m/2，STOMP的默认排除区域是m/4（见定义3和图3）。对于自连接，设置
ignore_trivial = True以避免简单匹配。注意，左矩阵剖面和右矩阵剖面仅在自连接时可用。
示例
>>> import stumpy >>> import numpy as np >>> from numba import cuda >>> if __name__ == "__main__": ... all_gpu_devices = [device.id for device in cuda.list_devices()] ... mp = stumpy.gpu_stump( ... np.array([584., -11., 23., 79., 1001., 0., -19.]), ... m=3, ... device_id=all_gpu_devices) >>> mp mparray([[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) >>> >>> mp.P_ mparray([0.11633857, 2.69407392, 3.00009263, 2.69407392, 0.11633857]) >>> mp.I_ mparray([4, 3, 0, 1, 0])
质量#
- stumpy.mass(Q, T, M_T=None, Σ_T=None, normalize=True, p=2.0, T_subseq_isfinite=None, T_subseq_isconstant=None, Q_subseq_isconstant=None, query_idx=None)[源]#
使用MASS算法计算距离概况
这是一个方便的包装器，围绕着Numba JIT编译的_mass函数。
- Parameters:
- Qnumpy.ndarray
查询数组或子序列。
- Tnumpy.ndarray
时间序列或序列。
- M_Tnumpy.ndarray, default None
滑动平均值
T.- Σ_Tnumpy.ndarray, default None
滑动标准差 of
T.- normalizebool, default True
当设置为
True时，先对子序列进行z标准化，然后再计算距离。否则，此函数将被重定向到其对应的非标准化等效函数，该函数设置在@core.non_normalized函数装饰器中。- pfloat, default 2.0
用于计算闵可夫斯基距离的p范数。此参数在
normalize == True时被忽略。- T_subseq_isfinitenumpy.ndarray, default None
一个布尔数组，指示
T中的子序列是否包含np.nan/np.inf值（False）。当normalize == True时，此参数被忽略。- T_subseq_isconstantnumpy.ndarray or function, default None
一个布尔数组，用于指示
T中的子序列是否是连续的 (True)。另外，可以使用自定义的用户定义函数返回一个 布尔数组，该数组指示T中的子序列是否是连续的 (True)。该函数必须仅接受两个参数，a，一个一维数组， 和w，窗口大小，而额外的参数可以通过使用functools.partial对用户定义函数进行柯里化来指定。 任何包含至少一个np.nan/np.inf的子序列将在该布尔数组中对应的值自动设置为False。- Q_subseq_isconstantnumpy.ndarray or function, default None
一个布尔数组，用于指示
Q中的子序列是否是常量 (True)。或者，一个自定义的用户定义函数，返回一个 布尔数组，用于指示Q中的子序列是否是常量 (True)。该函数仅需接受两个参数，a，一个一维数组， 和w，窗口大小，而额外的参数可以通过使用functools.partial对用户定义的函数进行柯里化来指定。 任何含有至少一个np.nan/np.inf的子序列将自动在此布尔数组中将其对应的值设为False。- query_idxint, default None
这是时间序列中的索引位置，
T，查询子序列Q的位置。如果Q不是T的子序列，则query_idx应设置为None。如果Q是T的子序列，则提供此参数是可选的。如果提供了query_idx，则Q与T[query_idx : query_idx + m]之间的距离将自动设为零。
- Returns:
- distance_profilenumpy.ndarray
距离剖面。
另见
stumpy.motifs发现时间序列的主要模式
Tstumpy.match在时间序列
T中查找查询Q的所有匹配项
备注
见表 II
请注意
Q,T并不是计算D直接所需的注意：与《Matrix Profile I》论文不同，在这里，
M_T，Σ_T可以针对T的所有子序列计算一次并传入，从而消除冗余示例
>>> import stumpy >>> import numpy as np >>> 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])
敏捷开发#
- stumpy.scrump(T_A, m, T_B=None, ignore_trivial=True, percentage=0.01, pre_scrump=False, s=None, normalize=True, p=2.0, k=1, T_A_subseq_isconstant=None, T_B_subseq_isconstant=None)[源]#
用于计算近似z标准化矩阵剖面的类
这是一个关于Numba JIT编译的并行化
_stump函数的便利封装，该函数根据SCRIMP计算矩阵剖面。- Parameters:
- T_Anumpy.ndarray
要计算矩阵剖面的时间序列或序列。
- T_Bnumpy.ndarray
将用于注释
T_A的时间序列或序列。对于T_A中的每一个子序列，它在T_B中的最近邻将被记录。- mint
窗口大小。
- ignore_trivialbool
如果这是自连接，则设置为
True。否则，对于 AB 连接，将其设置为False。- percentagefloat
完成的大致百分比。该值介于
0.0和1.0之间。- pre_scrumpbool
一个标志，指示在计算SCRIMP之前是否执行PreSCRIMP计算。如果设置为
True，这相当于计算SCRIMP++，可能会导致更快的收敛- sint
PreSCRIMP 固定间隔的大小。如果
pre_scrump = True并且s = None，那么s将自动设置为s = int(np.ceil(m / config.STUMPY_EXCL_ZONE_DENOM))，这是 排除区域的大小。- normalizebool, default True
当设置为
True时，此操作在计算距离之前对子序列进行z标准化。否则，此类会重新路由到其补充的非标准化等效设置，在@core.non_normalized类装饰器中。- pfloat, default 2.0
用于计算闵可夫斯基距离的 p-范数。闵可夫斯基距离通常使用
p为1或2，分别对应于曼哈顿距离和欧几里得距离。当normalize == True时，此参数将被忽略。- kint, default 1
用于构建矩阵特征的最小
k个最小距离的数量。注意，当k > 1时，这将增加总的计算时间和内存使用。- T_A_subseq_isconstantnumpy.ndarray or function, default None
一个布尔数组，指示在
T_A中的一个子序列是否是常量 (True)。或者，一个自定义的用户定义函数，返回一个 布尔数组，指示在T_A中的一个子序列是否是常量 (True)。该函数必须仅接受两个参数，a，一个一维数组， 和w，窗口大小，而额外的参数可以通过使用functools.partial对用户定义函数进行柯里化来指定。 任何包含至少一个np.nan/np.inf的子序列将自动在此布尔数组中 其对应值设置为False。- T_B_subseq_isconstantnumpy.ndarray or function, default None
一个布尔数组，指示在
T_B中的一个子序列是否为常数 (True)。或者，一个自定义的用户定义函数，返回一个 布尔数组，指示在T_B中的一个子序列是否为常数 (True)。该函数必须仅接受两个参数，a，一个一维数组， 和w，窗口大小，同时可以通过使用functools.partial对用户定义函数进行柯里化来指定其他参数。 任何具有至少一个np.nan/np.inf的子序列将在此布尔数组中自动将 其对应的值设置为False。
- Attributes:
P_numpy.ndarray获取更新的（前k个）矩阵剖面。
I_numpy.ndarray获取更新的（前k个）矩阵剖面索引。
left_I_numpy.ndarray获取更新的左侧（顶部-1）矩阵剖面索引
right_I_numpy.ndarray获取更新的右侧（top-1）矩阵轮廓索引
方法
update()
通过计算额外的新距离（受限于
percentage），更新矩阵轮廓和矩阵轮廓索引，以构成完整的距离矩阵。它更新了（top-k）矩阵轮廓、（top-1）左矩阵轮廓、（top-1）右矩阵轮廓、（top-k）矩阵轮廓索引、（top-1）左矩阵轮廓索引和（top-1）右矩阵轮廓索引。另见
stumpy.stump计算z标准化矩阵剖面
stumpy.stumped使用
dask/ray集群计算z标准化矩阵轮廓stumpy.gpu_stump计算使用一个或多个GPU设备的z标准化矩阵轮廓
备注
请参见算法 1 和算法 2
示例
>>> import stumpy >>> import numpy as np >>> approx_mp = stumpy.scrump( ... np.array([584., -11., 23., 79., 1001., 0., -19.]), ... m=3) >>> approx_mp.update() >>> approx_mp.P_ array([2.982409 , 3.28412702, inf, 2.982409 , 3.28412702]) >>> approx_mp.I_ array([ 3, 4, -1, 0, 1])
树桩i#
- stumpy.stumpi(T, m, egress=True, normalize=True, p=2.0, k=1, mp=None, T_subseq_isconstant_func=None)[源]#
一个用于计算流数据增量z标准化矩阵轮廓的类
这是基于在线STOMPI和STAMPI算法。
- Parameters:
- Tnumpy.ndarray
将返回矩阵简介和矩阵简介索引的时间序列或序列。
- mint
窗口大小。
- egressbool, default True
如果设置为
True，时间序列中的最旧数据点将被移除，时间序列的长度将保持不变，而不是永远增加- normalizebool, default True
当设置为
True时，此 z 标准化子序列在计算距离之前。否则，此类将被重新路由到其在@core.non_normalized类装饰器中对应的非标准化等价物。- pfloat, default 2.0
用于计算闵可夫斯基距离的p范数。此参数在
normalize == True时被忽略。- kint, default 1
用于构建矩阵特征的最小
k个最小距离的数量。注意，当k > 1时，这将增加总的计算时间和内存使用。- mpnumpy.ndarray, default None
预计算的矩阵特征（及其对应的矩阵特征索引）。这是一个形状为
(len(T) - m + 1, 2 * k + 2)的二维数组，其中前k列是前 k 矩阵特征，接下来的k列是它们对应的索引。最后两列对应于 top-1 左侧和 top-1 右侧矩阵特征索引。当None（默认）时，这个数组在内部使用stumpy.stump计算。- T_subseq_isconstant_funcfunction, default None
一个自定义的用户定义函数，它返回一个布尔数组，指示在
T中的子序列是否是常量 (True)。该函数必须只接受两个参数，a，一个一维数组，以及w，窗口大小，同时可以通过使用functools.partial对用户定义函数进行柯里化来指定额外的参数。任何具有至少一个np.nan/np.inf的子序列，将自动在这个布尔数组中对应的值设置为False。
- Attributes:
P_numpy.ndarray获取 (top-k) 矩阵配置文件。
I_numpy.ndarray获取（前k个）矩阵轮廓索引。
left_P_numpy.ndarray获取（top-1）左矩阵概况
left_I_numpy.ndarray获取（top-1）左侧矩阵轮廓索引
T_numpy.ndarray获取时间序列
方法
update(t)
将单个新数据点，
t，附加到时间序列T中，并更新矩阵剖面。备注
DOI: 10.1007/s10618-017-0519-9
参见表 V
注意第11行缺少一个重要的
sqrt操作!示例
>>> import stumpy >>> import numpy as np >>> 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, p=2.0, T_subseq_isconstant=None)[源]#
计算多维z标准化矩阵轮廓
这是一个便利的包装器，围绕着Numba JIT编译的并行化
_mstump函数，该函数根据mSTOMP计算多维矩阵轮廓和多维矩阵轮廓索引，mSTOMP是 mSTAMP的一种变体。请注意，仅支持自连接。- Parameters:
- Tnumpy.ndarray
用于计算多维矩阵剖面的时间序列或序列。
T中的每一行代表来自同一维度的数据，而T中的每一列代表来自不同维度的数据。- mint
窗口大小。
- includelist, numpy.ndarray, default None
与必须包含在受限的多维动机搜索中的
T的维度对应的（零基）索引列表。有关更多信息，请参见：- discordsbool, default False
当设置为
True时，这将反转距离矩阵，从而产生一个多维矩阵特征，偏向于较大的矩阵特征值（即，离群值），而不是较小的值（即，模式）。请注意，include中的索引仍然得到维护和尊重。- normalizebool, default True
当设置为
True时，先对子序列进行z标准化，然后再计算距离。否则，此函数将被重定向到其对应的非标准化等效函数，该函数设置在@core.non_normalized函数装饰器中。- pfloat, default 2.0
用于计算闵可夫斯基距离的 p-范数。闵可夫斯基距离通常使用
p为1或2，分别对应于曼哈顿距离和欧几里得距离。当normalize == True时，此参数将被忽略。- T_subseq_isconstantnumpy.ndarray, function, or list, default None
一个参数，用于显示时间序列中一个子序列是否为常数(
True)。T_subseq_isconstant可以是一个 2D 布尔numpy.ndarray，也可以是一个可以应用于T中每个时间序列的函数。或者，为了最大灵活性，也可以使用一个列表（长度等于时间序列的总数）。在这种情况下，T_subseq_isconstant[i]对应于第i个时间序列T[i]，列表中的每个元素可以是一个 1D 布尔numpy.ndarray、一个函数，或None。
- Returns:
- Pnumpy.ndarray
多维矩阵剖面。数组的每一行对应于给定维度的每个矩阵剖面（即，第一行是1维矩阵剖面，第二行是2维矩阵剖面）。
- Inumpy.ndarray
多维矩阵特征索引，其中数组的每一行对应于给定维度的每个矩阵特征索引。
另见
stumpy.mstumped计算多维z标准化矩阵轮廓，使用一个
dask/ray集群stumpy.subspace计算给定子序列索引及其最近邻索引的k维矩阵剖面子空间
stumpy.mdl计算使用最小描述长度（MDL）将一个数组压缩到另一个数组所需的位数
备注
查看 mSTAMP 算法
示例
>>> 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(client, T, m, include=None, discords=False, p=2.0, normalize=True, T_subseq_isconstant=None)[源]#
计算多维z标准化矩阵剖面的
dask/ray集群这是一个高度分布式的实现，围绕着 Numba JIT 编译的 并行化
_mstump函数，该函数根据 STOMP 计算多维矩阵 轮廓。请注意，仅支持自连接。- Parameters:
- clientclient
A
dask/ray客户端。设置集群超出了该库的范围。请参考dask/ray文档。- Tnumpy.ndarray
用于计算多维矩阵剖面的时间序列或序列。
T中的每一行代表来自同一维度的数据，而T中的每一列代表来自不同维度的数据。- mint
窗口大小。
- includelist, numpy.ndarray, default None
与必须包含在受限的多维动机搜索中的
T的维度对应的（零基）索引列表。有关更多信息，请参见：- discordsbool, default False
当设置为
True时，这会反转距离矩阵，从而产生一个多维矩阵轮廓，该轮廓偏向于较大的矩阵轮廓值（即，离群点），而不是较小的值（即，模式）。请注意，include 中的索引仍然得到维护和尊重。- pfloat, default 2.0
用于计算闵可夫斯基距离的p范数。闵可夫斯基距离通常与
p取1或2，分别对应于曼哈顿距离和欧几里得距离。- normalizebool, default True
当设置为
True时，先对子序列进行z标准化，然后再计算距离。否则，此函数将被重定向到其对应的非标准化等效函数，该函数设置在@core.non_normalized函数装饰器中。- T_subseq_isconstantnumpy.ndarray, function, or list, default None
一个参数，用于显示时间序列中的一个子序列在
T中是否为常数 (True)。T_subseq_isconstant可以是一个 2D 布尔numpy.ndarray或可应用于每个时间序列的函数在T中。或者，为了最大灵活性，也可以使用一个列表（长度等于时间序列的总数）。在这种情况下，T_subseq_isconstant[i]对应于第i个时间序列T[i]，列表中的每个元素可以是一个 1D 布尔numpy.ndarray，一个函数，或者None。
- Returns:
- Pnumpy.ndarray
多维矩阵剖面。数组的每一行对应于给定维度的每个矩阵剖面（即，第一行是1维矩阵剖面，第二行是2维矩阵剖面）。
- Inumpy.ndarray
多维矩阵特征索引，其中数组的每一行对应于给定维度的每个矩阵特征索引。
另见
stumpy.mstump计算多维z标准化矩阵轮廓
stumpy.subspace计算给定子序列索引及其最近邻索引的k维矩阵剖面子空间
stumpy.mdl计算使用最小描述长度（MDL）将一个数组压缩到另一个数组所需的位数
备注
查看 mSTAMP 算法
示例
>>> import stumpy >>> import numpy as np >>> from dask.distributed import Client >>> if __name__ == "__main__": ... with Client() as dask_client: ... stumpy.mstumped( ... dask_client, ... 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]]))
或者，你也可以使用 ray
>>> import ray >>> if __name__ == "__main__": >>> ray.init() >>> stumpy.mstumped( ... ray, ... np.array([[584., -11., 23., 79., 1001., 0., -19.], ... [ 1., 2., 4., 8., 16., 0., 32.]]), ... m=3) >>> ray.shutdown()
子空间#
- stumpy.subspace(T, m, subseq_idx, nn_idx, k, include=None, discords=False, discretize_func=None, n_bit=8, normalize=True, p=2.0, T_subseq_isconstant=None)[源]#
计算给定子序列索引的
k维矩阵配置子空间及其最近邻索引- Parameters:
- Tnumpy.ndarray
计算多维矩阵剖面、计算多维矩阵剖面索引的时间序列或序列。
- mint
窗口大小。
- subseq_idxint
子序列索引在
T中。- nn_idxint
在
T中的最近邻索引。- kint
要返回子空间的维度子集数量，来自于
D = T.shape[0]维度。请注意使用的是零基索引。- includenumpy.ndarray, default None
与必须包含在受限的多维动机搜索中的
T的维度对应的（零基）索引列表。有关更多信息，请参见：- discordsbool, default False
当设置为
True时，这会反转距离轮廓，以偏向不和谐模式而不是模式。 请注意，include中的索引仍然保持并受到尊重。- discretize_funcfunc, default None
一个用于离散化每个输入数组的函数。当这个是
None时，将应用一个合适的离散化函数（基于normalize参数）。- n_bitint, default 8
用于离散化的位数。有关适当值的更多信息，请参见：
和图2在：
- normalizebool, default True
当设置为
True时，先对子序列进行z标准化，然后再计算距离。否则，此函数将被重定向到其对应的非标准化等效函数，该函数设置在@core.non_normalized函数装饰器中。- pfloat, default 2.0
用于计算闵可夫斯基距离的 p-范数。闵可夫斯基距离通常使用
p为1或2，分别对应于曼哈顿距离和欧几里得距离。当normalize == True时，此参数将被忽略。- T_subseq_isconstantnumpy.ndarray, function, or list, default None
一个参数，用于显示时间序列的子序列在
T中是否是常数 (True) 或不是。T_subseq_isconstant可以是一个 2D 布尔numpy.ndarray或可以应用于T中每个时间序列的函数。或者，为了最大灵活性，也可以使用一个列表（长度等于时间序列的总数）。在这种情况下，T_subseq_isconstant[i]对应于第i个时间序列T[i]，列表中的每个元素可以是一个 1D 布尔numpy.ndarray、一个函数或None。
- Returns:
- Snumpy.ndarray
一个包含索引等于
subseq_idx的子序列的（单一的）k维子空间的数组。注意将返回k + 1行。
另见
stumpy.mstump计算多维z标准化矩阵轮廓
stumpy.mstumped计算多维z标准化矩阵轮廓，使用一个
dask/ray集群stumpy.mdl计算使用最小描述长度（MDL）将一个数组压缩到另一个数组所需的位数
示例
>>> import stumpy >>> import numpy as np >>> 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] >>> k = 1 >>> 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=k) array([0, 1])
mdl#
- stumpy.mdl(T, m, subseq_idx, nn_idx, include=None, discords=False, discretize_func=None, n_bit=8, normalize=True, p=2.0, T_subseq_isconstant=None)[源]#
计算在每个
k维度上使用最小描述长度（MDL）将一个多维子序列与另一个多维子序列压缩所需的位数- Parameters:
- Tnumpy.ndarray
计算多维矩阵剖面、计算多维矩阵剖面索引的时间序列或序列。
- mint
窗口大小。
- subseq_idxnumpy.ndarray
在
T中的多维子序列索引- nn_idxnumpy.ndarray
多维最近邻索引在
T中- includenumpy.ndarray, default None
与必须包含在受限的多维动机搜索中的
T的维度对应的（零基）索引列表。有关更多信息，请参见：- discordsbool, default False
当设置为
True时，距离轮廓会反转，以优先考虑不和谐而不是模式。请注意，include中的索引仍然被维护和尊重。- discretize_funcfunc, default None
一个用于离散化每个输入数组的函数。当这个是
None时，将应用一个适当的离散化函数（基于normalization参数）。- n_bitint, default 8
用于离散化和计算位大小的位数。有关适当值的更多信息，请参见：
和图2在：
- normalizebool, default True
当设置为
True时，先对子序列进行z标准化，然后再计算距离。否则，此函数将被重定向到其对应的非标准化等效函数，该函数设置在@core.non_normalized函数装饰器中。- pfloat, default 2.0
用于计算闵可夫斯基距离的 p-范数。闵可夫斯基距离通常使用
p为1或2，分别对应于曼哈顿距离和欧几里得距离。当normalize == True时，此参数将被忽略。- T_subseq_isconstantnumpy.ndarray, function, or list, default None
一个参数，用于显示时间序列中的一个子序列在
T中是否为常数 (True)。T_subseq_isconstant可以是一个 2D 布尔numpy.ndarray或可应用于每个时间序列的函数在T中。或者，为了最大灵活性，也可以使用一个列表（长度等于时间序列的总数）。在这种情况下，T_subseq_isconstant[i]对应于第i个时间序列T[i]，列表中的每个元素可以是一个 1D 布尔numpy.ndarray，一个函数，或者None。
- Returns:
- bit_sizesnumpy.ndarray
用于表示每对多维子序列的从MDL计算出的总比特数。
- Slist
包含
k维子空间的numpy.ndarrays列表。
另见
stumpy.mstump计算多维z标准化矩阵轮廓
stumpy.mstumped计算多维z标准化矩阵轮廓，使用一个
dask/ray集群stumpy.subspace计算给定子序列索引及其最近邻索引的k维矩阵剖面子空间
示例
>>> import stumpy >>> import numpy as np >>> 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)[:, 0] >>> stumpy.mdl( ... np.array([[584., -11., 23., 79., 1001., 0., -19.], ... [ 1., 2., 4., 8., 16., 0., 32.]]), ... m=3, ... subseq_idx=motifs_idx, ... nn_idx=indices[np.arange(motifs_idx.shape[0]), motifs_idx]) (array([ 80. , 111.509775]), [array([1]), array([0, 1])])
atsc#
- stumpy.atsc(IL, IR, j)[源]#
计算锚定时间序列链（ATSC）
请注意，由于矩阵轮廓索引
IL和IR是预先计算的，这个函数与子序列归一化无关。- Parameters:
- ILnumpy.ndarray
左矩阵轮廓索引。
- IRnumpy.ndarray
右侧矩阵轮廓索引。
- jint
用于计算ATSC的索引值。
- Returns:
- outnumpy.ndarray
索引的锚定时间序列链，
j
另见
stumpy.allc计算所有链集合 (ALLC)
备注
请参见表 I
这是锚定时间序列链（ATSC）的实现。
与原论文不同，我们用一个更稳定的 for 循环替换了 while 循环。
示例
>>> import stumpy >>> import numpy as np >>> mp = stumpy.stump(np.array([584., -11., 23., 79., 1001., 0., -19.]), m=3) >>> stumpy.atsc(mp[:, 2], mp[:, 3], 1) array([1, 3])
>>> # Alternative example using named attributes >>> >>> mp = stumpy.stump(np.array([584., -11., 23., 79., 1001., 0., -19.]), m=3) >>> stumpy.atsc(mp.left_I_, mp.right_I_, 1) array([1, 3])
所有c#
- stumpy.allc(IL, IR)[源]#
计算所有链集合 (ALLC)
请注意，由于矩阵轮廓索引
IL和IR是预先计算的，这个函数与子序列归一化无关。- Parameters:
- ILnumpy.ndarray
左矩阵轮廓索引。
- IRnumpy.ndarray
右矩阵轮廓索引。
- Returns:
- Slist(numpy.ndarray)
全链集合。
- Cnumpy.ndarray
锚定时间序列链用于最长链（也称为未锚定链）。注意，当存在多个不同的链，其长度等于
len(C)时，仅返回这组中的一个链。您可以迭代所有链集合S，以查找所有其他可能的链，长度为len(C)。
另见
stumpy.atsc计算锚定时间序列链（ATSC）
备注
见表 II
与原始论文不同，我们用一个更稳定的 for 循环替换了 while 循环。
这是所有链集合（ALLC）的实现，未固定链仅仅是所有链集合中最长的一个。所有链集合和未固定链都会被返回。
所有链集，
S，作为唯一的 numpy 数组列表返回。示例
>>> import stumpy >>> import numpy as np >>> 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]))
>>> # Alternative example using named attributes >>> >>> mp = stumpy.stump(np.array([584., -11., 23., 79., 1001., 0., -19.]), m=3) >>> stumpy.allc(mp.left_I_, mp.right_I_) ([array([1, 3]), array([2]), array([0, 4])], array([0, 4]))
流动#
- stumpy.fluss(I, L, n_regimes, excl_factor=5, custom_iac=None)[源]#
计算快速低成本单元语义分割（FLUSS）用于静态数据（即批处理）
本质上，这是一个封装器，用于计算修正的弧曲线和状态位置。请注意，由于矩阵轮廓索引，
I，是预先计算的，因此此函数与子序列归一化无关。- Parameters:
- Inumpy.ndarray
感兴趣的时间序列的矩阵剖面索引。
- Lint
子序列长度设置大致为一个周期长度。 这很可能与用于计算矩阵概况和矩阵概况索引的窗口大小
m相同，但它可以不同，因为这仅用于管理边缘效应，并且与任何 IAC 或 CAC 核心计算无关。- n_regimesint
要搜索的状态数量。这比原始论文中所示的状态变化数量多一个。
- excl_factorint, default 5
政权排除区的乘数因子。
- custom_iacnumpy.ndarray, default None
一个用于修正弧线的自定义理想化弧线曲线 (IAC)。
- Returns:
- cacnumpy.ndarray
一个修正的弧线（CAC）。
- regime_locsnumpy.ndarray
政权的位置。
另见
stumpy.floss计算流数据的快速低成本在线语义分割（FLOSS）
备注
参见A节
这是快速低成本单值语义分割（FLUSS）的实现。
示例
>>> import stumpy >>> import numpy as np >>> 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]))
>>> # Alternative example using named attributes >>> >>> mp = stumpy.stump(np.array([584., -11., 23., 79., 1001., 0., -19.]), m=3) >>> stumpy.fluss(mp.P_, 3, 2) (array([1., 1., 1., 1., 1.]), array([0]))
牙线#
- stumpy.floss(mp, T, m, L, excl_factor=5, n_iter=1000, n_samples=1000, custom_iac=None, normalize=True, p=2.0, T_subseq_isconstant_func=None)[源]#
一个用于计算快速低成本在线语义分割（FLOSS）的类，适用于流数据
- Parameters:
- mpnumpy.ndarray
第一列由矩阵轮廓组成，第二列由矩阵轮廓索引组成，第三列由左侧矩阵轮廓索引组成，第四列由右侧矩阵轮廓索引组成。
- Tnumpy.ndarray
用于生成矩阵概要和在
mp中找到的矩阵概要索引的一维时间序列数据。注意，使用的是右侧的矩阵概要索引，并且右侧的矩阵概要是智能地从T动态重新计算的，而不是使用双向矩阵概要。- mint
用于计算滑动窗口质量的窗口大小。这与矩阵剖面计算中使用的窗口大小相同。有关管理边缘效应，请参见
L参数。- Lint
子序列长度设置大致为一个周期长度。 这很可能与用于计算矩阵概况和矩阵概况索引的窗口大小
m相同，但它可以不同，因为这仅用于管理边缘效应，并且与任何 IAC 或 CAC 核心计算无关。- excl_factorint, default 5
该制度排除区的乘数因子。请注意，这与用于计算矩阵轮廓的
excl_zone无关。- n_iterint, default 1000
在确定IAC贝塔分布的参数时，用于平均的迭代次数。
- n_samplesint, default 1000
在计算IAC时，每次迭代要抽取的分布样本数量。
- custom_iacnumpy.ndarray, default None
一个用于修正弧线的自定义理想化弧线曲线 (IAC)。
- normalizebool, default True
当设置为
True时，这会在计算距离之前对子序列进行z标准化- pfloat, default 2.0
用于计算闵可夫斯基距离的 p-范数。闵可夫斯基距离通常使用
p为1或2，分别对应于曼哈顿距离和欧几里得距离。当normalize == True时，此参数将被忽略。- T_subseq_isconstant_funcfunction, default None
一个自定义的用户定义函数，它返回一个布尔数组，指示在
T中的子序列是否是常量 (True)。该函数必须只接受两个参数，a，一个一维数组，以及w，窗口大小，同时可以通过使用functools.partial对用户定义函数进行柯里化来指定额外的参数。任何具有至少一个np.nan/np.inf的子序列，将自动在这个布尔数组中对应的值设置为False。
- Attributes:
cac_1d_numpy.ndarray获取更新的一维校正弧线 (CAC_1D)
P_numpy.ndarray获取更新后的矩阵剖面
I_numpy.ndarray获取更新的（右）矩阵剖面索引
T_numpy.ndarray获取更新的时间序列，T
方法
update(t)
将一个新的数据点，
t，输入到时间序列T中，然后将T中最旧的单个数据点输出。接着，更新一维校正弧曲线（CAC_1D）和矩阵轮廓。另见
stumpy.fluss计算快速低成本单元语义分割（FLUSS）用于静态数据（即，批处理）
备注
见第C节
这是快速低成本在线语义分割（FLOSS）的实现。
示例
>>> import stumpy >>> import numpy as np >>> 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.])
重复音#
- stumpy.ostinato(Ts, m, normalize=True, p=2.0, Ts_subseq_isconstant=None)[源]#
找到多个时间序列的z标准化共识模式
这是ostinato算法的原生版本的一个包装器，它找到最佳半径和一个辅助函数，该函数找到最中心的保护性模式。
- Parameters:
- Tslist
要寻找最中心的一致动机的时间序列列表。
- mint
窗口大小。
- normalizebool, default True
当设置为
True时，先对子序列进行z标准化，然后再计算距离。否则，此函数将被重定向到其对应的非标准化等效函数，该函数设置在@core.non_normalized函数装饰器中。- pfloat, default 2.0
用于计算闵可夫斯基距离的 p-范数。闵可夫斯基距离通常使用
p为1或2，分别对应于曼哈顿距离和欧几里得距离。当normalize == True时，此参数将被忽略。- Ts_subseq_isconstantlist, default None
每个时间序列的滚动窗口列表是常量，位于
Ts中。
- Returns:
- central_radiusfloat
最中心共识基序的半径。
- central_Ts_idxint
包含最中心共识主题的
Ts中的时间序列索引。- central_subseq_idxint
时间序列
Ts[central_motif_Ts_idx]中包含最中心共识特征的子序列索引。
另见
stumpy.ostinatoed找到多个时间序列的z标准化共识模式，使用一个
dask/ray集群stumpy.gpu_ostinato找到多个时间序列的z标准化共识图案，使用一个或多个GPU设备
备注
见表2
本文中提出的ostinato算法在
Ts中找到最佳半径。直观上，半径是一个子序列的最小距离，以包含来自所有其他时间序列的至少一个最近邻子序列。在Ts中的最佳半径是所有半径中的最小半径。一些数据集可能包含多个具有相同最佳半径的子序列。贪婪的Ostinato算法仅找到其中一个，这可能不是最中心的主题。在具有最佳半径的子序列中，最中心的主题是与所有其他时间序列的最近邻的平均距离最小的子序列。要找到这个中心主题，有必要通过stumpy.ostinato._get_central_motif搜索具有最佳半径的子序列。示例
>>> import stumpy >>> import numpy as np >>> 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)
持续的#
- stumpy.ostinatoed(client, Ts, m, normalize=True, p=2.0, Ts_subseq_isconstant=None)[源]#
找到多个时间序列的z标准化共识模式，使用一个
dask/ray集群这是ostinato算法的原生版本的一个包装器，它找到最佳半径和一个辅助函数，该函数找到最中心的保护性模式。
- Parameters:
- clientclient
一个
dask/ray客户端。设置dask/ray集群超出了本库的范围。请参考dask/ray分布式文档。- Tslist
要寻找最中心的一致动机的时间序列列表。
- mint
窗口大小。
- normalizebool, default True
当设置为
True时，先对子序列进行z标准化，然后再计算距离。否则，此函数将被重定向到其对应的非标准化等效函数，该函数设置在@core.non_normalized函数装饰器中。- pfloat, default 2.0
用于计算闵可夫斯基距离的 p-范数。闵可夫斯基距离通常使用
p为1或2，分别对应于曼哈顿距离和欧几里得距离。当normalize == True时，此参数将被忽略。- Ts_subseq_isconstantlist, default None
每个时间序列的滚动窗口列表是常量，位于
Ts中。
- Returns:
- central_radiusfloat
最中心共识基序的半径。
- central_Ts_idxint
包含最中心共识主题的
Ts中的时间序列索引。- central_subseq_idxint
时间序列
Ts[central_motif_Ts_idx]中包含最中心共识模式的子序列索引。
另见
stumpy.ostinato找到多个时间序列的z标准化共识模式
stumpy.gpu_ostinato找到多个时间序列的z标准化共识图案，使用一个或多个GPU设备
备注
见表2
本文提出的ostinato算法在
Ts中找到最佳半径。直观上，半径是子序列与所有其他时间序列中的至少一个最近邻子序列之间的最小距离。在Ts中最佳半径是所有半径中的最小半径。一些数据集可能包含多个具有相同最佳半径的子序列。贪婪的Ostinato算法只找到其中一个子序列，这可能不是最中心的主题。最佳半径的子序列中最中心的主题是与所有其他时间序列中的最近邻的平均距离最小的那个。为了找到这个中心主题，有必要通过stumpy.ostinato._get_central_motif搜索具有最佳半径的子序列。示例
>>> import stumpy >>> import numpy as np >>> from dask.distributed import Client >>> if __name__ == "__main__": >>> with Client() as dask_client: >>> stumpy.ostinatoed( ... dask_client, ... [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)
或者，你也可以使用 ray
>>> import ray >>> if __name__ == "__main__": >>> ray.init() >>> stumpy.ostinatoed( ... ray, ... [np.array([584., -11., 23., 79., 1001., 0., 19.]), ... np.array([600., -10., 23., 17.]), ... np.array([ 1., 9., 6., 0.])], ... m=3) >>> ray.shutdown()
gpu_ostinato#
- stumpy.gpu_ostinato(Ts, m, device_id=0, normalize=True, p=2.0, Ts_subseq_isconstant=None)#
使用一个或多个GPU设备找到多个时间序列的z标准化共识模式
这是ostinato算法的原生版本的一个包装器，它找到最佳半径和一个辅助函数，该函数找到最中心的保护性模式。
- Parameters:
- Tslist
要寻找最中心的一致动机的时间序列列表。
- mint
窗口大小。
- device_idint or list, default 0
要使用的 (GPU) 设备编号。默认值为
0。还可以提供有效设备 ID 的列表 (int) 以进行并行 GPU-STUMP 计算。可以通过执行[device.id for device in numba.cuda.list_devices()]获得所有有效设备 ID 的列表。- normalizebool, default True
当设置为
True时，先对子序列进行z标准化，然后再计算距离。否则，此函数将被重定向到其对应的非标准化等效函数，该函数设置在@core.non_normalized函数装饰器中。- pfloat, default 2.0
用于计算闵可夫斯基距离的 p-范数。闵可夫斯基距离通常使用
p为1或2，分别对应于曼哈顿距离和欧几里得距离。当normalize == True时，此参数将被忽略。- Ts_subseq_isconstantlist, default None
每个时间序列的滚动窗口列表是常量，位于
Ts中。
- Returns:
- central_radiusfloat
最中心共识基序的半径。
- central_Ts_idxint
包含最中心共识主题的
Ts中的时间序列索引。- central_subseq_idxint
时间序列
Ts[central_motif_Ts_idx]中包含最中心共识特征的子序列索引。
另见
stumpy.ostinato找到多个时间序列的z标准化共识模式
stumpy.ostinatoed找到多个时间序列的z标准化共识模式，使用一个
dask/ray集群
备注
见表2
论文中提出的持续音算法在
Ts中找出最佳半径。直观上，半径是子序列到所有其他时间序列中至少包含一个最近邻子序列的最小距离。Ts中的最佳半径是所有半径中的最小半径。有些数据集可能包含多个具有相同最佳半径的子序列。贪婪的持续音算法只能找到其中一个，这可能不是最中心的音型。具有最佳半径的子序列中最中心的音型是与所有其他时间序列中最近邻的平均距离最小的那个。要找到这个中心音型，需要通过stumpy.ostinato._get_central_motif查找具有最佳半径的子序列。示例
>>> import stumpy >>> import numpy as np >>> from numba import cuda >>> if __name__ == "__main__": ... all_gpu_devices = [device.id for device in cuda.list_devices()] ... stumpy.gpu_ostinato( ... [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, p=2.0, T_A_subseq_isconstant=None, T_B_subseq_isconstant=None)[源]#
计算任意两个时间序列之间的z标准化矩阵特征距离 (MPdist) 测量
MPdist 距离测量认为，如果两个时间序列共享许多子序列，则它们是相似的，无论匹配子序列的顺序如何。 MPdist 连接 AB-join 和 BA-join 的输出，并返回
k-th 最小值作为报告的距离。 注意，MPdist 是一种测量，而不是度量。因此，它不遵循三角不等式，但该方法具有高度的可扩展性。- Parameters:
- T_Anumpy.ndarray
要计算矩阵概况的第一次时间序列或序列。
- T_Bnumpy.ndarray
第二个时间序列或序列，用于计算矩阵简介。
- mint
窗口大小。
- percentagefloat, default 0.05
将用于报告
mpdist的距离百分比。该值介于0.0和1.0之间。- kint
指定在连接的矩阵剖面中返回的
k-th 值。当k不是None时，percentage参数将被忽略。- normalizebool, default True
当设置为
True时，先对子序列进行z标准化，然后再计算距离。否则，此函数将被重定向到其对应的非标准化等效函数，该函数设置在@core.non_normalized函数装饰器中。- pfloat, default 2.0
用于计算闵可夫斯基距离的 p-范数。闵可夫斯基距离通常使用
p为1或2，分别对应于曼哈顿距离和欧几里得距离。当normalize == True时，此参数将被忽略。- T_A_subseq_isconstantnumpy.ndarray or function, default None
一个布尔数组，用于指示在
T_A中的子序列是否是常量 (True)。或者，一个自定义的用户定义函数，该函数返回一个 布尔数组，用于指示在T_A中的子序列是否是常量 (True)。该函数必须仅接受两个参数，a，一个一维数组， 以及w，窗口大小，而其他参数可以通过使用functools.partial对用户定义函数进行柯里化来指定。任何 至少有一个np.nan/np.inf的子序列都将自动在此布尔数组中对应的值设为False。- T_B_subseq_isconstantnumpy.ndarray or function, default None
一个布尔数组，指示在
T_B中的子序列是否为常数 (True)。或者，一个自定义的用户定义函数，返回一个布尔数组，指示在T_B中的子序列是否为常数 (True)。该函数必须只接受两个参数，a，一个一维数组，以及w，窗口大小，同时可以通过对用户定义函数进行柯里化来指定额外的参数，使用functools.partial。任何至少有一个np.nan/np.inf的子序列将在该布尔数组中自动将其对应值设置为False。
- Returns:
- MPdistfloat
矩阵轮廓距离。
另见
mpdisted计算任何两个时间序列之间的z标准化矩阵剖面距离（MPdist）度量，与一个
dask/ray集群gpu_mpdist计算任何两个时间序列之间的z归一化矩阵轮廓距离（MPdist）度量，使用一个或多个GPU设备
备注
数字对象标识符: 10.1109/ICDM.2018.00119
请参见第三部分
示例
>>> import stumpy >>> import numpy as np >>> 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(client, T_A, T_B, m, percentage=0.05, k=None, normalize=True, p=2.0, T_A_subseq_isconstant=None, T_B_subseq_isconstant=None)[源]#
计算任何两个时间序列之间的z标准化矩阵轮廓距离（MPdist）度量，使用一个
dask/ray集群MPdist 距离测量认为，如果两个时间序列共享许多子序列，则它们是相似的，无论匹配子序列的顺序如何。 MPdist 连接 AB-join 和 BA-join 的输出，并返回
k-th 最小值作为报告的距离。 注意，MPdist 是一种测量，而不是度量。因此，它不遵循三角不等式，但该方法具有高度的可扩展性。- Parameters:
- clientclient
一个
dask/ray客户端。设置一个dask/ray集群超出了本库的范围。请参考dask/ray文档。- T_Anumpy.ndarray
要计算矩阵概况的第一次时间序列或序列。
- T_Bnumpy.ndarray
第二个时间序列或序列，用于计算矩阵简介。
- mint
窗口大小。
- percentagefloat, default 0.05
将用于报告
mpdist的距离百分比。该值在0.0和1.0之间。当k不为None时，此参数会被忽略。- kint
指定在连接的矩阵剖面中返回的
k-th 值。当k不是None时，percentage参数将被忽略。- normalizebool, default True
当设置为
True时，先对子序列进行z标准化，然后再计算距离。否则，此函数将被重定向到其对应的非标准化等效函数，该函数设置在@core.non_normalized函数装饰器中。- pfloat, default 2.0
用于计算闵可夫斯基距离的 p-范数。闵可夫斯基距离通常使用
p为1或2，分别对应于曼哈顿距离和欧几里得距离。当normalize == True时，此参数将被忽略。- T_A_subseq_isconstantnumpy.ndarray or function, default None
一个布尔数组，指示在
T_A中的子序列是否为常数 (True)。或者，一个自定义的用户定义函数，返回一个 布尔数组，指示在T_A中的子序列是否为常数 (True)。该函数只能接受两个参数，a，一个一维数组， 以及w，窗口大小，而可以通过柯里化用户定义函数来指定额外的参数functools.partial。任何包含至少一个np.nan/np.inf的 子序列将在此布尔数组中自动将其对应值设置为False。- T_B_subseq_isconstantnumpy.ndarray or function, default None
一个布尔数组，指示在
T_B中的一个子序列是否是常数 (True)。或者，一个自定义的用户定义函数，返回一个布尔数组，指示在T_B中的一个子序列是否是常数 (True)。该函数必须只接受两个参数，a，一个一维数组， 和w，窗口大小，而额外的参数可以通过使用functools.partial来对用户定义的函数进行柯里化。任何 至少有一个np.nan/np.inf的子序列，都会自动在这个布尔数组中对应的位置被设置为False。
- Returns:
- MPdistfloat
矩阵轮廓距离。
另见
mpdist计算任意两个时间序列之间的z标准化矩阵轮廓距离（MPdist）度量
gpu_mpdist计算任何两个时间序列之间的z归一化矩阵轮廓距离（MPdist）度量，使用一个或多个GPU设备
备注
见第三节
示例
>>> import stumpy >>> import numpy as np >>> from dask.distributed import Client >>> if __name__ == "__main__": >>> with Client() as dask_client: >>> stumpy.mpdisted( ... dask_client, ... np.array([-11.1, 23.4, 79.5, 1001.0]), ... np.array([584., -11., 23., 79., 1001., 0., -19.]), ... m=3) 0.00019935236191097894
或者，你也可以使用 ray
>>> import ray >>> if __name__ == "__main__": >>> ray.init() >>> stumpy.mpdisted( ... ray, ... np.array([-11.1, 23.4, 79.5, 1001.0]), ... np.array([584., -11., 23., 79., 1001., 0., -19.]), ... m=3) >>> ray.shutdown()
gpu_mpdist#
- stumpy.gpu_mpdist(T_A, T_B, m, percentage=0.05, k=None, device_id=0, normalize=True, p=2.0, T_A_subseq_isconstant=None, T_B_subseq_isconstant=None)#
计算任意两个时间序列之间的z标准化矩阵轮廓距离（MPdist）度量，使用一个或多个GPU设备
MPdist距离度量考虑两个时间序列是相似的，如果它们共享许多子序列，无论匹配子序列的顺序如何。MPdist连接并排序AB连接和BA连接的输出，并返回第
k个最小值作为报告的距离。注意，MPdist是一个度量而不是一个度量标准。因此，它不遵循三角不等式，但该方法具有高度可扩展性。- Parameters:
- T_Anumpy.ndarray
要计算矩阵概况的第一次时间序列或序列。
- T_Bnumpy.ndarray
第二个时间序列或序列，用于计算矩阵简介。
- mint
窗口大小。
- percentagefloat, default 0.05
用于报告
mpdist的距离百分比。该值介于0.0和1.0之间。当k不为None时，此参数将被忽略。- kint, default None
指定要返回的连接矩阵轮廓中的
k-th 值。当k不是None时，则忽略 percentage 参数。- device_idint or list, default 0
要使用的 (GPU) 设备编号。默认值为
0。还可以提供有效设备 ID 的列表 (int) 以进行并行 GPU-STUMP 计算。可以通过执行[device.id for device in numba.cuda.list_devices()]获得所有有效设备 ID 的列表。- normalizebool, default True
当设置为
True时，先对子序列进行z标准化，然后再计算距离。否则，此函数将被重定向到其对应的非标准化等效函数，该函数设置在@core.non_normalized函数装饰器中。- pfloat, default 2.0
用于计算闵可夫斯基距离的 p-范数。闵可夫斯基距离通常使用
p为1或2，分别对应于曼哈顿距离和欧几里得距离。当normalize == True时，此参数将被忽略。- T_A_subseq_isconstantnumpy.ndarray or function, default None
一个布尔数组，指示在
T_A中的子序列是否是常量 (True)。或者，一个自定义的用户定义函数，返回一个 布尔数组，指示在T_A中的子序列是否是常量 (True)。该函数必须仅接受两个参数，a，一个一维数组， 和w，窗口大小，而通过使用functools.partial归并用户定义函数 可以指定其他参数。任何包含至少一个np.nan/np.inf的子序列 将在这个布尔数组中自动将其对应值设置为False。- T_B_subseq_isconstantnumpy.ndarray or function, default None
一个布尔数组，用于指示T_B中的子序列是否为常数 (
True)。或者，一个自定义的用户定义函数，返回一个 布尔数组，指示T_B中的子序列是否为常数 (True)。该函数只能接受两个参数，a，一个一维数组， 和w，窗口大小，而额外的参数可以通过使用functools.partial来柯里化用户定义的函数。任何 包含至少一个np.nan/np.inf的子序列将在这个布尔数组中自动将其 相应的值设为False。
- Returns:
- MPdistfloat
矩阵轮廓距离。
备注
数字对象标识符: 10.1109/ICDM.2018.00119
见第三节
示例
>>> import stumpy >>> import numpy as np >>> 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
模式#
- stumpy.motifs(T, P, min_neighbors=1, max_distance=None, cutoff=None, max_matches=10, max_motifs=1, atol=1e-08, normalize=True, p=2.0, T_subseq_isconstant=None)[源]#
发现时间序列的主要模式
T一个子序列，
Q，如果在T中存在至少min_neighbor个其他子序列匹配（在排除区域外），并且距离小于或等于max_distance，则成为候选模式。请注意，在最佳情况下，返回的数组将具有形状
(max_motifs, max_matches)，并包含所有有限值。然而，实际上， 许多条件（见下文）需要满足才能使这一点成立。行数（即，motifs）的任何截断可能是由于 候选motifs不足，其匹配数大于或等于min_neighbors或者 候选motif的矩阵剖面值大于cutoff。 同样，列数（即，matches）的任何截断可能是由于 未找到足够的匹配，其距离（与对应的候选 motif）小于或等于max_distance。只有满足所有这些约束的 motifs和matches将被返回。如果您必须返回形状为
(max_motifs, max_matches)，那么您可以考虑指定更小的min_neighbors、更大的max_distance和/或更大的cutoff。例如，虽然这并不建议，但将min_neighbors=1、max_distance = np.inf和cutoff = np.inf将确保输出数组的形状为(max_motifs, max_matches)。然而，由于缺乏约束，每个图案的质量和每个匹配的质量可能会有很大差异。设置适当的条件将有助于确保结果适当约束，可能更容易解释。- Parameters:
- Tnumpy.ndarray
时间序列或序列。
- Pnumpy.ndarray
矩阵剖面的（1维）
T。在矩阵剖面是通过k > 1（即，top-k 最近邻）计算的情况下，您必须总结每个子序列的 top-k 最近邻距离为一个单一值（例如，np.mean，np.min等），然后使用该派生值作为您的P。- min_neighborsint, default 1
子序列被认为是一个模式所需的相似匹配的最小数量。默认为
1，这意味着子序列必须至少有一个相似匹配才能被认为是一个模式。- max_distancefloat or function, default None
对于候选序列
Q和一个非平凡的子序列S，max_distance是允许在Q和S之间的最大距离，以便S被视为与Q的匹配。如果max_distance是一个函数，则它必须是一个接受单个参数D的函数，在其函数签名中，它是Q和T之间的距离轮廓。如果None，这默认为np.nanmax([np.nanmean(D) - 2.0 * np.nanstd(D), np.nanmin(D)])。- cutofffloat, default None
候选模式允许拥有的最大矩阵轮廓值（距离）。如果
None，默认值为np.nanmax([np.nanmean(P) - 2.0 * np.nanstd(P), np.nanmin(P)])。- max_matchesint, default 10
返回的与模式代表相似匹配的最大数量。 结果匹配按距离排序，因此值为
10意味着返回最相似的10个子序列的索引。 如果None，则将在模式代表的max_distance之内返回所有匹配。 请注意，第一个匹配始终是每个模式的自匹配/平凡匹配。- max_motifsint, default 1
返回的最大模式数量。
- atolfloat, default 1e-8
绝对容差参数。这个值将在比较子序列之间的距离时添加到
max_distance。- normalizebool, default True
当设置为
True时，先对子序列进行z标准化，然后再计算距离。否则，此函数将被重定向到其对应的非标准化等效函数，该函数设置在@core.non_normalized函数装饰器中。- pfloat, default 2.0
用于计算闵可夫斯基距离的 p-范数。闵可夫斯基距离通常使用
p为1或2，分别对应于曼哈顿距离和欧几里得距离。当normalize == True时，此参数将被忽略。- T_subseq_isconstantnumpy.ndarray or function, default None
一个布尔数组，用于指示
T中的子序列是否为恒定 (True)。或者，一个自定义的用户定义函数，该函数返回一个 布尔数组，用于指示T中的子序列是否为恒定 (True)。该函数必须只接受两个参数，a，一个一维数组， 和w，窗口大小，而附加参数可以通过对用户自定义函数进行柯里化 使用functools.partial来指定。任何 包含至少一个np.nan/np.inf的子序列将自动 在此布尔数组中将其对应值设置为False。
- Returns:
- motif_distancesnumpy.ndarray
每个模式的每组子序列匹配对应的距离。 请注意，第一列始终对应于每个模式的自匹配/平凡匹配的距离。
- motif_indicesnumpy.ndarray
对应于每个模式的一组子序列匹配的索引。注意，第一列始终对应于每个模式的自匹配/平凡匹配的索引。
另见
stumpy.match在时间序列
T中查找查询Q的所有匹配项stumpy.mmotifs发现多维时间序列
T的顶级模式stumpy.stump计算z标准化矩阵剖面
stumpy.stumped使用
dask/ray集群计算z标准化矩阵轮廓stumpy.gpu_stump计算使用一个或多个GPU设备的z标准化矩阵轮廓
stumpy.scrump计算近似z标准化矩阵剖面
示例
>>> import stumpy >>> import numpy as np >>> 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]]))
>>> # Alternative example using named attributes >>> >>> 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.P_, ... max_distance=2.0) (array([[0. , 0.11633857]]), array([[0, 4]]))
匹配#
- stumpy.match(Q, T, M_T=None, Σ_T=None, max_distance=None, max_matches=None, atol=1e-08, query_idx=None, normalize=True, p=2.0, T_subseq_isfinite=None, T_subseq_isconstant=None, Q_subseq_isconstant=None)[源]#
在时间序列
T中查找查询Q的所有匹配项与
Q的距离小于或等于max_distance的子序列的索引，按距离排序（从低到高）。在每个出现的周围，在搜索下一个之前施加一个排除区域。- Parameters:
- Qnumpy.ndarray
查询序列。
Q不必是T的子序列。- Tnumpy.ndarray
感兴趣的时间序列。
- M_Tnumpy.ndarray, default None
时间序列的滑动均值，
T.- Σ_Tnumpy.ndarray, default None
时间序列的滑动标准差，
T.- max_distancefloat or function, default None
最大距离在
Q和子序列S之间，以便S被视为匹配。如果max_distance是一个函数，则它必须是一个接受单个参数D的函数，其函数签名中的参数是Q和T之间的距离特征（一个大小为n - m + 1的一维 numpy 数组）。如果None，则默认为np.nanmax([np.nanmean(D) - 2 * np.nanstd(D), np.nanmin(D)])（即至少将返回最近的匹配）。- max_matchesint, default None
返回的相似出现的最大数量。结果出现按距离排序，因此值为
10意味着返回最相似的10个子序列的索引。如果None，则返回所有出现。- atolfloat, default 1e-8
绝对容差参数。这个值将在比较子序列之间的距离时添加到
max_distance。- query_idxint, default None
这是时间序列中的索引位置，
T，查询子序列Q所在的位置。只有在矩阵轮廓为自连接时，才能使用query_idx，对于通过 AB 连接计算的矩阵轮廓，应该将其设置为None。如果query_idx设置为特定的整数值，则这将有助于确保自匹配将首先返回。- normalizebool, default True
当设置为
True时，先对子序列进行z标准化，然后再计算距离。否则，此函数将被重定向到其对应的非标准化等效函数，该函数设置在@core.non_normalized函数装饰器中。- pfloat, default 2.0
用于计算闵可夫斯基距离的 p-范数。闵可夫斯基距离通常使用
p为1或2，分别对应于曼哈顿距离和欧几里得距离。当normalize == True时，此参数将被忽略。- T_subseq_isfinitenumpy.ndarray
一个布尔数组，指示
T中的一个子序列是否包含一个np.nan/np.inf值（False）。当normalize=True时，此参数被忽略。- T_subseq_isconstantnumpy.ndarray or function, default None
一个布尔数组，指示在
T中是否存在一个长度等于len(Q)的子序列是常量 (True)。或者，一个自定义的用户定义函数，该函数返回一个布尔数组，指示在T中的子序列是否是常量 (True)。该函数只能接受两个参数，a，一个一维数组，以及w，窗口大小，同时可以通过使用functools.partial对用户定义函数进行柯里化来指定额外的参数。任何包含至少一个np.nan/np.inf的子序列将在这个布尔数组中自动将其对应值设置为False。- Q_subseq_isconstantnumpy.ndarray or function, default None
一个布尔数组（大小为
1），指示Q是否为常数 （True）。或者，一个自定义的用户定义函数，返回一个布尔数组，指示Q中的一个子序列是否为常数 （True）。该函数必须仅接受两个参数，a，一个一维数组，以及w，窗口大小，同时可以通过使用functools.partial对用户定义函数进行柯里化来指定其他参数。 任何至少包含一个np.nan/np.inf的子序列将自动使其对应的值在此布尔数组中设置为False。
- Returns:
- outnumpy.ndarray
第一列由子序列的距离组成，这些子序列与
Q的距离小于或等于max_distance，按距离排序（从低到高）。第二列包含T中对应的索引。
另见
stumpy.motifs发现时间序列的主要模式
Tstumpy.mmotifs发现多维时间序列
T的顶级模式stumpy.stump计算z标准化矩阵剖面
stumpy.stumped使用
dask/ray集群计算z标准化矩阵轮廓stumpy.gpu_stump计算使用一个或多个GPU设备的z标准化矩阵轮廓
stumpy.scrump计算近似z标准化矩阵剖面
示例
>>> import stumpy >>> import numpy as np >>> 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)
mmotifs#
- stumpy.mmotifs(T, P, I, min_neighbors=1, max_distance=None, cutoffs=None, max_matches=10, max_motifs=1, atol=1e-08, k=None, include=None, normalize=True, p=2.0, T_subseq_isconstant=None)[源]#
发现多维时间序列
T的最佳主题。- Parameters:
- Tnumpy.ndarray
多维时间序列或序列。
- Pnumpy.ndarray
T的多维矩阵剖面。- Inumpy.ndarray
多维矩阵轮廓索引。
- min_neighborsint, default 1
一个子序列被认为是一个基序所需的最小相似匹配数量。默认值为
1，这意味着子序列必须至少具有一个相似匹配才能被视为基序。- max_distancefloat, default None
查询子序列（一个候选基序）与
T中所有子序列之间允许的最大距离，以便被视为匹配。如果None，默认值为np.nanmax([np.nanmean(D) - 2 * np.nanstd(D), np.nanmin(D)])（即至少会返回最接近的匹配）。- cutoffsnumpy.ndarray or float, default None
多维矩阵轮廓中每个维度允许的最大矩阵轮廓值（距离）。如果
cutoffs是一个标量值，那么这个值将应用于每个维度。- max_matchesint, default 10
每个模式返回的相似匹配（最近邻居）的最大数量。第一个匹配始终是每个模式的自我/简单匹配。
- max_motifsint, default 1
返回的最大模式数量。
- atolfloat, default 1e-8
绝对容差参数。这个值将在比较子序列之间的距离时添加到
max_distance。- kint, default None
发现所有图案所需的维度数量 (
k + 1)。此值可用于进行引导搜索，或者与include一起用于约束搜索。如果k is None，则将自动使用 MDL （无约束搜索）为每个图案计算此值。- includenumpy.ndarray, default None
一个与
T中的维度对应的（从零开始的）索引列表，必须包含在受限的多维模式搜索中。- normalizebool, default True
当设置为
True时，先对子序列进行z标准化，然后再计算距离。否则，此函数将被重定向到其对应的非标准化等效函数，该函数设置在@core.non_normalized函数装饰器中。- pfloat, default 2.0
用于计算闵可夫斯基距离的 p-范数。闵可夫斯基距离通常使用
p为1或2，分别对应于曼哈顿距离和欧几里得距离。当normalize == True时，此参数将被忽略。- T_subseq_isconstantnumpy.ndarray, function, or list, default None
一个参数，用于显示时间序列的子序列在
T中是否是常数 (True) 或不是。T_subseq_isconstant可以是一个 2D 布尔numpy.ndarray或可以应用于T中每个时间序列的函数。或者，为了最大灵活性，也可以使用一个列表（长度等于时间序列的总数）。在这种情况下，T_subseq_isconstant[i]对应于第i个时间序列T[i]，列表中的每个元素可以是一个 1D 布尔numpy.ndarray、一个函数或None。
- Returns:
- motif_distances: numpy.ndarray
每个主题对应一组子序列匹配的距离。
- motif_indices: numpy.ndarray
与每个模式相对应的一组子序列匹配的索引。
- motif_subspaces: list
一个由数组组成的列表，包含每个主题的
k维子空间。- motif_mdls: list
一个包含数组的列表，这些数组包含用于查找每个模式的维度的mdl结果。
另见
stumpy.motifs找到时间序列的主要模式
Tstumpy.match在时间序列
T中查找查询Q的所有匹配项stumpy.mstump计算多维z标准化矩阵轮廓
stumpy.mstumped计算多维z标准化矩阵轮廓，使用一个
dask/ray集群stumpy.subspace计算给定子序列索引及其最近邻索引的
k维矩阵轮廓子空间stumpy.mdl计算使用最小描述长度（MDL）将一个数组压缩到另一个数组所需的位数
备注
有关
include和搜索类型的更多信息，请参阅第 IV D 和 IV E 节示例
>>> import stumpy >>> import numpy as np >>> mps, indices = stumpy.mstump( ... np.array([[584., -11., 23., 79., 1001., 0., -19.], ... [ 1., 2., 4., 8., 16., 0., 32.]]), ... m=3) >>> stumpy.mmotifs( ... np.array([[584., -11., 23., 79., 1001., 0., -19.], ... [ 1., 2., 4., 8., 16., 0., 32.]]), ... mps, ... indices) (array([[4.47034836e-08, 4.47034836e-08]]), array([[0, 2]]), [array([1])], [array([ 80. , 111.509775])])
片段#
- stumpy.snippets(T, m, k, percentage=1.0, s=None, mpdist_percentage=0.05, mpdist_k=None, normalize=True, p=2.0, mpdist_T_subseq_isconstant=None)[源]#
识别最能代表时间序列的前
k个片段，T- Parameters:
- Tnumpy.ndarray
要查找片段的时间序列或序列。
- mint
片段窗口大小。
- kint
所需的片段数量。
- percentagefloat, default 1.0
对于每个不重叠子序列的长度，
S[i]，设为m，这是S[i]（即percentage * m）的百分比，用于设置s（子子序列长度）。当percentage == 1.0时，则使用S[i]的全长来计算mpdist_vect。当percentage < 1.0时，则使用较短的子子序列长度s = min(math.ceil(percentage * m), m)来计算mpdist_vect。当s不是None时，则忽略percentage参数。- sint, default None
每个不重叠子序列的长度，
S[i]，设置为m，这实质上是子子序列的长度（即S[i]的一个较短部分）。当s == m时，使用S[i]的完整长度来计算mpdist_vect。当s < m时，使用来自每个S[i]长度为s的较短子序列来计算mpdist_vect。当s不是None时，percentage参数将被忽略。- mpdist_percentagefloat, default 0.05
将用于报告
mpdist的距离百分比。该值介于0.0和1.0之间。- mpdist_kint
指定在连接的矩阵剖面中返回的
k-th 值。当mpdist_k不为None时，mpdist_percentage参数将被忽略。- normalizebool, default True
当设置为
True时，先对子序列进行z标准化，然后再计算距离。否则，此函数将被重定向到其对应的非标准化等效函数，该函数设置在@core.non_normalized函数装饰器中。- pfloat, default 2.0
用于计算闵可夫斯基距离的 p-范数。闵可夫斯基距离通常使用
p为1或2，分别对应于曼哈顿距离和欧几里得距离。当normalize == True时，此参数将被忽略。- mpdist_T_subseq_isconstantnumpy.ndarray or function, default None
一个布尔数组，用于指示在
T中的一个子序列（长度等于len(s)）是否是常量 (True)。或者，一个自定义的用户定义函数，返回一个布尔数组，用于指示T中的一个子序列是否是常量 (True)。该函数必须仅接受两个参数，a，一个 1-D 数组，以及w，窗口大小，而其他参数可以通过使用functools.partial对用户定义的函数进行柯里化来指定。任何包含至少一个np.nan/np.inf的子序列，将自动在此布尔数组中将其对应的值设置为False。
- Returns:
- snippetsnumpy.ndarray
前
k个代码片段。- snippets_indicesnumpy.ndarray
每个前
k片段的索引位置。- snippets_profilesnumpy.ndarray
每个前
k片段的 MPdist 轮廓。- snippets_fractionsnumpy.ndarray
每个前
k片段所代表的数据比例。- snippets_areasnumpy.ndarray
每个顶级
k片段对应的曲线下的面积。- snippets_regimes: numpy.ndarray
对应于每个主要
k片段的一组状态的索引切片。第一列是（零基础）片段索引，而第二列和第三列分别对应于（包括）状态开始索引和（不包括）状态停止索引。
备注
请参见表 I
示例
>>> import stumpy >>> import numpy as np >>> 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]]))
刺激#
- stumpy.stimp(T, min_m=3, max_m=None, step=1, percentage=0.01, pre_scrump=True, normalize=True, p=2.0, T_subseq_isconstant_func=None)[源]#
一个用于计算潘矩阵轮廓的类
这基于SKIMP算法。
- Parameters:
- Tnumpy.ndarray
用于计算全景矩阵轮廓的时间序列或序列。
- min_mint, default 3
可以计算矩阵剖面的起始（或最小）子序列窗口大小。
- max_mint, default None
可以计算矩阵分析的停止（或最大）子序列窗口大小。当
max_m = None时，这个值被设置为最大允许的子序列窗口大小。- stepint, default 1
子序列窗口大小之间的步骤。
- percentagefloat, default 0.01
要计算的每个子序列窗口大小的完整矩阵 perfil 的百分比。当
percentage < 1.0时，将使用scrump算法。否则，当请求精确的矩阵 perfil 时，将使用stump算法。- pre_scrumpbool, default True
一个标志，用于指示是否在计算 SCRIMP 之前执行 PreSCRIMP 计算。如果设置为
True，这相当于计算 SCRIMP++。当percentage = 1.0时，此参数将被忽略。- normalizebool, default True
当设置为
True时，先对子序列进行z标准化，然后再计算距离。否则，此函数将被重定向到其对应的非标准化等效函数，该函数设置在@core.non_normalized函数装饰器中。- pfloat, default 2.0
用于计算闵可夫斯基距离的 p-范数。闵可夫斯基距离通常使用
p为1或2，分别对应于曼哈顿距离和欧几里得距离。当normalize == True时，此参数将被忽略。- T_subseq_isconstant_funcfunction, default None
一个自定义的用户定义函数，它返回一个布尔数组，指示在
T中的子序列是否是常量 (True)。该函数必须只接受两个参数，a，一个一维数组，以及w，窗口大小，同时可以通过使用functools.partial对用户定义函数进行柯里化来指定额外的参数。任何具有至少一个np.nan/np.inf的子序列，将自动在这个布尔数组中对应的值设置为False。
- Attributes:
- PAN_numpy.ndarray
变换后的（即，标准化、对比化、二值化和重复的）平面矩阵剖面。
- M_numpy.ndarray
子序列窗口大小的完整列表（广度优先搜索（层次）排序）.
方法
update():
使用下一个可用的（广度优先搜索（层级）排序的）子序列窗口大小计算下一个矩阵轮廓并更新全盘矩阵轮廓
另见
stumpy.stimped使用
dask/ray集群计算潘矩阵轮廓stumpy.gpu_stimp使用一个或多个GPU设备计算Pan矩阵剖面
备注
见表2
示例
>>> import stumpy >>> import numpy as np >>> 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.]])
刺激的#
- stumpy.stimped(client, T, min_m=3, max_m=None, step=1, normalize=True, p=2.0, T_subseq_isconstant_func=None)[源]#
一个用于计算Pan矩阵轮廓的类，使用
dask/ray集群这基于SKIMP算法。
- Parameters:
- clientclient
A
dask/ray客户端。设置一个dask/ray集群超出了 本库的范围。请参考dask/ray文档。- Tnumpy.ndarray
用于计算全景矩阵轮廓的时间序列或序列。
- min_mint, default 3
可以计算矩阵剖面的起始（或最小）子序列窗口大小。
- max_mint, default None
可以计算矩阵剖面的停止（或最大）子序列窗口大小。当
max_m = None时，设置为允许的最大子序列窗口大小- stepint, default 1
子序列窗口大小之间的步骤。
- normalizebool, default True
当设置为
True时，先对子序列进行z标准化，然后再计算距离。否则，此函数将被重定向到其对应的非标准化等效函数，该函数设置在@core.non_normalized函数装饰器中。- pfloat, default 2.0
用于计算闵可夫斯基距离的 p-范数。闵可夫斯基距离通常使用
p为1或2，分别对应于曼哈顿距离和欧几里得距离。当normalize == True时，此参数将被忽略。- T_subseq_isconstant_funcfunction, default None
一个自定义的用户定义函数，返回一个布尔数组，指示在
T中的一个子序列是否是常数 (True)。该函数只能接受两个参数，a，一个一维数组，以及w，窗口大小，同时可以通过使用functools.partial对用户定义函数进行柯里化来指定额外的参数。任何包含至少一个np.nan/np.inf的子序列将在这个布尔数组中自动将其对应的值设置为False。
- Attributes:
- PAN_numpy.ndarray
变换后的（即，标准化、对比化、二值化和重复的）平面矩阵剖面。
- M_numpy.ndarray
子序列窗口大小的完整列表（广度优先搜索（层次）排序）.
方法
update():
使用下一个可用的（广度优先搜索（层次）排序的）子序列窗口大小计算下一个矩阵特征，并更新全局矩阵特征。
另见
stumpy.stimp计算潘矩阵剖面
stumpy.gpu_stimp使用一个或多个GPU设备计算Pan矩阵剖面
备注
见表2
示例
>>> import stumpy >>> import numpy as np >>> from dask.distributed import Client >>> if __name__ == "__main__": ... with Client() as dask_client: ... pmp = stumpy.stimped( ... dask_client, ... 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.]])
或者，你也可以使用 ray
>>> import ray >>> if __name__ == "__main__": >>> ray.init() >>> pmp = stumpy.stimped( ... ray, ... np.array([584., -11., 23., 79., 1001., 0., -19.])) >>> ray.shutdown()
gpu_stimp#
- stumpy.gpu_stimp(T, min_m=3, max_m=None, step=1, device_id=0, normalize=True, p=2.0, T_subseq_isconstant_func=None)#
一个用于计算潘矩阵配置文件的类，可以使用一个或多个GPU设备
这基于SKIMP算法。
- Parameters:
- Tnumpy.ndarray
用于计算全景矩阵轮廓的时间序列或序列。
- min_mint, default 3
可以计算矩阵剖面的起始（或最小）子序列窗口大小。
- max_mint, default None
可以计算矩阵特征的停止（或最大）子序列窗口大小。当
m_stop = None时，设置为最大允许的子序列窗口大小。- stepint, default 1
子序列窗口大小之间的步骤。
- device_idint or list, default 0
要使用的 (GPU) 设备编号。默认值为
0。还可以提供有效设备 ID 的列表 (int) 以进行并行 GPU-STUMP 计算。可以通过执行[device.id for device in numba.cuda.list_devices()]获得所有有效设备 ID 的列表。- normalizebool, default True
当设置为
True时，先对子序列进行z标准化，然后再计算距离。否则，此函数将被重定向到其对应的非标准化等效函数，该函数设置在@core.non_normalized函数装饰器中。- pfloat, default 2.0
用于计算闵可夫斯基距离的 p-范数。闵可夫斯基距离通常使用
p为1或2，分别对应于曼哈顿距离和欧几里得距离。当normalize == True时，此参数将被忽略。- T_subseq_isconstant_funcfunction, default None
一个自定义的用户定义函数，返回一个布尔数组，该数组指示
T中的子序列是否是常数（True）。该函数必须仅接受两个参数，a，一个一维数组，以及w，窗口大小，同时可以通过使用functools.partial对用户定义的函数进行柯里化来指定其他参数。任何包含至少一个np.nan/np.inf的子序列，其对应的值将在此布尔数组中自动设置为False。
- Attributes:
- PAN_numpy.ndarray
变换后的（即，标准化、对比化、二值化和重复的）平面矩阵剖面。
- M_numpy.ndarray
子序列窗口大小的完整列表（广度优先搜索（层次）排序）.
方法
update():
使用下一个可用的（广度优先搜索（级别）有序）子序列窗口大小计算下一个矩阵轮廓并更新pan矩阵轮廓。
另见
stumpy.stimp计算潘矩阵剖面
stumpy.stimped使用
dask/ray集群计算潘矩阵轮廓
备注
见表2
示例
>>> import stumpy >>> import numpy as np >>> 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.]])