FD001 to FD004: Single vs. Multi-Condition

One Weather, Six Weathers

Imagine training a self-driving car only on a single sunny day in California. It will be a beautiful driver — until you ship it to Norway in December. The model never had a chance to learn that the world has regimes: weather, terrain, traffic density. Drop it into a regime it has never seen and behaviour collapses.

That same regime structure is the central difficulty of multi-condition prognostics. A jet engine's sensors at 35,000 ft cruising at Mach 0.84 produce values that have nothing to do with the same engine sitting at sea-level idle. If you mix readings from both regimes into a single normalisation pipeline, the “degradation signal” you actually learn is mostly the regime label, not the real wear.

The 2x2 Difficulty Matrix

The four C-MAPSS sub-datasets exhaust the cross product of two binary axes: operating conditions (1 vs 6) and fault modes (1 vs 2). The matrix below is what makes them a small but well-chosen benchmark suite.

Every paper that claims a result on C-MAPSS quotes per-subset RMSE; the delta between FD001 and FD002 measures how robust the model is to operating regimes; the delta between FD002 and FD004 measures robustness to multiple failure modes. Most published methods do well on FD001/FD003 and badly on FD002/FD004 — which is exactly the regime where the GABA / GRACE benefit is largest in the paper's Table II.

What an Operating Condition Looks Like

An operating condition is a single point in the joint distribution of altitude, Mach number, and throttle resolver angle — the three operational-setting columns we met in Section 2.1. C-MAPSS's six canonical conditions are the centroids reported by the original NASA documentation:

The key fact: cycle-by-cycle, an engine in FD002 jumps between these six regimes. There is no smooth transition. A row labelled cycle 5 might be at sea-level idle; cycle 6 might be at 35,000 ft. Sensors respond to both regime change AND degradation — and unless we factor out the regime first, the degradation signal stays buried under it.

Interactive: The Conditions Space

Click between the four cards. FD001 / FD003 collapse to a single point in the (altitude, Mach) plane; FD002 / FD004 fan out into six visually distinct clusters. Marker size encodes throttle — you can see condition 3 (descent) sit slightly south of condition 2 because of the lower TRA.

Two seconds of slider-clicking communicates what fifty pages of prose cannot: FD002 and FD004 are not slightly harder than FD001; they live in a qualitatively different geometry.

Python: Discover Conditions With k-Means

We never get the condition labels for free in real-world data — they have to be re-discovered from the op_set columns. k-means with k=6 nails it on C-MAPSS because the canonical centroids are well-separated. Total cluster sizes are nearly balanced (8869-9115 rows per condition).

[[34.99, 0.84, 100.0], [41.99, 0.84, 100.0], [24.99, 0.62, 60.0]]

1import numpy as np
2import pandas as pd
3from sklearn.cluster import KMeans
4
5COLUMNS = (
6    ["engine_id", "cycle"]
7    + [f"op_set_{i}" for i in range(1, 4)]
8    + [f"sensor_{i}" for i in range(1, 22)]
9)
10OP_COLS = ["op_set_1", "op_set_2", "op_set_3"]
11
12
13def discover_conditions(df: pd.DataFrame, n_conditions: int) -> np.ndarray:
14    """Cluster the op_set columns into n_conditions discrete regimes."""
15    if n_conditions == 1:
16        # Single condition - everyone gets label 0.
17        return np.zeros(len(df), dtype=np.int64)
18
19    ops = df[OP_COLS].to_numpy()
20    km = KMeans(n_clusters=n_conditions, n_init=10, random_state=0).fit(ops)
21    return km.labels_
22
23
24# ----- Use it on FD002 -----
25df = pd.read_csv("data/raw/train_FD002.txt", sep=r"\s+",
26                 header=None, names=COLUMNS)
27df["condition"] = discover_conditions(df, n_conditions=6)
28
29# Verify the cluster sizes are roughly balanced
30print(df["condition"].value_counts().sort_index())
31# 0    8896
32# 1    8869
33# 2    8989
34# 3    8900
35# 4    8990
36# 5    9115
37# Name: condition, dtype: int64
38
39# Inspect the centroids
40ops = df[OP_COLS].to_numpy()
41km = KMeans(n_clusters=6, n_init=10, random_state=0).fit(ops)
42for i, c in enumerate(km.cluster_centers_):
43    print(f"cond {i}: alt={c[0]:5.1f}  Mach={c[1]:.3f}  TRA={c[2]:5.1f}")
44# cond 0: alt=  0.0   Mach=0.000   TRA=100.0
45# cond 1: alt= 10.0   Mach=0.250   TRA=100.0
46# cond 2: alt= 20.0   Mach=0.700   TRA=100.0
47# cond 3: alt= 25.0   Mach=0.620   TRA= 60.0
48# cond 4: alt= 35.0   Mach=0.840   TRA=100.0
49# cond 5: alt= 42.0   Mach=0.840   TRA=100.0

