Three Deployment Regimes (Accuracy / Safety / Balanced)

The Delivery Truck, the 787, the Cruise Ship

A FedEx tractor breaks down? Annoying, expensive, but the parcels reach their destination a day late and the country keeps turning. A 787 turbofan fails in flight? An entirely different conversation: passenger lives, an emergency landing, an AOG event whose cost reaches eight figures. A cruise ship six days at sea? Somewhere between the two: the operator wants high availability, but a stranded vessel is closer to the 787 end of the spectrum than the FedEx end.

Each of these operators has identical fleet management software and identical RUL prediction models — but they want different things from those models. The trucking company wants minimum RMSE so it can schedule its maintenance shop tightly. The airline wants minimum NASA score so its model never surprises a flight crew. The cruise line wants somewhere in between. The same neural network, three different deployment regimes.

One Combined Cost, One Knob

Formalise the choice with a single safety weight $w \in [0, 1]$. Define the combined operational cost of a model as

$J(\theta;\, w) = (1 - w)\,\widetilde{\mathrm{RMSE}}(\theta) + w\,\widetilde{\mathrm{NASA}}(\theta),$

where $\widetilde{\mathrm{RMSE}}$ and $\widetilde{\mathrm{NASA}}$ are min-max-normalised versions of the two metrics over a candidate set of models. Three special cases:

The same knob can be expressed inside the training loss too — making it a hyper-parameter you can choose at deployment time without retraining the architecture. We will see exactly that in the PyTorch code below.

Interactive: The Frontier with Real Numbers

The chart below is the actual table from the paper — the multi-condition (FD002 + FD004) average RMSE and NASA scores, across five random seeds, for ten methods. The three green dots are the three proposed models. The red dot is DKAMFormer, the previous published state of the art. Drag the safety-weight slider to switch regimes; the model that minimises $J(\theta; w)$ is highlighted with a black ring.

Three observations the chart makes plain. First, the three proposed models each own a regime: AMNL wins at $w \le 0.05$, GABA wins around $w = 0.5$, GRACE wins at $w \ge 0.75$. Second, the dashed green line is the Pareto frontier — every model on it is non-dominated, every model off it is irrelevant for any choice of $w$. Third, DKAMFormer (the red dot) lies dramatically outside the frontier, dominated on both axes by every model in the framework. That single observation is Chapter 26's headline result.

Three Models, One Per Regime

The mapping the rest of the book commits to:

Python: A Regime-Selectable Loss

Concretise the knob in code. Three synthetic models stand in for AMNL, GABA, and GRACE; one combined-cost function ranks them under any regime weight.

1import numpy as np
2
3# ----- A regime-selectable scalar cost -----
4# RMSE  : root-mean-square error  (symmetric, accuracy)
5# NASA  : asymmetric exp score    (safety)
6# J(w) = (1 - w) * RMSE_norm + w * NASA_norm   — single knob
7def nasa_score(p, a):
8    d = p - a
9    return np.exp(-d / 13.0) - 1.0 if d < 0 else np.exp(d / 10.0) - 1.0
10
11
12def rmse(pred, actual):
13    return float(np.sqrt(np.mean((pred - actual) ** 2)))
14
15
16def total_nasa(pred, actual):
17    return float(sum(nasa_score(p, a) for p, a in zip(pred, actual)))
18
19
20def combined_cost(pred, actual, w: float,
21                  rmse_lo: float, rmse_hi: float,
22                  nasa_lo: float, nasa_hi: float) -> float:
23    """Min-max-normalised mix of RMSE and NASA. Lower is better.
24
25    w = 0  → pure RMSE ranking (accuracy regime)
26    w = 1  → pure NASA ranking (safety regime)
27    w = ½  → balanced regime
28    """
29    r = (rmse(pred, actual)        - rmse_lo) / (rmse_hi - rmse_lo)
30    n = (total_nasa(pred, actual)  - nasa_lo) / (nasa_hi - nasa_lo)
31    return (1 - w) * r + w * n
32
33
34# ----- Three "models" matching the paper's three deployment regimes -----
35np.random.seed(0)
36n = 100
37actual = np.random.uniform(20, 120, n)
38
39np.random.seed(0)
40amnl  = actual + np.random.normal(0,  6, n)   # accuracy-first - tight, unbiased
41np.random.seed(0)
42gaba  = actual + np.random.normal(-2, 6, n)   # slight safety bias
43np.random.seed(0)
44grace = actual + np.random.normal(-3, 5, n)   # tighter safety bias
45
46# Min/max envelope over our three candidate models
47all_rmse = [rmse(p, actual)       for p in (amnl, gaba, grace)]
48all_nasa = [total_nasa(p, actual) for p in (amnl, gaba, grace)]
49rmse_lo, rmse_hi = min(all_rmse), max(all_rmse)
50nasa_lo, nasa_hi = min(all_nasa), max(all_nasa)
51
52for name, p in [("AMNL  (accuracy)", amnl),
53                ("GABA  (balanced)", gaba),
54                ("GRACE (safety)  ", grace)]:
55    for label, w in [("[email protected]", 0.0), ("[email protected]", 0.5), ("[email protected]", 1.0)]:
56        j = combined_cost(p, actual, w, rmse_lo, rmse_hi, nasa_lo, nasa_hi)
57        print(f"{name}  {label} = {j:.3f}", end="    ")
58    print()
59# AMNL  (accuracy)  [email protected] = 0.000    [email protected] = 0.500    [email protected] = 1.000
60# GABA  (balanced)  [email protected] = 0.605    [email protected] = 0.302    [email protected] = 0.000
61# GRACE (safety)    [email protected] = 1.000    [email protected] = 0.500    [email protected] = 0.000

