@@ -41,6 +41,25 @@ and this project adheres to
 - `add_terminal_composition` on `DeepLCDataset` and `DeepLCDataset.from_psm_list`,
   passed through to `encode_peptidoform`.
 
+### Fixed
+
+- Fine-tuning could return a model far worse than the one it started from. Three
+  defects compounded: `train()` began with an infinite best validation loss, so the
+  first epoch always became the best however bad it was; the output layer's scale was
+  learned rather than solved, though it is linear in its input; and the adapter's ReLU
+  stack is largely dead at its default initialisation, which left the activations rank
+  deficient and made a CUDA least-squares solve return non-finite values and silently
+  decline. On a 133-minute gradient with 230 reference peptides the adapter path
+  returned predictions spanning 1.3 to 27.2 minutes at an error of 92 minutes, with
+  the correlation still above 0.9 because only the scale was lost. Training now scores
+  its starting point, both adaptation paths solve their output layer on the reference
+  data first, and that solve is rank tolerant. The same setup now gives 1.63 minutes
+  for the adapter path and 2.05 for the low-rank head, against 1.47 and 1.28 for
+  calibration.
+- A fine-tuned model whose validation error exceeds a large fraction of the reference
+  retention-time span is now reported at error level, since a collapsed fit leaves the
+  loss curve and the correlation looking unremarkable.
+
 ### Changed
 
 - `predict()` loads the model before encoding features, so a model that records a feature
 
@@ -416,6 +416,92 @@ def add_adapter(self, hidden_size: int = 256) -> None:
         )
         self.adapter.to(self.heads.b2.device)
 
+    @torch.no_grad()
+    def solve_adapter_output(
+        self,
+        x_atom: torch.Tensor,
+        x_atom_sum: torch.Tensor,
+        x_global: torch.Tensor,
+        x_one_hot: torch.Tensor,
+        targets: torch.Tensor,
+    ) -> bool:
+        """
+        Set the adapter's output layer by least squares on the reference data.
+
+        The adapter is otherwise trained from a default initialisation, so its output
+        begins unrelated to minutes and, on a small reference set, can settle on a
+        degenerate fit that predicts every peptide near the mean retention time. Its
+        final layer is linear in its input, so the best output weights and bias for
+        the current earlier layers follow in closed form.
+
+        Returns True when the solve was applied. Called after :meth:`add_adapter` and
+        before training.
+
+        Parameters
+        ----------
+        x_atom, x_atom_sum, x_global, x_one_hot
+            Encoded reference peptidoforms.
+        targets
+            Their observed retention times.
+
+        """
+        adapter = getattr(self, "adapter", None)
+        if adapter is None or not isinstance(adapter[-1], nn.Linear):
+            return False
+
+        was_training = self.training
+        self.eval()
+        try:
+            x_atom_t = x_atom.transpose(1, 2)
+            x_atom_sum_t = x_atom_sum.transpose(1, 2)
+            x_one_hot_t = x_one_hot.transpose(1, 2)
+            concatenated = torch.cat(
+                [
+                    self.branch_a(x_atom_t),
+                    self.branch_b(x_atom_sum_t),
+                    self.branch_c(x_global),
+                    self.branch_d(x_one_hot_t),
+                ],
+                dim=1,
+            )
+            head_vector = self.heads(self.shared_trunk(concatenated))
+            # Everything up to, but not including, the output layer.
+            penultimate = head_vector
+            for layer in list(adapter)[:-1]:
+                penultimate = layer(penultimate)
+        finally:
+            if was_training:
+                self.train()
+
+        features = penultimate.detach().double()
+        y = targets.detach().reshape(-1).double()
+        if features.shape[0] != y.shape[0] or features.shape[0] < 3:
+            return False
+
+        design = torch.cat([features, torch.ones_like(features[:, :1])], dim=1)
+        # Solved on the CPU with a rank-revealing driver, and ridge-regularised. The
+        # adapter's ReLU stack is largely dead at its default initialisation, so the
+        # activations arriving here are often rank deficient; the default CUDA driver
+        # requires full rank and returns non-finite values on such a system, which is
+        # how this solve silently declined to apply.
+        design = design.cpu()
+        target = y.unsqueeze(1).cpu()
+        ridge = 1e-6 * torch.eye(design.shape[1], dtype=design.dtype)
+        try:
+            gram = design.T @ design + ridge
+            solution = torch.linalg.solve(gram, design.T @ target).reshape(-1)
+        except Exception:  # noqa: BLE001 - a singular system leaves the init alone
+            return False
+        if not torch.isfinite(solution).all():
+            return False
+        solution = solution.to(features.device)
+
+        output = adapter[-1]
+        output.weight.copy_(solution[:-1].reshape(1, -1).to(output.weight.dtype))
+        if output.bias is not None:
+            output.bias.copy_(solution[-1].reshape(1).to(output.bias.dtype))
+        return True
+
     def freeze_backbone(self) -> None:
         """Freeze all parameters except the adapter."""
         for name, param in self.named_parameters():
 
