Sliding Window Sequence Construction

Learning Objectives

By the end of this section, you will:

1. Understand why sliding windows are needed for variable-length time series
2. Master the actual research implementation of sequence construction with RUL calculation
3. Handle train vs test data correctly with different RUL computation strategies
4. Assign labels correctly to each extracted window
5. Track unit IDs for proper per-engine evaluation

Why This Matters: Neural networks require fixed-size inputs, but engine trajectories vary from 128 to 362 cycles. The _build_sequences_and_labels method is the heart of our preprocessing—it extracts sliding windows, computes piecewise RUL, and tracks unit IDs for proper evaluation.

Why Sliding Windows?

Engine trajectories in C-MAPSS have variable lengths:

The Fixed-Input Requirement

Our model expects tensors of shape $(B, T, D)$:

• $B$: Batch size (samples per batch)
• $T = 30$: Sequence length (fixed window size)
• $D = 17$: Feature dimension

Sliding windows solve this by extracting fixed-length subsequences from each trajectory, converting variable-length engines into uniform training samples.

Window Intuition

1Trajectory: [c₁, c₂, c₃, c₄, c₅, c₆, c₇, c₈, c₉, c₁₀] (10 cycles)
2Window size: L = 3
3Stride: S = 1
4
5Window 1: [c₁, c₂, c₃]  → RUL label from c₃
6Window 2: [c₂, c₃, c₄]  → RUL label from c₄
7Window 3: [c₃, c₄, c₅]  → RUL label from c₅
8...
9Window 8: [c₈, c₉, c₁₀] → RUL label from c₁₀
10
11Total: 8 windows from 10-cycle trajectory

Window Construction Algorithm

Mathematical Definition

For a trajectory of length $T$, window size $L$, and stride $S = 1$, the number of windows is:

Window $i$ (0-indexed) spans cycles:

And the RUL label is taken from the last cycle in the window:

Research Implementation

This is the actual _build_sequences_and_labels method from our research code. It handles both training and test data with different RUL computation strategies.

Engine with 200 cycles: cycle 100 has RUL = min(125, 200-100) = 100

RUL_FD001.txt has 100 values, one per test engine

If true RUL at end is 50, and max_cycle=100, then at cycle 80: RUL = 50 + (100-80) = 70

Window covering cycles 50-79 gets RUL label from cycle 79

1def _build_sequences_and_labels(self, df, feat_cols, L):
2    """Build sequences and labels from normalized data"""
3    df_sorted = df.sort_values(['unit','cycle']).reset_index(drop=True)
4
5    # Calculate RUL
6    if self.train:
7        # For training data: RUL = max_cycle - current_cycle
8        max_cycle = df_sorted.groupby('unit')['cycle'].transform('max')
9        df_sorted['RUL'] = (max_cycle - df_sorted['cycle']).clip(lower=0, upper=125)
10    else:
11        # For test data: Load true RUL values from file
12        rul_path = self.data_dir / f'RUL_{self.dataset_name}.txt'
13        if not rul_path.exists():
14            raise FileNotFoundError(f"RUL file not found: {rul_path}")
15
16        rul_values = pd.read_csv(rul_path, sep='\\s+', header=None).values.flatten()
17
18        # Calculate RUL for each test sample
19        df_sorted['RUL'] = 0
20        for i, (unit_id, group) in enumerate(df_sorted.groupby('unit', sort=False)):
21            max_cycle_test = group['cycle'].max()
22            true_rul_at_end = rul_values[i]
23
24            # RUL for each cycle = true_rul_at_end + (max_cycle - current_cycle)
25            rul_values_unit = true_rul_at_end + (max_cycle_test - group['cycle'].values)
26            rul_values_unit = np.clip(rul_values_unit, 0, 125)
27            df_sorted.loc[group.index, 'RUL'] = rul_values_unit
28
29    X_list, y_list, uid_list = [], [], []
30    for uid, g in df_sorted.groupby('unit'):
31        g = g.reset_index(drop=True)
32        feats = g[feat_cols].values
33        rul = g['RUL'].values
34        if len(g) < L:
35            continue
36        for i in range(len(g) - L + 1):
37            X_list.append(feats[i:i+L])
38            y_list.append(rul[i+L-1])
39            uid_list.append(int(uid))  # Track unit ID for each window
40
41    X = np.stack(X_list, axis=0) if X_list else np.empty((0,L,len(feat_cols)), dtype=np.float32)
42    y = np.array(y_list, dtype=np.float32) if y_list else np.empty((0,), dtype=np.float32)
43    unit_ids = np.array(uid_list, dtype=np.int32) if uid_list else np.empty((0,), dtype=np.int32)
44    return X, y, unit_ids

Key Implementation Details

RUL Calculation Strategy

A critical distinction exists between how RUL is computed for training vs test data:

Training Data

For training data, we know the exact failure point (last cycle in trajectory):

The clip(lower=0, upper=125) implements the piecewise linear assumption: during early operation, RUL is capped at 125.

Test Data

For test data, the true RUL at the final cycle is provided in RUL_FD00X.txt files:

This back-propagates the ground truth through the entire test trajectory.

Window Parameters

Window Size (L = 30)

Rationale for L = 30:

• Captures ~30 flight cycles of context (approximately one month of operation)
• Long enough to see degradation trends, short enough for efficiency
• All training engines have at least 128 cycles, so 30-cycle windows always fit
• Consistent with prior work, enabling fair comparison

Sample Count Analysis

Summary

In this section, we explored the actual research implementation of sliding window sequence construction:

1. Why windows: Convert variable-length trajectories to fixed-size inputs (30, 17)
2. Research implementation: _build_sequences_and_labels() handles both train and test data
3. RUL calculation: Different strategies for training (max_cycle - current) vs test (back-propagate from ground truth)
4. Label assignment: RUL at window end (last timestep)
5. Unit ID tracking: Essential for per-engine evaluation metrics

Looking Ahead: We now have sequences and labels. The next section implements the complete PyTorch Dataset class that wraps this preprocessing and integrates with DataLoader for training.

With sequence construction understood, we are ready to implement the PyTorch data pipeline.