mstump input versus output order

[jh72ie]

Hi all,
A totally new space for me but so glad to find it!

I have been struggling with some weird behaviours in my code - basically no matter what order the data is in that I pass to mstump, the profiles output are always in the same order. So i end up assigning the results to the wrong signals :|

By way of simple example:

import numpy as np
import stumpy

# Generate synthetic data for 3 signals, each with length 20
np.random.seed(42)
data = {
    'signalA': np.sin(np.linspace(0, 3*np.pi, 20)) + np.random.normal(0, 0.1, 20),
    'signalB': np.cos(np.linspace(0, 3*np.pi, 20)) + np.random.normal(0, 0.1, 20),
    'signalC': np.linspace(0, 1, 20) + np.random.normal(0, 0.1, 20),
}

window_size = 5

# Original order of signals
signal_names = ['signalA', 'signalB', 'signalC']
T = np.vstack([data[name] for name in signal_names])
profile_values_1, profile_indices_1 = stumpy.mstump(T, window_size)

print("Profile values in original order:")
for i, name in enumerate(signal_names):
    print(f"{name} (index {i}): {profile_values_1[i][:10]}")

# Reverse the order of signals
signal_names_reversed = list(reversed(signal_names))
T_reversed = np.vstack([data[name] for name in signal_names_reversed])
profile_values_2, profile_indices_2 = stumpy.mstump(T_reversed, window_size)

print("\nProfile values in reversed order:")
for i, name in enumerate(signal_names_reversed):
    print(f"{name} (index {i}): {profile_values_2[i][:10]}")

# Now check if profile_values_1[0] corresponds to profile_values_2[2], etc.
print("\nComparing profiles after reversing input order:")
print("profile_values_1[0] vs profile_values_2[2]:", np.allclose(profile_values_1[0], profile_values_2[2]))
print("profile_values_1[1] vs profile_values_2[1]:", np.allclose(profile_values_1[1], profile_values_2[1]))
print("profile_values_1[2] vs profile_values_2[0]:", np.allclose(profile_values_1[2], profile_values_2[0]))

produces this output:
Profile values in original order:

signalA (index 0): [0.36671318 0.38948363 0.34777324 0.48050343 0.67967935 0.91119923
 0.93443573 1.42529831 1.44014194 1.0097958 ]
signalB (index 1): [0.49955392 0.66128647 0.64602174 0.53433362 1.18977248 2.02240923
 1.44775265 1.95207666 1.65460767 1.44775265]
signalC (index 2): [1.08965024 1.19333567 0.90628887 0.63887541 1.38749961 2.66210483
 2.36757998 2.64920912 2.43201286 2.33191571]

Profile values in reversed order:

signalC (index 0): [0.36671318 0.38948363 0.34777324 0.48050343 0.67967935 0.91119923
 0.93443573 1.42529831 1.44014194 1.0097958 ]
signalB (index 1): [0.49955392 0.66128647 0.64602174 0.53433362 1.18977248 2.02240923
 1.44775265 1.95207666 1.65460767 1.44775265]
signalA (index 2): [1.08965024 1.19333567 0.90628887 0.63887541 1.38749961 2.66210483
 2.36757998 2.64920912 2.43201286 2.33191571]

Comparing profiles after reversing input order:

profile_values_1[0] vs profile_values_2[2]: False
profile_values_1[1] vs profile_values_2[1]: True
profile_values_1[2] vs profile_values_2[0]: False

Is there something I am not understanding?

Thank you!

[seanlaw]

@jh72ie Welcome to the STUMPY community and thank you for your question!

Is there something I am not understanding?

Yes, it is important/vital to understand that a "multi-dimensional matrix profile" (for N signals) using mstump is NOT the same as computing N 1-dimensional matrix profiles using stump and then stacking the results one on top of each other. For a full explanation of mstump, we recommend going through this tutorial.

Otherwise, if you don't need to know which subset of dimensions (i.e., signals) produce the smallest averaged matrix profile, then I would recommend simply using stump on each of your signals independently as it would be more performant.

[jh72ie]

I'm sorry to the a PITA, but I'm really stuck. I went back over the tutorial (amazing work - all of this) and still see behaviour I don't expect. I am not a data scientist or anything even in that vicinity so I am frustratingly without the skills I need.