@@ -199,7 +199,14 @@ def train(
     loss_fn = torch.nn.L1Loss()
 
     best_model_wts = copy.deepcopy(model.state_dict())
-    best_val_loss = float("inf")
+
+    # Score the starting point, so training can never return a model worse than the
+    # one it began with. With this left at infinity the first epoch always became the
+    # best, even when it was worse: fine-tuning a small reference set could hand back
+    # a fit whose predictions had collapsed onto the mean retention time, at ninety
+    # times the error of the model it started from.
+    best_val_loss = _validate_epoch(model, val_loader, loss_fn, device)
+    logger.debug("Validation loss before training: %.4f", best_val_loss)
     epochs_no_improve = 0
 
     with _create_progress(disable=not show_progress) as progress:
 
@@ -31,6 +31,15 @@
 #: 0.48, and at 735 and above fine-tuning helped every version.
 MIN_FINETUNE_REFERENCE = 500
 
+#: A fine-tuned model whose validation error exceeds this fraction of the reference
+#: retention-time span has not converged onto the gradient, whatever the loss curve
+#: said. Measured failures collapse the output range and predict near the mean, so
+#: the error lands at a large fraction of the span: on one 133-minute gradient the
+#: adapter path reached 92 minutes, or 69 % of the span, while its correlation stayed
+#: above 0.9 because the peptide ordering was never what broke. Ordinary fits sit
+#: near 1 %.
+MAX_FINETUNE_ERROR_FRACTION = 0.15
+
 #: Fused-trunk multitask model, trained across 6,543 LC setups. Not the default:
 #: switching would change every prediction, so the choice is left to the caller
 #: until the calibration path is adapted to its low-rank head.
@@ -321,6 +330,39 @@ def finetune_and_predict(
     return calibrated_rt
 
 
+def _solve_reference_affine(
+    model: torch.nn.Module,
+    dataset,
+    device: str | None = None,
+    adapter: bool = False,
+) -> bool:
+    """
+    Put a freshly attached output on the right axis before training starts.
+
+    Both adaptation paths end in a layer that is linear in its input, so the values
+    that best fit the reference data follow in closed form. Solving them first is what
+    keeps a small reference set from producing a fit that predicts every peptide near
+    the mean retention time.
+
+    Returns True when the solve was applied. A failure is not fatal: training then
+    proceeds from the initialised values, which is the previous behaviour.
+    """
+    try:
+        loader = DataLoader(dataset, batch_size=len(dataset), shuffle=False)
+        features, targets = next(iter(loader))
+        selected = device or ("cuda" if torch.cuda.is_available() else "cpu")
+        model.to(selected)
+        moved = tuple(f.to(selected) for f in features)
+        targets = targets.to(selected).float()
+        if adapter:
+            return bool(model.solve_adapter_output(*moved, targets))
+        model.solve_new_task_affine(moved, targets)
+        return True
+    except Exception:  # noqa: BLE001 - never let the anchor break the fit
+        LOGGER.warning("Could not anchor the output layer; training from the initialised values.")
+        return False
+
+
 def finetune(
     psm_list_reference: PSMList,
     psm_list_validation: PSMList | None = None,
@@ -420,22 +462,8 @@ def finetune(
         # with 230 reference peptides the output range shrank to 17 minutes and the
         # error reached 91 minutes, with the correlation still above 0.9 because the
         # ordering was never what broke.
-        try:
-            loader = DataLoader(training_data, batch_size=len(training_data), shuffle=False)
-            features, batch_targets = next(iter(loader))
-            device = train_kwargs_local.get("device") or (
-                "cuda" if torch.cuda.is_available() else "cpu"
-            )
-            loaded_model.to(device)
-            loaded_model.solve_new_task_affine(
-                tuple(f.to(device) for f in features),
-                batch_targets.to(device).float(),
-            )
+        if _solve_reference_affine(loaded_model, training_data, train_kwargs_local.get("device")):
             LOGGER.info("Anchored the new setup's scale and shift by least squares.")
-        except Exception:  # noqa: BLE001 - a failed anchor is not fatal
-            LOGGER.warning(
-                "Could not anchor the affine part; falling back to the initialised values."
-            )
         # Sixty-six parameters tolerate, and need, a far larger step than the
         # whole-network default: at 1e-3 the fit is still short of its optimum after
         # twenty-five epochs (1.32 min against 0.86 on a held-out setup).
@@ -449,6 +477,19 @@ def finetune(
     elif hasattr(loaded_model, "add_adapter"):
         loaded_model.add_adapter(hidden_size=adapter_hidden_size)
         train_kwargs_local["freeze_epochs"] = freeze_epochs
+
+        # Put the adapter's output on the right axis before training. From a default
+        # initialisation on a small reference set the fit can collapse onto the mean
+        # retention time: on a 133-minute gradient with 230 reference peptides the
+        # output range shrank to 26 minutes and the error reached 92, with the
+        # correlation still above 0.9 because only the scale was lost.
+        if _solve_reference_affine(
+            loaded_model,
+            training_data,
+            train_kwargs_local.get("device"),
+            adapter=True,
+        ):
+            LOGGER.info("Anchored the adapter's output layer by least squares.")
     else:
         raise NotImplementedError(
             f"{type(loaded_model).__name__} supports neither adapter-based "
@@ -461,9 +502,68 @@ def finetune(
         validation_dataset=validation_dataset,
         **train_kwargs_local,
     )
+
+    _warn_if_fit_collapsed(
+        finetuned_model,
+        validation_dataset,
+        psm_list_reference,
+        device=train_kwargs_local.get("device"),
+    )
     return finetuned_model
 
 
+def _warn_if_fit_collapsed(
+    model: torch.nn.Module,
+    validation_dataset,
+    psm_list_reference: PSMList,
+    device: str | None = None,
+) -> None:
+    """
+    Say so, loudly, when a fine-tuned model is far worse than its own reference data.
+
+    Fine-tuning can converge on a degenerate solution that predicts every peptide
+    near the mean retention time. The loss curve looks unremarkable and the
+    correlation stays high, because the ordering is preserved and only the scale is
+    lost, so nothing in training flags it. Comparing the validation error against the
+    span of the reference retention times does: a collapsed fit lands at a large
+    fraction of the span where a working one sits near a hundredth of it.
+
+    This is a report, not a repair. Whether to fall back to calibration is the
+    caller's decision, and for the adapter path there is no untrained state worth
+    reverting to.
+    """
+    observed = [t for t in psm_list_reference["retention_time"] if t is not None]
+    if len(observed) < 3:
+        return
+    span = float(np.max(observed) - np.min(observed))
+    if span <= 0:
+        return
+
+    try:
+        error = _model_ops.evaluate(model, validation_dataset, device=device)
+    except Exception:  # noqa: BLE001 - the check must never break the fit
+        LOGGER.debug("Could not evaluate the fine-tuned model for the sanity check.")
+        return
+
+    fraction = error / span
+    if fraction > MAX_FINETUNE_ERROR_FRACTION:
+        LOGGER.error(
+            "Fine-tuned validation error is %.2f, which is %.0f %% of the reference "
+            "retention-time span of %.1f. A fit this far off has collapsed rather "
+            "than converged: predictions are probably clustered near the mean "
+            "retention time. Prefer predict() with calibrate() for this dataset.",
+            error,
+            fraction * 100,
+            span,
+        )
+    else:
+        LOGGER.info(
+            "Fine-tuned validation error %.3f, %.1f %% of the reference span.",
+            error,
+            fraction * 100,
+        )
+
+
 def train(
     psm_list_reference: PSMList,
     psm_list_validation: PSMList | None = None,
 
@@ -590,3 +590,78 @@ def test_small_reference_set_warns_and_widens_validation(tmp_path, caplog):
             train_kwargs={"epochs": 2, "device": "cpu", "show_progress": False, "batch_size": 4},
         )
     assert any("reference PSMs" in r.getMessage() for r in caplog.records)
+
+
+def test_adapter_output_layer_is_anchored():
+    """
+    Solving the adapter's output layer must put it on the retention-time axis.
+
+    The adapter's ReLU stack is largely dead at its default initialisation, so before
+    this solve its output was near zero for every peptide, and the activations
+    reaching the output layer are rank deficient. A CUDA least-squares driver
+    requires full rank and returns non-finite values on such a system, which is why
+    the solve has to be done with a rank-tolerant method.
+    """
+    model = DeepLCModel(n_heads=4)
+    model.add_adapter(hidden_size=32)
+    model.eval()
+
+    lengths = [8, 12, 20, 31, 44, 7]
+    x_atom, x_atom_sum, x_global, one_hot = _deeplc_batch(lengths)
+    targets = torch.tensor([20.0, 35.0, 55.0, 80.0, 110.0, 15.0])
+
+    with torch.no_grad():
+        before = model(x_atom, x_atom_sum, x_global, one_hot).reshape(-1)
+    assert before.max() - before.min() < 5.0, "expected a near-constant start"
+
+    applied = model.solve_adapter_output(x_atom, x_atom_sum, x_global, one_hot, targets)
+    assert applied
+
+    with torch.no_grad():
+        after = model(x_atom, x_atom_sum, x_global, one_hot).reshape(-1)
+    # The solve cannot fit dead activations perfectly, but it must at least land on
+    # the right axis rather than near zero.
+    assert after.mean().item() > 5.0
+    assert abs(after.mean().item() - targets.mean().item()) < 25.0
+
+
+def _deeplc_batch(lengths):
+    """Four-branch features for the released architecture."""
+    rng = np.random.RandomState(2)
+    batch = len(lengths)
+    x_atom = np.zeros((batch, MAXLEN, N_ATOMS), dtype=np.float32)
+    x_atom_sum = np.zeros((batch, 30, N_ATOMS), dtype=np.float32)
+    one_hot = np.zeros((batch, MAXLEN, N_RESIDUES), dtype=np.float32)
+    for i, length in enumerate(lengths):
+        x_atom[i, :length] = rng.randint(0, 12, size=(length, N_ATOMS))
+        x_atom_sum[i, : max(1, length // 2)] = rng.randint(
+            0, 20, size=(max(1, length // 2), N_ATOMS)
+        )
+        residues = rng.randint(0, N_RESIDUES, size=length)
+        one_hot[i, np.arange(length), residues] = 1.0
+    # The four-branch model reads the 55-dimensional global vector, not the 67-
+    # dimensional one the fused trunk needs.
+    x_global = rng.randn(batch, 55).astype(np.float32)
+    return (
+        torch.from_numpy(x_atom),
+        torch.from_numpy(x_atom_sum),
+        torch.from_numpy(x_global),
+        torch.from_numpy(one_hot),
+    )
+
+
+def test_training_scores_its_starting_point(tmp_path):
+    """
+    Training must not return a model worse than the one it started from.
+
+    With the best validation loss left at infinity the first epoch always became the
+    best, however bad, so a fine-tune on a small reference set could hand back a
+    collapsed fit at ninety times the error of its own starting point.
+    """
+    import inspect
+
+    from deeplc import _model_ops
+
+    source = inspect.getsource(_model_ops.train)
+    assert 'best_val_loss = float("inf")' not in source
+    assert "_validate_epoch(model, val_loader, loss_fn, device)" in source