AI4Manufacturing/CMAPSS

C-MAPSS turbofan — how much life is left? (multi-channel, multiple choice)

Part of the AI4Manufacturing FORGE corpus (Category C, task T-C1). Each record is one engine's history so far, read on 5 gas-path channels at once — T50, Ps30, T30, htBleed, T24 — stacked as panels over a single relative horizontal axis. Every panel shows how far that reading has drifted from what this same engine gave when new at the same flight condition, oriented so that up means more worn, with three dashed fleet lines cutting it into four bands. The question is a four-way multiple choice over how many cycles the engine has left.

The rule is positional and needs no arithmetic: read which band the current value sits in on each panel, then take the middle of those readings. That is why the lines carry no numbers — what matters is where the curve is, not what the axis says.

Records: 2778 over 704 engines (splits {'train': 2038, 'test': 740}); labels {'80 to 130 cycles': 688, '40 to 80 cycles': 639, 'fewer than 40 cycles': 885, 'more than 130 cycles': 566}; by subset {'FD001': 393, 'FD002': 1025, 'FD003': 397, 'FD004': 963}.

This release replaces an earlier one under this same repo id. If you pulled AI4Manufacturing/CMAPSS before this version, the copy you have has a defect described in full below, and its answer space is different — you cannot carry results across. Please re-pull.

What this replaces, and why

The previous release under this id was one T50 panel, two classes (shop_visit_due / on_wing), remaining life <= 55 cycles. It is withdrawn for a reason worth stating plainly, because anyone holding a copy of it should know.

The defect. The drawn curve was smoothed over a fixed 21 CYCLES. Drawn on a relative axis, the residual wiggle then has wavelength 21 / (cycles in the record), so how many cycles the record spans is legible from how rough the line looks. The horizontal axis carried no cycle numbers, which was the point of it — but the texture of the line did. On run-to-failure data that matters: how far the engine has already run is most of the answer.

Measured on that release's own binary task, on its own held-out engines (each quantity given its best twenty-bin vote fitted on the training engines):

quantity	held-out accuracy
always pick the largest class	0.6537
the absolute cycle count — which that card called NOT on the image	0.7898
the drawn curve's roughness — which is on the image	0.7861
the T50 margin itself, the evidence the plot existed to show	0.9093

The two middle rows are the finding: the roughness and the absolute cycle count score within four thousandths of each other, because they are very nearly the same quantity — Spearman +0.994 between them, and a twenty-bin predictor reads the cycle count's quartile off the roughness alone at 0.898 against 0.25 chance. That figure is for the single panel the previous release actually drew; averaged over five panels the same probe reads 0.936, which is the number quoted in The axis below.

Replicated independently, from the published PNGs rather than from the code (pull the images from the Hub, extract the main curve by colour, take second differences -- no access to the producing code): Spearman +0.769, and the cycle-count quartile recovered at 0.530 against 0.25 chance — a coarser roughness estimate than the one above, hence lower, but the same finding. The control in that check is the important one: roughness against total life reaches only +0.152, because random truncation really does block total life, so what leaked is current_cycle, not total_life_cycles -- the previous card's probe table was right about total life and wrong about the current cycle.

So the previous card was wrong about its own image. The previous card listed current_cycle first in its record-level not_visible_in_image field, and its probe table described the absolute cycle count as NOT on the image. On its own rendering that was not true.

What this release does instead. Three changes: a fixed 400 output positions per panel; a piecewise-linear fit on 5 knots of the relative axis instead of a moving average over a fixed number of cycles — smoothing in proportion to the record rather than over a fixed count is the change that closes this at the root — and one y-range per channel for the whole dataset, never autoscaled. Spearman between roughness and the absolute cycle count goes from +0.994 to -0.220, and the quartile probe from 0.898 to 0.342 against 0.25 chance. That is not zero, and this card does not pretend otherwise — see What is left below for how much remains, what it is worth beside the real evidence, and why it is left in place rather than bought out with synthetic noise.

What it cost, in full. The rendering change itself cost nothing — the proportional fit scores better than the previous recipe on the stated rule (0.685 against 0.669) as well as on every leak column. The drawn curves are a faithful rendering of the measurement: nothing synthetic is added to them. What the release does cost is the task change:

1. The reasoning-track filter now removes 34% of the population instead of 10%, because a four-way rule is wrong more often than a two-way one — and it removes the middle bands preferentially, so the published class balance is more skewed than the raw one: the largest class goes from 0.2713 of the raw population to 0.3186 of what ships.
2. Some of the length channel survives, by choice rather than by oversight. It is measured in What is left.

And the question changed. The previous release asked a two-way serviceability verdict; this one asks a four-way choice among remaining-life bands. The answer space is different, so numbers measured on the old release do not transfer to this one, and a model fine-tuned on it will not evaluate against this without retraining.

The task

Four ordered bands of remaining life, listed in the question and answered by their text:

option	records (before filtering)
more than 130 cycles	972
80 to 130 cycles	1143
40 to 80 cycles	1049
fewer than 40 cycles	1027