But, again, what I observe is that if I change the order of the input I can not longer guarantee that the output aligns. I'm hoping this example, from the tutorial, illustrates....plus, if this is accurate, all I am looking for is some guaranteed way of aligning those - like if some internal sorting, etc. happens I just want to know what the criteria is so i can apply it outside also (if possible). Alternatively, I'd love to hear an opinion on how destructive it might be to add a wee fingerprint into the data?!

The output of this code is:
--- Original Column Order ---

0: **T1**
  Signal[:5]: [0.56511742 0.4935134  0.46934998 0.44409967 0.3730078 ]
  **MP[:5]:     [3.01630583 2.83720883 2.68261467 2.463773   2.18602394]**
1: T2
  Signal[:5]: [0.63717975 0.62941499 0.53921991 0.57767014 0.57018018]
  MP[:5]:     [3.74779845 3.58822096 3.49334978 3.40696267 3.34492199]
2: T3
  Signal[:5]: [0.74182174 0.73973106 0.71875679 0.73016901 0.75240569]
  MP[:5]:     [4.89094327 4.61814682 4.55491406 4.52876816 4.32776454]

--- Shuffled Column Order ---

0: **T3**
  Signal[:5]: [0.74182174 0.73973106 0.71875679 0.73016901 0.75240569]
  **MP[:5]:     [3.01630583 2.83720883 2.68261467 2.463773   2.18602394]**
1: T1
  Signal[:5]: [0.56511742 0.4935134  0.46934998 0.44409967 0.3730078 ]
  MP[:5]:     [3.74779845 3.58822096 3.49334978 3.40696267 3.34492199]
2: T2
  Signal[:5]: [0.63717975 0.62941499 0.53921991 0.57767014 0.57018018]
  MP[:5]:     [4.89094327 4.61814682 4.55491406 4.52876816 4.32776454]

So, you can see my issue - T3's matrix profile in the second run is actually T1's from the first run.

import pandas as pd
import numpy as np
import stumpy

print("# Load original data")
df = pd.read_csv("https://zenodo.org/record/4328047/files/toy.csv?download=1")

print("# Define subsequence length")
m = 30

print("# Compute matrix profile")
mps, _ = stumpy.mstump(df, m)

print("# Print first few values of each signal and its matrix profile")
print("\n--- Original Column Order ---")
for k, dim_name in enumerate(df.columns):
    print(f"{k}: {dim_name}")
    print(f"  Signal[:5]: {df[dim_name].values[:5]}")
    print(f"  MP[:5]:     {mps[k, :5]}")


print("# Manually re-order the columns (e.g. move T3 to front)")
manual_order = ['T3', 'T1', 'T2']
df_shuffled = df[manual_order]

print("# Run mstump on shuffled input")
mps_shuffled, _ = stumpy.mstump(df_shuffled, m)

print("\n--- Shuffled Column Order ---")
for k, dim_name in enumerate(df_shuffled.columns):
    print(f"{k}: {dim_name}")
    print(f"  Signal[:5]: {df_shuffled[dim_name].values[:5]}")
    print(f"  MP[:5]:     {mps_shuffled[k, :5]}")

[seanlaw]

it is important/vital to understand that a "multi-dimensional matrix profile" (for N signals) using mstump is NOT the same as computing N 1-dimensional matrix profiles using stump and then stacking the results one on top of each other.

Yes, I do understand that

Unfortunately, I think you are still misunderstanding the complex nature of multi-dimensional matrix profiles.

what I observe is that if I change the order of the input I can not longer guarantee that the output aligns.

For a multi-dimensional matrix profile, there is NOT/NEVER a simple one-to-one alignment between the inputs and outputs. That is, the first row of the matrix profile may not have anything to do with the first column (signal) of your dataframe (df). Similarly, the second row of the matrix profile will have little to do with only the second column (signal) of your dataframe (df). It is much much more complex than that and explained in detail in the aforementioned tutorial. If you insist on continuing to use mstump, then you must take the time to read the original published paper and go over the tutorial multiple times as it isn't straightforward. Then come back to ask more clarifying questions (not about code but about conceptual understanding) and I will try my best to explain.

