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, n=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,9 @@ def check_window_size(m, max_size=None):
     max_size : int, default None
         The maximum window size allowed
 
+    n : int, default None
+        The length of the time series.
+
     Returns
     -------
     None
@@ -589,6 +593,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 n is not None:
+        # The following code raises warning if there is at least one subsequence
+        # with no non-trivial neighbor. The following logic does not check if
+        # a subsequence has a non-finite value.
+
+        # Logic: For each subsequnece `S_i = T[i : i + m]`, its neighbor `S_j`
+        # is non-trivial if |i - j| > excl_zone. Let's denote `S_jmax` as
+        # the neighbor that is furthest away from `S_i` (index-wise). So:
+        # |i - jmax| >= |i - j|
+        # Therefore, if `S_i` has at least one non-trivial neighbor, then `S_jmax` is
+        # definitely a non-trivial neighbor. Because:
+        # |i - jmax| >= |i - j| > excl_zone
+        # To ensure ALL subsequences have at least one non-trivial neighbor, we can just
+        # check the subsequence `S_i` that has the minimum |i - jmax|. Let's denote `d`
+        # as that minimum value. So, if d > excl_zone, then:
+        # For any `i` and its corresponding `jmax`, we have:
+        # |i - jmax| >= d > excl_zone
+
+        # The minimum |i - jmax| is achieved when `S_i` is the middle subsequence,
+        # i.e. i == int(ceil((n - m) / 2)), and its corresponding jmax is 0. Hence,
+        # we just need to make sure the following inequity is satisfied:
+        # |int(ceil((n - m) / 2)) - 0| > excl_zone`
+
+        excl_zone = int(math.ceil(m / config.STUMPY_EXCL_ZONE_DENOM))
+        if (int(math.ceil((n - m) / 2)) - 0) <= excl_zone:
+            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,18 +711,17 @@ 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
 
+    ignore_trivial = core.check_ignore_trivial(T_A, T_B, ignore_trivial)
     excl_zone = int(np.ceil(m / config.STUMPY_EXCL_ZONE_DENOM))
-
-    if ignore_trivial:
+    if ignore_trivial:  # self-join
+        core.check_window_size(m, max_size=n_A, n=n_A)
         diags = np.arange(excl_zone + 1, n_A - m + 1, dtype=np.int64)
-    else:
+    else:  # AB-join
+        core.check_window_size(m, max_size=min(n_A, n_B))
         diags = np.arange(-(n_A - m + 1) + 1, n_B - m + 1, dtype=np.int64)
 
     P, PL, PR, I, IL, IR = _stump(

tests/test_core.py

@@ -192,6 +192,26 @@ 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
+
+    with pytest.warns(UserWarning):
+        core.check_window_size(m, max_size=len(T), n=len(T))
+
+
+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
+
+    with pytest.warns(UserWarning):
+        core.check_window_size(m, max_size=len(T), n=len(T))
+
+
 @pytest.mark.parametrize("Q, T", test_data)
 def test_njit_sliding_dot_product(Q, T):
     ref_mp = naive_rolling_window_dot_product(Q, T)