The edges are ours, and the rule for them was fixed before the run: quartiles of the TRAIN snapshots' remaining life, rounded to the nearest 10 cycles. The training quartiles came out at [41.0, 81.0, 127.0] cycles, giving [40, 80, 130]. That rule is label-only — the edges look at no signal and are fitted to no detector — and it lands the four classes within a few percent of equal, which is what makes a multiple choice worth asking. The archive ships no bands, no threshold and no limit of any kind; it was scored as regression on remaining cycles.

We do not publish a regression target. The image carries no absolute time by construction, so a cycle count cannot be read off it.

The option order is shuffled per record — sorted by sha256(cmapss-mc-options-v1, record id, option index). Ordered bands presented in order are a position prior; a model that learns 'the answer is usually the second one' never looks at the picture. After filtering, the answer lands in position 0: 691, 1: 692, 2: 709, 3: 686 (largest share 0.255), so position is not a shortcut. annot is the option's text, never a letter, so it does not depend on the order at all.

The baseline to quote is 'always pick the largest class': 0.271 on the held-out engines before filtering, 0.319 on what is published.

The axis, which is still the whole design

On run-to-failure data an absolute time axis is the answer — its length is how far the engine has run. The first cut of this dataset closed that by drawing on a relative axis, and disclosed one leftover: the curve was smoothed over a fixed number of cycles, so its residual wiggle had wavelength window / cycles shown. That disclosure was too generous to itself. Measured here, the drawn curve's roughness tracked the absolute record length at Spearman +0.998 and a twenty-bin predictor read the length's quartile off it at 0.936 against 0.25 chance. A relative axis with an absolute-length texture on it is an absolute axis wearing a hat.

So this version closes it rather than disclosing it:

1. fixed 400 output positions, so neither axis nor point density encodes cycles
2. a piecewise-linear fit on 5 fixed knots of the RELATIVE axis -- smoothing in PROPORTION to the record rather than over a fixed number of cycles, which is the change that closes this at the root
3. a fixed 25-point smoothing in the relative domain, the identical operator for every record
4. one ylim per channel for the whole dataset; no autoscaling
5. the snapshot ends at a cycle drawn uniformly over the engine's life

After that, the same probe reads 0.342 against 0.25 chance.

The whole table, each quantity given its best twenty-bin vote fitted on the training engines and scored on the held-out ones. Always picking the largest class scores 0.271.

quantity	held-out accuracy	what it is
current_cycle_absolute	0.471	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.376	the engine's whole life in cycles. NOT on the image.
cycles_since_onset_absolute	0.448	how many cycles since degradation started. NOT on the image.
drawn_curve_roughness	0.323	how rough the DRAWN curves are -- the only trace of the record's length left on the canvas, and the channel relative_fit exists to close. IS on the image.
drawn_curve_roughness_top_channel	0.349	the same, read off the top panel alone. IS on the image.
panel_T50_current_value	0.603	the current value of the T50 panel -- intended evidence, not a leak. IS on the image.
panel_Ps30_current_value	0.647	the current value of the Ps30 panel -- intended evidence, not a leak. IS on the image.
panel_T30_current_value	0.560	the current value of the T30 panel -- intended evidence, not a leak. IS on the image.
panel_htBleed_current_value	0.569	the current value of the htBleed panel -- intended evidence, not a leak. IS on the image.
panel_T24_current_value	0.580	the current value of the T24 panel -- intended evidence, not a leak. IS on the image.

Constant by construction. Every record has 5 panels and 400 points per panel. Both are the same for every record, so neither can carry information; no probe is possible or needed.

What is left, which is not nothing

The drawn curve's roughness still carries some trace of how many cycles the record spans. Stated, not claimed away: a twenty-bin predictor reads the cycle count's quartile off the roughness at 0.342 against 0.25 chance, and predicts the answer itself at 0.323 against a 0.2713 baseline — about 5 points of free accuracy.

Set that against what the panels are for: the best single panel's current value is worth 0.647 and the stated rule 0.685, about 41 points over the same baseline. A model has a path worth about forty-one points over the baseline sitting in plain sight; there is no reason for it to learn to estimate how jittery a line looks for five. Closing the rest costs synthetic noise in a picture of a measurement, and 2.6 points of the rule.

And it may not even be reachable. An independent check downsampled the images and found the probe itself stopped working below 448 px, so it could not separate 'the texture is gone' from 'the probe is gone'. Whether a VLM can use this at its real input resolution is unevidenced in BOTH directions -- which is an argument for not paying a certain cost against it, not an argument that it is harmless.

The three renderings, measured side by side — same snapshots, same engines, same four-way gold, all scored on the held-out engines:

drawn how	spearman(roughness, current cycle)	roughness -> cycle quartile (chance 0.25)	roughness -> the answer (baseline 0.2713)	the stated rule (baseline 0.2713)
previous release: moving average over a fixed 21 CYCLES	+0.998	0.936	0.482	0.669
SHIPS: piecewise-linear fit on 5 knots of the relative axis	-0.220	0.342	0.323	0.685
declined: the same, plus seeded noise equalisation	+0.042	0.298	0.323	0.659