Otherwise, if you expect a one-to-one mapping between each column (signal) of your dataframe (df) and each row of your matrix profile then you should just call stump (1-dimensional matrix profiles) three times (once for each of your signal columns). That is what is done in this tutorial section. For beginners, it is not recommended to to use mstump due to its much more complex result interpretation (even I had a lot of trouble with it when I first read the original paper).

[jh72ie]

Very, very, very appreciative of your answer and the time you took for me.

I am very happy to realize that my understanding is weak rather than their being any issue with the code. My brain is simply not big enough.

I just got very lost in the for "k, dim_name in enumerate(df.columns):" loop as my brain interpreted a correlation.... and switching column order made the next paragraphs pointing at the T3 irrelevance very confusing.

I shall persist. And, again, I thank you for your patience.

[seanlaw]

It's not your fault. Multi-dimensional matrix profiles are a very hard concept to grasp so please give yourself a lot of credit for wanting to persist. Not many people have gotten this far and gave up. Again, feel free to ask clarifying questions to improve your understanding.

I just got very lost in the for "k, dim_name in enumerate(df.columns):" loop

If you haven't figured it out already, k represents the "subset of dimensions (i.e., which subset of time series to pick from). So, if there are 3 time series signals, then for k == 1, it is finding one subsequence amongst the three (vertically aligned) subsequences that has the smallest nearest neighbor distance. Then it repeats this for each and every (vertically aligned) subsequence. Afterward, for k == 2, it is finding two subsequences amongst the three (vertically aligned) subsequences that has the smallest (average) nearest neighbor distance. This also gets repeated for every (vertically aligned) subsequence. Finally, you do this for k == 3 and the distances are averaged across all three dimensions.

[jh72ie]

Feeling lonely here - not knowing if what I am seeing is a problem or a lack of understanding.

To my mind, it should not matter what order the TS are entered - the MPs should be the same for the same dataset??

But, I have a strong feeling that there is something here I don't understand - in how it all works or in how the tutorial implies the relationship between T and P.

That said, I think I have found the code where the correlation breaks - its in _multi_distance_profile between the call to _multi_mass and the return D:

_print_T_to_D_correlation(T_A, D, "BEFORE")

if include is not None:
    core._apply_include(D, include)
    start_row_idx = include.shape[0]
if discords:
    D[start_row_idx:][::-1].sort(axis=0, kind="mergesort")
else:
    D[start_row_idx:].sort(axis=0, kind="mergesort")

D_prime = np.zeros(l, dtype=np.float64)
for i in range(d):
    D_prime[:] = D_prime + D[i]
    D[i, :] = D_prime / (i + 1)

if excl_zone is not None:
    core.apply_exclusion_zone(D, query_idx, excl_zone, np.inf)

_print_T_to_D_correlation(T_A, D, "AFTER")

....

with that data used in the mstump tutorial:

BEFORE_T1: 0.5651174160530583...min D[0] index: 435...value: 3.1947053598034487
BEFORE_T2: 0.6371797479205732...min D[1] index: 89...value: 3.2604684360557505
**BEFORE_T3: 0.7418217407048813...min D[2] index: 1...value: 2.652670172192173**

AFTER_T1: 0.5651174160530583...min D[0] index: 453...value: 3.016305830216488
AFTER_T2: 0.6371797479205732...min D[1] index: 485...value: 3.7477984468672787
**AFTER_T3: 0.7418217407048813...min D[2] index: 314...value: 4.890943267441674**

Now, running mstump on shuffled input (T3 swapped to the first column)

**BEFORE_T3: 0.7418217407048813...min D[0] index: 1...value: 2.652670172192173**  -- all good so far
BEFORE_T1: 0.5651174160530583...min D[1] index: 435...value: 3.1947053598034487
BEFORE_T2: 0.6371797479205732...min D[2] index: 89...value: 3.2604684360557505

**AFTER_T3: 0.7418217407048813...min D[0] index: 453...value: 3.016305830216488**  -- now T3 is correlated to the T1 of the first run
AFTER_T1: 0.5651174160530583...min D[1] index: 485...value: 3.7477984468672787
AFTER_T2: 0.6371797479205732...min D[2] index: 314...value: 4.890943267441674

Can anyone of you fine folks out there set me straight? I would be extremely grateful.