AI4Manufacturing/CMAPSS

C-MAPSS turbofan — is this engine due for a shop visit? (reasoning track)

Part of the AI4Manufacturing FORGE corpus (Category C, task T-C1), and the corpus's first run-to-failure dataset. Every family before this one asks is this machine faulty right now; this one asks how much longer can it stay in service, so a record is not a snapshot of a machine but a whole machine's history up to a moment.

Each record is one engine's exhaust-gas-temperature margin trend: the vertical axis is how many degrees Rankine hotter than itself-when-new that engine now runs at the same flight condition, and the horizontal axis is its service history so far, as a percentage, never as cycles. A dashed line marks where the fleet calls an engine in. That is the line an airline actually watches — a worn gas path runs hotter at the same throttle setting, and when the margin is used up the engine comes off wing.

Records: 3787 over 709 engines (splits {'train': 2799, 'test': 988}); labels {'on_wing': 2642, 'shop_visit_due': 1145}; by subset {'FD001': 527, 'FD002': 1388, 'FD003': 537, 'FD004': 1335}.

The axis, which is the whole design

On run-to-failure data an absolute time axis is the answer. Its length is how far the engine has run, and on a record drawn to the end of life it is the total life — so a reader who cannot tell a turbine from a toaster can measure the answer off the picture with a ruler. This is the failure mode that ruins the whole family, so it is closed twice and then measured.

Closed. render_trend resamples every record onto a fixed 400 positions spanning 0-100% of the history shown, so neither the axis nor the plotted point density encodes a number of cycles, and the tool has no parameter that puts cycles back. One vertical range is shared by every record, because per-record autoscaling would make a flat healthy engine fill the frame exactly like a worn one. The record ends at a cycle drawn uniformly over the engine's life, so the axis is the whole life only in the rare record that reaches it. The degradation-onset marker is drawn as a fraction of the width; the renderer raises on anything outside [0, 1].

Measured, every run, by fitting each quantity's best single cut on the training engines and scoring it on the held-out ones. The majority baseline is 0.654.

quantity	best threshold	20-bin majority	what it is
current_cycle_absolute	0.790	0.790	how many cycles the plotted history spans -- what an ABSOLUTE horizontal axis would hand a reader for free. NOT on the image.
total_life_absolute	0.657	0.640	the engine's whole life in cycles. NOT on the image, and worth nothing anyway because the snapshot ends at a random cycle.
cycles_since_onset_absolute	0.744	0.744	how many cycles since degradation started, in cycles. NOT on the image.
onset_fraction	0.645	0.672	where the onset marker sits as a fraction of the width. IS on the image -- and scores at the majority baseline, which is why drawing it is safe.
egt_margin_deg_r	0.909	0.909	the curve's current height, the evidence the plot exists to show. IS on the image.

Read the total-life row against the current-cycle row. Everything that needs an absolute scale is worth about eight points of free accuracy and none of it reaches the image; total life is worth nothing even in principle, because the record stops at a random cycle; and the one relative quantity that is drawn — the onset marker — scores at the baseline, which is why drawing it is safe.

The residual channel, stated. The drawn curve is smoothed over a fixed 21 CYCLES, so the wavelength of its residual wiggle in relative units is 21/(cycles shown) and in principle traces how long the history is. It is not the remaining life: total life alone scores at the majority baseline (see the probe), so recovering the width would not recover the answer.

Flight condition first, degradation second

T50 sits 357 degR apart between the hottest and coldest flight condition while a whole run to failure raises it by 18-27 degR at a fixed one -- the condition shift is about 15x the lifetime signal. The same engine flies six different altitude / Mach / throttle combinations on two of the four subsets, and a reading compared across them measures which condition the engine is in, not how worn it is. So the flight condition is separated before any indicator is computed, and every reference level below is per condition.

The method is operating_state_segmentation: the three setting columns rounded to integers; the distinct tuples ARE the states (exact and order-independent, unlike clustering the same columns).

subset	conditions per the archive readme	measured
FD001	1	1
FD002	6	6
FD003	1	1
FD004	6	6

Why T50 is on the vertical axis

A trend plot has one vertical axis, so something has to pick what goes on it, and picking by eye is how a converter ends up fitting the render to the answer. hi_select scores all 21 sensors on Coble & Hines' three prognostic-parameter metrics over the training engines only, before any image is drawn:

candidate	monotonicity	trendability (min over engines)	prognosability
T50	0.271	0.452	0.825
Ps30	0.325	0.393	0.815
T30	0.184	0.353	0.790
htBleed	0.197	0.341	0.787
T24	0.177	0.355	0.791
BPR	0.263	0.401	0.378

T50 wins, and that it wins is the point: it is also the sensor an airline actually watches. It is the turbine-outlet temperature, the gas-path station closest to exhaust gas temperature, and EGT margin is the number that decides when an engine comes off wing. trendability is the minimum over engines rather than the mean, which is what eliminates the speed channels: Nc is as monotone as T50 and useless anyway, because on at least one engine it does not track age at all.

Zero is this engine's own as-new level, not the fleet's: the median of its first cycles once the flight-condition reference is removed. The archive's readme is the reason — "each engine starts with different degrees of initial wear and manufacturing variation which is unknown to the user" — so a fleet zero would read one engine's build tolerance as wear.

Degrees, not sigma. The usual recipe would z-score within each condition. Measured, it is not better here: the at-failure margins cluster at cv 0.183 in sigma against 0.194 in degR, which does not pay for losing a unit a flight deck actually shows.

What the query states, and why

