Fixed #1077 Add extra check for window size

stumpy/core.py

@@ -554,11 +554,12 @@ def get_max_window_size(n):
     return max_m
 
 
-def check_window_size(m, max_size=None):
+def check_window_size(m, max_size=None, excl_zone=None, last_start_index=None):
     """
     Check the window size and ensure that it is greater than or equal to 3 and, if
     `max_size` is provided, ensure that the window size is less than or equal to the
-    `max_size`
+    `max_size`. Furthermore, if `excl_zone` is provided, then it will also check if the
+    window size is too large and could lead to meaningless results.
 
     Parameters
     ----------
@@ -568,6 +569,13 @@ def check_window_size(m, max_size=None):
     max_size : int, default None
         The maximum window size allowed
 
+    excl_zone : int, default None
+        The exclusion zone. If provided, then the `last_start_index` must also be
+        provided.
+
+    last_start_index : int, default None
+        The start index of last subsequence.
+
     Returns
     -------
     None
@@ -589,6 +597,37 @@ def check_window_size(m, max_size=None):
     if max_size is not None and m > max_size:
         raise ValueError(f"The window size must be less than or equal to {max_size}")
 
+    if excl_zone is not None:
+        if last_start_index is None:  # pragma: no cover
+            raise ValueError(
+                "last_start_index must be provided when excl_zone is not None"
+            )
+
+        # Check if subsequneces have non-trivial neighbours
+
+        # Case 1:
+        # There is at least one subsequence with non-trivial neighbour
+        # i.e. For AN `i`, there exists at least one `j` such that |i - j| > excl_zone
+        # In this case, we just need to consider the two subsequences that are furthest
+        # apart from each other.
+        # In other words: |last_start_index - 0| > excl_zone
+        cond_1 = (last_start_index - 0) > excl_zone
+
+        # Case 2:
+        # Check if each single subsequence has at least one non-trivial neighbor
+        # i. e. For ANY `i`, there exists at least one `j` such that |i - j| > excl_zone
+        # In this case, we need to consider the subseuqence whose furthest neighbour is
+        # the shortest compared to other subsequences.
+        # In other words: |ceil(last_start_index / 2) - 0| > excl_zone
+        cond_2 = (math.ceil(last_start_index / 2) - 0) > excl_zone
+
+        if not cond_1 or not cond_2:
+            msg = (
+                f"The window size, 'm = {m}', may be too large and could lead to "
+                + "meaningless results. Consider reducing 'm' where necessary"
+            )
+            warnings.warn(msg)
+
 
 @njit(fastmath=config.STUMPY_FASTMATH_TRUE)
 def _sliding_dot_product(Q, T):

stumpy/stump.py

@@ -711,20 +711,25 @@ def stump(
             "For multidimensional STUMP use `stumpy.mstump` or `stumpy.mstumped`"
         )
 
-    core.check_window_size(m, max_size=min(T_A.shape[0], T_B.shape[0]))
-    ignore_trivial = core.check_ignore_trivial(T_A, T_B, ignore_trivial)
-
     n_A = T_A.shape[0]
     n_B = T_B.shape[0]
     l = n_A - m + 1
 
-    excl_zone = int(np.ceil(m / config.STUMPY_EXCL_ZONE_DENOM))
-
+    ignore_trivial = core.check_ignore_trivial(T_A, T_B, ignore_trivial)
     if ignore_trivial:
+        excl_zone = int(np.ceil(m / config.STUMPY_EXCL_ZONE_DENOM))
         diags = np.arange(excl_zone + 1, n_A - m + 1, dtype=np.int64)
     else:
+        excl_zone = None
         diags = np.arange(-(n_A - m + 1) + 1, n_B - m + 1, dtype=np.int64)
 
+    core.check_window_size(
+        m,
+        max_size=min(T_A.shape[0], T_B.shape[0]),
+        excl_zone=excl_zone,
+        last_start_index=l - 1,
+    )
+
     P, PL, PR, I, IL, IR = _stump(
         T_A,
         T_B,

tests/test_core.py

@@ -192,6 +192,36 @@ def test_check_max_window_size():
             core.check_window_size(m, max_size=3)
 
 
+def test_check_window_size_excl_zone_case1():
+    # To ensure warning is raised if there is no subsequence
+    # with non-trivial neighbor
+    T = np.random.rand(64)
+    m = 60
+    last_start_index = len(T) - m
+
+    excl_zone = int(np.ceil(m / config.STUMPY_EXCL_ZONE_DENOM))
+
+    with pytest.warns(UserWarning):
+        core.check_window_size(
+            m, max_size=len(T), excl_zone=excl_zone, last_start_index=last_start_index
+        )
+
+
+def test_check_window_size_excl_zone_case2():
+    # To ensure warning is raised if there is at least one subsequence
+    # that has no non-trivial neighbor
+    T = np.random.rand(64)
+    m = 48
+    last_start_index = len(T) - m
+
+    excl_zone = int(np.ceil(m / config.STUMPY_EXCL_ZONE_DENOM))
+
+    with pytest.warns(UserWarning):
+        core.check_window_size(
+            m, max_size=len(T), excl_zone=excl_zone, last_start_index=last_start_index
+        )
+
+
 @pytest.mark.parametrize("Q, T", test_data)
 def test_njit_sliding_dot_product(Q, T):
     ref_mp = naive_rolling_window_dot_product(Q, T)