How robust is k-means here?

Very. The op_set centroids are separated by altitudes ranging from 0 to 42 kft — an order of magnitude larger than the noise inside any cluster. Misclassification rate against the synthetic ground truth is below 0.1% for n_init ≥ 5. Robust convergence is the reason every C-MAPSS preprocessing pipeline uses k-means rather than a more involved Gaussian-mixture model.

PyTorch: A Condition-Aware Dataset

Extend Section 2.1's CMAPSSDataset with the condition column. __getitem__ now returns a three-tuple $(\mathbf{X},\,\mathbf{c},\, y)$ — sensor window, condition sequence, RUL target.

1import numpy as np
2import pandas as pd
3import torch
4from torch.utils.data import Dataset
5from sklearn.cluster import KMeans
6
7COLUMNS = (
8    ["engine_id", "cycle"]
9    + [f"op_set_{i}" for i in range(1, 4)]
10    + [f"sensor_{i}" for i in range(1, 22)]
11)
12SENSOR_COLS = [f"sensor_{i}" for i in range(1, 22)]
13OP_COLS     = [f"op_set_{i}" for i in range(1, 4)]
14
15
16class CMAPSSDatasetByCondition(Dataset):
17    """Sliding-window CMAPSS dataset that also returns the operating
18    condition for every sample. Reuses Section 2.1's structure plus a
19    k-means clustering on the op_set columns."""
20
21    def __init__(self, csv_path: str, n_conditions: int = 6, window: int = 30):
22        df = pd.read_csv(csv_path, sep=r"\s+", header=None, names=COLUMNS)
23        df["RUL"] = (df.groupby("engine_id")["cycle"].transform("max")
24                     - df["cycle"])
25
26        # Discover conditions
27        if n_conditions > 1:
28            km = KMeans(n_clusters=n_conditions, n_init=10,
29                        random_state=0).fit(df[OP_COLS].to_numpy())
30            df["condition"] = km.labels_.astype(np.int64)
31        else:
32            df["condition"] = 0
33
34        self.window  = window
35        self.samples = []
36        self.engines = {}
37        for eid, sub in df.groupby("engine_id"):
38            arr  = sub[SENSOR_COLS].to_numpy(dtype=np.float32)
39            ruls = sub["RUL"].to_numpy(dtype=np.float32)
40            cond = sub["condition"].to_numpy(dtype=np.int64)
41            self.engines[eid] = (arr, ruls, cond)
42            for end in range(window, len(sub) + 1):
43                self.samples.append((eid, end))
44
45    def __len__(self) -> int:
46        return len(self.samples)
47
48    def __getitem__(self, idx: int):
49        eid, end = self.samples[idx]
50        arr, ruls, cond = self.engines[eid]
51        X     = torch.from_numpy(arr [end - self.window:end])  # (W, 21)
52        c_seq = torch.from_numpy(cond[end - self.window:end])  # (W,) condition labels
53        y     = torch.tensor(ruls[end - 1])                     # scalar RUL
54        return X, c_seq, y
55
56
57# ----- Use it -----
58ds = CMAPSSDatasetByCondition("data/raw/train_FD002.txt",
59                              n_conditions=6, window=30)
60X, c_seq, y = ds[0]
61print("X    :", tuple(X.shape))
62print("c_seq:", tuple(c_seq.shape), c_seq[:5].tolist())
63print("y    :", float(y))
64# X    : (30, 21)
65# c_seq: (30,) [5, 5, 3, 4, 0]
66# y    : 119.0

Multi-Condition Problems Outside RUL

The structural pattern “features are dominated by regime, not by the signal of interest” appears all over machine learning. Every row of the table below has been solved with the same per-condition normalisation idea we apply in Chapter 6.

The book's machinery — cluster, normalise per cluster, train on the residual signal — transfers to all of these without a single domain-specific change.

The Mixing Trap

Section 6.2 walks through exactly how this fails empirically and shows the per-condition fix. For now the mental rule is: normalise inside a regime, not across regimes.

Why this whole chapter exists. Multi-condition data is the regime where every method discussed in this book differentiates itself. On FD001 / FD003 most methods bunch together; on FD002 / FD004 the gradient-aware objectives pull ahead by 28-76% on NASA score and 18-40% on RMSE.

Takeaway

• Four sub-datasets, two binary axes. 1 vs 6 operating conditions, 1 vs 2 fault modes. FD002 and FD004 are where the research benefit lives.
• An operating condition is a point in (altitude, Mach, TRA). Six canonical centroids span the realistic flight envelope from idle to top-of-climb.
• k-means with k=6 recovers the conditions in one line. n_init=10, random_state=0, .fit on the op_set columns. Misclassification below 0.1%.
• The condition label belongs in the dataset, not the model. CMAPSSDatasetByCondition emits a per-cycle condition sequence alongside every input window.
• The mixing trap is real. Single mean / std across regimes turns the “model” into a regime classifier in disguise.