An engine has no characteristic fault frequency to look up: it simply runs hotter as it wears. So the question cannot be which fault and has to be has this crossed the limit, with the limit stated — it is an operator's convention, not something derivable from the picture. What the image supplies is the number to compare against it. The threshold in every query is read from the raw provenance, so the text and the calibration cannot drift apart. reasoning is empty here; the CMAPSS-annotated sibling fills it.

What was filtered. 404 of 4191 records are held back: those where the stated rule, applied to the image, does not land on the gold label. A record where it does not would teach a model to compute correctly and then ignore its own arithmetic. The filter uses gold, so this track is easier than the raw dataset, and what it removes is the boundary — engines sitting near 8.0 degR.

Rig

Machine	high-bypass turbofan, simulated in NASA's C-MAPSS engine model
Run	every engine from new to failure; one row per flight cycle, not per second
Sensors	21 gas-path readings (T2, T24, T30, T50, P30, Nf, Nc, Ps30, BPR, W31, ...)
Flight condition	3 setting columns (altitude, Mach, throttle-resolver angle)
Fault modes	HPC degradation (FD001/FD002); HPC and fan degradation (FD003/FD004)
Population	709 run-to-failure engines, 128-543 cycles each (median 207)
Labels	none shipped for the training trajectories: remaining life is the engine's own total minus the current cycle

Schema (7-field unified record)

field	here
query	the paraphrased question; it also states the decision rule in degR
image	the rendered PNG, bytes embedded
annot	shop_visit_due or on_wing
reasoning	None — filled by the annotation pass, not here
cate / task	C / T-C1 (signal condition classification)
metadata	JSON: every number behind the verdict, separately — the current margin, this engine's as-new level, the shop-visit line, the distance to it, the fleet's at-failure margin, the local slope in both units, the degradation onset, the flight-condition states with their reference levels and their cycle counts in the window, and the provenance quantities (current cycle, total life, remaining life) that are not on the image

Splits

train / test = by engine, never by snapshot. Six snapshots of one engine share its baseline, its manufacturing variation and its trajectory.

Provenance & calibration

Produced by forge_agent/examples/cmapss_turbofan/convert.py (forge_agent 4c4873f9c7) and packaged by forge_model/CMAPSS/convert_cmapss.py (forge_model 9448e33334).

Gold. shop_visit_due = remaining life <= 55 cycles. Chosen by us, from label-only properties; see caveat 3.

The measurement in the query. The current EGT margin — the right-hand end of the curve. The line, 8.0 degR, is fitted on the 527 TRAIN engines only and applied blind to the 182 held-out ones, the same discipline as PHM2010's newton cut and ITSC's ellipticity floor.

split	engines	records	rule agrees with gold	majority baseline	missed due	false due
test	182	1080	91.5%	65.4%	59	33	held out
train	527	3111	90.0%	67.0%	195	117	train

The line is not where engines die. The training fleet reaches 22.457 degR before it quits — about three times the line — and that number is in every record's metadata, because an airline removes an engine while it still has margin. A line drawn where engines actually fail would fire only in the last few cycles.

Split. Six snapshots of one engine share its baseline, its manufacturing variation and its trajectory; a per-snapshot split puts the same engine on both sides. The key is sha256(cmapss-split-v1, subset, unit) % 4 == 0 -> test, so it survives a re-run, a re-ordering and a change of numpy.

Query pool. Domain turbofan_egt, trend 30 paraphrases.

Caveats

1. The data is simulated. No engine was run to failure to produce it; the readings come out of NASA's C-MAPSS model with noise added. Nothing here is evidence about a real engine's sensor behaviour, and a model trained on it has learned a simulator's idea of degradation.
2. The horizontal axis is relative and always will be. See The axis above, including the measured leak probes and the one residual channel we could not remove.
3. The 55-cycle horizon is ours. Label-only: it puts the class balance near the corpus's ~1:2 convention, and it is not fitted to any detector. The archive ships no threshold, no pass/fail column and no limit of any kind — it was regression on remaining cycles. We do not publish a regression target, because the image carries no absolute time by construction, so a cycle count cannot be read off it.
4. The published track is easier than the raw data, and the boundary is what is missing. The filter below uses gold. There is no unfiltered perception sibling to carry the dropped records, so the raw manifest in forge_agent is the only place they survive.
5. The archive's own test_FD00* trajectories are not here. They stop before failure, so they carry no at-failure margin — the quantity the fleet line is defined against — and their remaining life is only recoverable from a separate vector. 709 run-to-failure engines were enough; mixing two populations into one fleet reference was not worth 706 more.
6. No perception track, and it is a measurement. The four perception renderers need a sampling rate and this family has none -- one reading per flight cycle. A spectrogram tops out at 0.5 cycles^-1 and comes back blank, a scalogram draws texture over a frequency axis that does not exist, and the reshaped render pads 95% zeros into a black square. The waveform render would draw this same trend with an ABSOLUTE axis -- i.e. the leak.
7. The archive readme is wrong about FD004. FD004 ships 249 training engines, not the 248 the readme states. Several sensor columns are also constant from end to end, which the readme does not mention; both are recorded in provenance.json under readme_vs_measured.
8. One rig, one simulator, two fault modes. This says nothing about transfer to another engine type, a real fleet, or a failure mode the model does not contain.

Source & license

NASA Prognostics Center of Excellence, Turbofan Engine Degradation Simulation Data Set (C-MAPSS). Rig and protocol: A. Saxena, K. Goebel, D. Simon and N. Eklund, Damage Propagation Modeling for Aircraft Engine Run-to-Failure Simulation, 1st International Conference on Prognostics and Health Management (PHM08), Denver CO, October 2008. The four train_FD00*.txt trajectories are used; the archive's truncated test_FD00* trajectories are not — see caveat 5. The data is simulated. No real engine was run to failure to produce it.