NASA C-MAPSS Overview

The ImageNet of Prognostics

ImageNet did not just give vision researchers a benchmark; it gave them a common language. Once a million labelled images existed, an entire generation of architectures became comparable, reproducible, and rankable on a single leaderboard. In prognostics that role belongs to NASA C-MAPSS — a public dataset of simulated turbofan run-to-failure trajectories released by the NASA Prognostic Center of Excellence in 2008. Almost every RUL paper of the past fifteen years quotes a number from one of its four sub-datasets.

C-MAPSS is short for Commercial Modular Aero-Propulsion System Simulation. NASA built it as a thermo-mechanical model of a high-bypass turbofan with five rotating components (fan, LPC, HPC, HPT, LPT), then ran thousands of simulated lifetimes with health-margin parameters that drift until something breaks. The result: a perfectly censoring-free supervised dataset where every engine runs all the way to failure and the failure cycle is known exactly.

What's in the Box: Files, Columns, Conventions

Each of the four sub-datasets ships as three plain-text files:

The 26 columns are always the same: 2 identifiers (engine id, cycle), 3 operational settings (altitude, Mach, throttle angle), and 21 sensors (temperatures, pressures, speeds, bleed flows). No header row, no missing values, no timestamps — just space-separated floats. Loading is a one-liner.

Labelling the training data with RUL is also a one-liner because the file is fully run-to-failure: the maximum cycle observed for each engine is its failure cycle. The training-time RUL at any earlier cycle is just $\text{RUL}_t = \max_{c}\,\text{cycle}_{c}^{(\text{this engine})} - t$.

Interactive: The Dataset at a Glance

Hover any value in the column anatomy to see what physical quantity it represents. Click an FD card to switch the histogram — FD003 and FD004 have noticeably longer tails than FD001/FD002 because their two-fault populations include slowly-degrading engines that survive 350+ cycles.

Two structural takeaways. First, the four sub-datasets are notidentical — they vary in operating conditions (1 vs 6) and fault modes (1 vs 2), which is exactly what the rest of Chapter 2 is about. Second, the failure-cycle distributions are wide enough that any model has to handle engines that fail at cycle 110 and engines that survive past 350.

Python: Parse the Raw Files in 20 Lines

Loading C-MAPSS is no harder than reading a CSV. The only quirk is that the delimiter is whitespace and the file has no header row.

1import numpy as np
2import pandas as pd
3
4# Column layout straight from the README. 26 columns, no header.
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)
10
11
12def load_train(path: str) -> pd.DataFrame:
13    """Load a C-MAPSS train_FD00x.txt into a pandas DataFrame."""
14    df = pd.read_csv(path, sep=r"\s+", header=None, names=COLUMNS)
15    # Each engine ends at its failure cycle - true RUL is trivial to label.
16    df["RUL"] = df.groupby("engine_id")["cycle"].transform("max") - df["cycle"]
17    return df
18
19
20# ----- Use it -----
21df = load_train("data/raw/train_FD002.txt")
22
23print("rows         :", len(df))
24print("engines      :", df["engine_id"].nunique())
25print("cycles min/max:", df["cycle"].min(), df["cycle"].max())
26print(df[["engine_id", "cycle", "op_set_1", "op_set_2",
27          "sensor_2", "sensor_4", "RUL"]].head(3))
28
29# rows         : 53759
30# engines      : 260
31# cycles min/max: 1 357
32#    engine_id  cycle  op_set_1  op_set_2  sensor_2  sensor_4   RUL
33# 0          1      1   34.9983    0.8400   642.55   1581.57   148
34# 1          1      2   41.9982    0.8408   642.83   1583.49   147
35# 2          1      3   24.9988    0.6218   645.89   1584.79   146

Why pandas, not pure NumPy?

We could call np.loadtxt and skip pandas entirely — it would work. We use pandas because the groupby + transform idiom turns the per-engine RUL labelling into one expressive line. The downstream PyTorch code converts back to NumPy float32 anyway.

PyTorch: A Reusable CMAPSSDataset

For training we need a Dataset that yields $(\mathbf{X}, y)$ pairs as PyTorch tensors. The class below is a thin wrapper around the NumPy logic above — same windows, same labels, same order; what changes is that DataLoader can now batch and shuffle for free.

1import numpy as np
2import pandas as pd
3import torch
4from torch.utils.data import Dataset
5
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)]
13
14
15class CMAPSSDataset(Dataset):
16    """Sliding-window (X, y) Dataset over an entire C-MAPSS train file."""
17
18    def __init__(self, csv_path: str, window: int = 30):
19        df = pd.read_csv(csv_path, sep=r"\s+", header=None, names=COLUMNS)
20        df["RUL"] = (df.groupby("engine_id")["cycle"].transform("max")
21                     - df["cycle"])
22
23        # Pre-compute the (engine_id, end_cycle) pairs that yield valid windows.
24        self.window  = window
25        self.samples = []
26        self.engines = {}
27        for eid, sub in df.groupby("engine_id"):
28            arr = sub[SENSOR_COLS].to_numpy(dtype=np.float32)
29            ruls = sub["RUL"].to_numpy(dtype=np.float32)
30            self.engines[eid] = (arr, ruls)
31            for end in range(window, len(sub) + 1):
32                self.samples.append((eid, end))
33
34    def __len__(self) -> int:
35        return len(self.samples)
36
37    def __getitem__(self, idx: int):
38        eid, end = self.samples[idx]
39        arr, ruls = self.engines[eid]
40        X = torch.from_numpy(arr[end - self.window:end])     # (W, 21)
41        y = torch.tensor(ruls[end - 1])                      # scalar RUL
42        return X, y
43
44
45# ----- Use it -----
46ds = CMAPSSDataset("data/raw/train_FD002.txt", window=30)
47print("samples:", len(ds))
48X, y = ds[0]
49print("X shape:", tuple(X.shape), "  y:", float(y))
50# samples: 46059
51# X shape: (30, 21)   y: 119.0

Other Public Prognostic Benchmarks

C-MAPSS is dominant but not alone. The benchmarks below cover similar territory in adjacent industries; everything in this book transfers to them with at most a renamed loader.

The Simulation-vs-Reality Gap

N-CMAPSS DS02 (Section 2.3) closes part of this gap by simulating real flight envelopes; the remaining gap to deployment is what motivates the Limitations chapter at the end of this book (Chapter 29).

What the benchmark gives us. A single, public, perfectly labelled dataset that lets ten different research groups directly compare their methods. That is enough to drive a decade of progress — even if the numbers do not transfer literally to a real airline.

Takeaway

• Four files, 26 columns, no surprises. 2 identifiers + 3 operational settings + 21 sensors per row, space-separated, no header.
• Labels are free. Training engines run all the way to failure, so RUL at any cycle is $\max(\text{cycle}_e) - \text{cycle}_t$ per engine.
• The four sub-datasets vary in difficulty. 1 vs 6 operating conditions, 1 vs 2 fault modes — the topic of Section 2.2.
• Loading is two helpers. load_train() for analysis and CMAPSSDataset for training. We will reuse the latter in every chapter from Part III onward.
• The simulation-reality gap is real but not the point of this book. C-MAPSS is the standardised arena. The methods built here generalise; the exact numbers do not.