Reading the table

Each row is one model; each column is one regime. The lowest number in each column is the model the operator should ship under that regime. AMNL wins column [email protected]; GABA wins column [email protected]; GRACE wins column [email protected]. Three independent winners is the compact statement of why the book trains three separate objectives.

PyTorch: The Same Switch as a Module

The same regime knob lives naturally in the training loss. The module below is a foreshadowing of the GRACE loss in Chapter 21 — one knob, smooth interpolation, GPU-friendly, autograd-friendly.

1import torch
2import torch.nn as nn
3import torch.nn.functional as F
4
5class RegimeAwareLoss(nn.Module):
6    """One module, three regimes. The single knob `safety_weight` controls
7    the mix between MSE (accuracy-first) and an asymmetric NASA-style loss
8    (safety-first). At 0.0 the loss is pure MSE; at 1.0 it is pure NASA.
9    """
10
11    def __init__(self,
12                 safety_weight: float = 0.5,
13                 early_scale: float = 13.0,
14                 late_scale:  float = 10.0):
15        super().__init__()
16        if not 0.0 <= safety_weight <= 1.0:
17            raise ValueError("safety_weight must be in [0, 1]")
18        self.w = safety_weight
19        self.early_scale = early_scale
20        self.late_scale  = late_scale
21
22    def forward(self, pred: torch.Tensor, actual: torch.Tensor) -> torch.Tensor:
23        # MSE branch — symmetric, accuracy-first
24        mse  = F.mse_loss(pred, actual)
25        # Asymmetric NASA branch — safety-first
26        d    = pred - actual
27        early = torch.exp(-d / self.early_scale) - 1.0
28        late  = torch.exp( d / self.late_scale ) - 1.0
29        nasa = torch.where(d < 0, early, late).mean()
30        # Convex combination — one knob
31        return (1.0 - self.w) * mse + self.w * nasa
32
33
34# ----- Use it three times, once per regime -----
35torch.manual_seed(0)
36B = 64
37actual = torch.rand(B) * 100 + 20
38pred   = actual + torch.randn(B) * 6   # one model, three losses
39
40for name, w in [("AMNL  (accuracy)", 0.0),
41                ("GABA  (balanced)", 0.5),
42                ("GRACE (safety)  ", 1.0)]:
43    loss = RegimeAwareLoss(safety_weight=w)(pred, actual)
44    print(f"{name}  L = {loss.item():.4f}")

A Decision Tree for Practitioners

Five questions. Five-second decision.

The Same Knob in Other Industries

The accuracy-safety tradeoff with a single regime knob is not unique to prognostics. It appears, with different variable names, almost everywhere a prediction has asymmetric consequences.

Every row is a different name for the same knob. The book's machinery for building, training, and choosing among models on the Pareto frontier carries over directly.

The book in two sentences. One backbone. Three losses. One knob to choose between them.

Takeaway

• There is no single best RUL model. There is a Pareto frontier and three useful operating points on it.
• One combined cost, one knob. $J(\theta; w) = (1-w)\widetilde{\mathrm{RMSE}} + w\widetilde{\mathrm{NASA}}$ collapses the choice into a single scalar in $[0, 1]$.
• Three models, three regimes. AMNL owns w near 0; GABA owns w near 0.5; GRACE owns w near 1. Real numbers from the paper bear this out.
• The same backbone underlies all three. Only the training objective differs — meaning all of Part III applies to all three of Parts V, VI, and VII.
• The published SOTA is dominated. Every model in our framework, including the simplest baseline, beats DKAMFormer on both axes on multi-condition data.