The fit alone removes most of the channel and costs nothing -- it is strictly better than the previous recipe on every column, the rule included. Equalisation removes a little more and costs 2.6 points of the rule, paid in synthetic noise.

Which channels, and why more than one

The channels are chosen by hi_select against floors written down before the run ({'min_monotonicity': 0.1, 'min_prognosability': 0.5, 'min_trendability': 0.2}), on Coble & Hines' three prognostic-parameter metrics, measured on the training engines only. Whatever clears them is what gets drawn. Exactly 5 did:

candidate	monotonicity	trendability (min over engines)	prognosability
T50	0.271	0.452	0.825	drawn
Ps30	0.325	0.393	0.815	drawn
T30	0.184	0.353	0.790	drawn
htBleed	0.197	0.341	0.787	drawn
T24	0.177	0.355	0.791	drawn
BPR	0.263	0.401	0.378	rejected
W31	0.150	0.286	0.386	rejected
Nc	0.305	0.007	0.396	rejected

The rejected ones fail on prognosability — they drift with age, but the fleet does not arrive at failure anywhere near a common value, so no single fleet line could be drawn on them.

Every panel is sign-checked against age ({'Ps30': 1.0, 'T24': 1.0, 'T30': 1.0, 'T50': 1.0, 'htBleed': 1.0}): the rule is positional and compares five panels, so every panel has to mean the same thing: higher = more worn. On this fleet all five already rise with wear, so nothing needed inverting -- but the check runs every time, because a panel pointing the wrong way would silently drag the middle reading.

Do the extra panels earn their place?

	train	held out
the rule on the top panel only	0.620	0.591
the rule on all panels (middle reading)	0.655	0.685
always pick the largest class	0.273	0.271

Each panel on its own, held out:

panel	alone
Ps30	0.649
T24	0.603
T50	0.591
htBleed	0.581
T30	0.558

The extra panels are worth about +0.095 on the held-out engines over the best single panel. Had they not been worth anything, this section would say so: the single-channel first cut was not wrong, it was leaving something on the table.

Flight condition first, degradation second

The same engine flies six different altitude / Mach / throttle combinations on two of the four subsets, and T50 sits 357 degR apart between the hottest and the coldest of them 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. So the flight condition is separated before any channel is computed (operating_state_segmentation: the three setting columns rounded to integers, and the distinct tuples are the states — one on FD001/FD003, six on FD002/FD004, matching the archive readme). Each channel's zero is then this engine's own as-new level, because the readme states every engine starts with a different unknown initial wear.

Schema (7-field unified record)

field	here
query	the paraphrased question; it states the rule and lists the four options in this record's shuffled order
image	the multi-panel PNG, bytes embedded
annot	the winning option's text, e.g. 40 to 80 cycles — never a letter or an index, so it cannot depend on the order
reasoning	None — filled by the annotation pass, not here
cate / task	C / T-C1
metadata	JSON: per panel, the current value, the three fleet lines, which band it reads, the distance to the next line, the channel's orientation and noise level, its own y-range and its solo accuracy; plus the option list before and after shuffling, the answer's position, the band edges, 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. Key: sha256(cmapss-split-v1, subset, unit) % 4 == 0. The raw population is {'test': 182, 'train': 527} engines; 704 of them still have at least one record after the filter below.

Provenance

Produced by forge_agent/examples/cmapss_turbofan_mc/convert.py (forge_agent 0574e0e25d) and packaged by forge_model/CMAPSS-MC/convert_cmapss_mc.py (forge_model 9448e33334). Query pool: domain turbofan_egt_mcq, 30 paraphrases. Full numbers, including every leak probe and the channel scores of all 21 candidates, are in provenance.json.

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. A model trained on this has learned a simulator's idea of degradation.
2. The bands are ours — see the task section. The archive ships no thresholds.
3. The filter is heavy here, and it uses gold. 1413 of 4191 records are held back because the stated rule, read off the image, does not land on the gold band — 34% of the population, against 10% for the binary first cut, simply because a four-way rule is wrong more often than a two-way one. What it removes is the boundary: engines whose panels disagree, and engines sitting near a fleet line. The published track is therefore easier than the raw dataset, and there is no unfiltered sibling — forge_agent's manifest is the only place the dropped records survive.
4. A residual length channel survives, deliberately. The drawn roughness still reads the record's cycle count's quartile at 0.342 against 0.25 chance and the answer at 0.323 against a 0.271 baseline. It could be closed by equalising the drawn noise; that was measured, and declined, because it buys five points of shortcut back with synthetic noise in a picture of a measurement. See What is left.
5. Five panels of one engine are not five independent opinions. They are five gas-path stations on the same machine, driven by the same degradation; they agree far more often than not. The middle-reading rule is a robustness device, not an ensemble.
6. No perception track. The four perception renderers need a sampling rate; this family gives one reading per flight cycle and has none.
7. 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.
8. The archive readme is wrong about FD004 — it ships 249 training engines, not 248.

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, PHM08, Denver CO, October 2008. The four train_FD00*.txt trajectories are used. The data is simulated.