SlidingWindow for classification tasks

[JakobPuehringerIpercept]

Hello,
First of all thank you for this awesome package, I just discovered it yesterday, so I just start out diving into everything.

The task I want to currently execute is a classification task, where a huge time series needs to be splitted into segments, so each segment can be classified individually. For this, applying a sliding window seems reasonable, though I am having troubles to map the labels to each segment.
More specifically, suppose I have a multivariate timeseries, where each time step is labelled. How to merge the most dominant label (maximal number of occurrences) within a window to the segment. Furthermore, is there a way to alllow different thresholds for labels within a window, so that if a "None" label is dominant, there is still a chance to take the next most dominant label as the label for a segment (e.g. based on relative occurence of x within the window).

I see that there is a parameter y_func, but it seems confusing to me, how a function is applied on the time series.

Thanks in advance :)

[oguiza]

Please, take a look at the documentation: https://timeseriesai.github.io/tsai/data.preparation.html?q=SlidingWindow#slidingwindow
There are some examples of how y_func can be used

[JakobPuehringerIpercept]

Thanks for the answer. I played around a little with y_func, but it does not give me the capabilities to achieve my task i think.
I found a workaround using SlidingWindow and then doing some postprocessing, though this has the downside of not being very intuitive.

Basically I did the following:

window_length = 2
stride = window_length
horizon = window_length

X, y= SlidingWindow(window_len=window_length, stride=stride, horizon=horizon, get_y='Label')(df)

This creates non_overlapping segments of size window_length, where the labels for a segment are all the labels from the next segment. Then I prepend the original labels to y from the first segment. Next, I need to collapse the labels for each segment to one label with the following function:

def merge_labels(labels, ratio=0.2):
  size = len(labels)
  # threshold for labels of interest
  min_occ = int(size*ratio)
  # count labels
  unique, counts = np.unique(labels, return_counts=True)

  # label 0 is in this usecase 'uninteresting'
  label = 0
  count_dict = dict(zip(unique, counts))
  # remove uninteresting label
  count_dict.pop(label, None)
  
  # if the remaining count dictionary is empty, then all labels are 0, therefore the collapsed label is also 0
  if len(count_dict) == 0:
      return label
  
  # get most dominant label which is not 0
  max_occ = max(count_dict.values())
  # if the dominant label surpasses the threshold, then it is the label for the segment
  if max_occ > min_occ:
      label = max(count_dict, key=count_dict.get)

  return label

It would be nice though to consider this usecase in SlidingWindow, as it is needed for many classification tasks, where each segment only has one label that is derived from the underlying collection of labels.

Correct me if I'm wrong, that this is currently not possible with the parameters in the current implementation of SlidingWindow. Also, this might not be the most beatiful implementation to solve the problem, but it did the job :)

[oguiza]

Why don't you pass the func you want to use to y_func as a SlidingWindow argument?

[JakobPuehringerIpercept]

Ok, I tried to work again with the parameter y_func and I found out the mistake i made. I misinterpreted the horizon paramater as it says in the docs number of future datapoints to predict. This caused me some confusion, as also negative values are allowed, which means not only future datapoints are to be considered with this parameter.

The updated code therefore:

def y_func_test(x, ratio=0.2):
    processed_labels = np.array([])
    for labels in x:
        size = len(labels)
        min_occ = int(size*ratio)
        unique, counts = np.unique(labels, return_counts=True)
        # 0 as uninteresting label
        label = 0
        count_dict = dict(zip(unique, counts))
        
        count_dict.pop(label, None)

        # if segment only holds uninteresting labels
        if len(count_dict) == 0:
            processed_labels = np.append(processed_labels, label)
        else:
            max_occ = max(count_dict.values())
            # check relative occurence of most dominant interesting label
            if max_occ > min_occ:
                label = max(count_dict, key=count_dict.get)

            processed_labels = np.append(processed_labels, label)
    return processed_labels

Next, SlidingWindow can be applied with a negative value for horizon, to keep the labels unshifted:

window_length = 5
stride = window_length
# negative horizon for unshifted labels within a segment
horizon = -window_length

# df holds feature values at column idx 0-2
X, y= SlidingWindow(window_len=window_length, stride=stride, horizon=horizon, get_x=[0, 1, 2], get_y='Label', y_func=y_func_test)(df_test)