Personalization on-device

"The factory shipped me one model for a million wrists. Yours is the only one I answer to now, and I never sent a single heartbeat back to prove it."

A Personal AI Agent

This section assumes you are comfortable with the frozen-backbone, train-the-head split of Section 62.4 and the forgetting dynamics of Section 62.2. Personalization reuses that machinery but points it inward: instead of adding a class the base never saw, it re-fits the decision surface to a person the base saw only as one anonymous sample among many. The privacy argument that makes on-device the only acceptable option connects directly to Chapter 34, and the fleet-wide version, where personal updates are aggregated without sharing data, is Chapter 64.

Personalization is a per-user distribution shift

State it formally so the fix is obvious. The base model is trained on a population distribution \(p_{\text{pop}}(x, y)\). User \(u\) generates samples from \(p_u(x, y)\), and the two differ. Decompose the joint: \(p_u(x,y) = p_u(y \mid x)\, p_u(x)\). Two flavours of gap appear. Covariate shift moves \(p_u(x)\): a runner's accelerometer occupies a different region of feature space than a desk worker's, though the activity labels mean the same thing. Concept shift moves \(p_u(y \mid x)\): the same photoplethysmography waveform amplitude means "resting" for an athlete and "elevated" for a sedentary user, so the label boundary itself relocates. The population model minimises expected loss over \(p_{\text{pop}}\), which is exactly the wrong average when one user sits far in the tail. Personalization is the act of re-estimating the part of the model that carries this per-user gap, using data drawn from \(p_u\) that only the device ever sees.

Three mechanisms, cheapest first

Calibration and threshold shift. The lightest personalization touches no weights at all. It re-centres feature statistics or moves the operating threshold to match the user's base rate and signal amplitude. Recomputing the running mean and variance that a normalization layer applies, using this user's samples instead of the population's, is often enough to absorb pure covariate shift; it is unsupervised, needs no labels, and is the on-device sibling of the test-time adaptation of Chapter 66. Pairing a personalized threshold with the calibrated probabilities and conformal sets of Chapter 18 keeps error rates honest per user rather than only on average.

Adapter or head fine-tuning. When the boundary itself has moved (concept shift), re-fit a small trainable module: a personalized classifier head, or a bottleneck adapter of width \(r\) inserted after the frozen features. With embedding dimension \(d\), a low-rank adapter costs \(2dr\) parameters against the \(d^2\) of a full layer; for \(d=256, r=8\) that is 4096 numbers, a few kilobytes, trainable from minutes of labelled interaction. The backbone stays frozen, so the population knowledge is preserved by construction, the same firewall against forgetting used in Section 62.4.

Regularized personal fine-tuning. The heaviest option unfreezes a few upper layers but anchors them to the shipped weights with a proximal penalty, minimizing

where \(\theta_0\) is the base model and \(\lambda\) sets how far the personal model may drift. Large \(\lambda\) keeps the user close to the robust population prior when their data is scarce or noisy; small \(\lambda\) lets a data-rich user specialise. This single knob is the practical heart of personalization: it trades personal fit against the safety of the shared model, and choosing it badly is how personalization goes wrong.

What breaks, and how to hold the line

Personalization has a signature failure mode: collapse onto a bad sample. A user tags noisy data, wears the device wrong for a day, or feeds the online learner a burst of one class, and the adapter over-fits to that transient. Because on-device labels are scarce and often self-generated, there is no held-out set to catch it. Three defences carry most of the weight. First, keep an escape hatch: retain the frozen base and blend, so a prediction is a gated mixture \(g\cdot f_{\text{personal}} + (1-g)\cdot f_{\text{base}}\) with the gate \(g\) rising only as personal confidence and data volume rise; if the personal model degrades you fall back to the shipped one. Second, anchor with the prior: the \(\lambda\) penalty above, sized to the amount of personal data, prevents a five-sample day from rewriting the model. Third, gate the trigger: only accept personal updates when an on-device drift or confidence check says the population model is genuinely mismatched, not merely noisy. These are the same self-update guardrails formalised in Section 62.7; personalization is the most common reason a deployed model ever asks to change itself.

The snippet below implements the cheapest and most robust mechanism together: an unsupervised per-user feature recalibration plus a confidence-gated blend against the frozen base. It runs in a few lines of NumPy and is faithful to what a microcontroller does in fixed point.

import numpy as np

class PersonalHead:
    """Per-user feature recalibration + confidence-gated blend with a frozen base."""
    def __init__(self, base_mu, base_sigma, W_base, b_base, lam=8.0):
        self.base_mu, self.base_sigma = base_mu, base_sigma      # population stats
        self.mu, self.sigma = base_mu.copy(), base_sigma.copy()  # personal, start = base
        self.n = 0.0                                             # personal samples seen
        self.W, self.b = W_base, b_base                          # shared linear head
        self.lam = lam                                           # prior strength

    def observe(self, z):
        """Unsupervised: update this user's running feature mean/var (no labels)."""
        self.n += 1.0
        d = z - self.mu
        self.mu += d / self.n
        self.sigma += (d * (z - self.mu) - self.sigma) / self.n

    def _logits(self, z, mu, sigma):
        return self.W @ ((z - mu) / (np.sqrt(sigma) + 1e-6)) + self.b

    def predict(self, z):
        # Anchor personal stats to the population prior; gate by evidence n.
        g = self.n / (self.n + self.lam)                        # 0 -> base, 1 -> personal
        mu  = g * self.mu    + (1 - g) * self.base_mu
        sig = g * self.sigma + (1 - g) * self.base_sigma
        logits = self._logits(z, mu, sig)
        p = np.exp(logits - logits.max()); p /= p.sum()
        return int(p.argmax()), float(p.max())                  # label, confidence

What's Next

In Section 62.7, we confront the uncomfortable consequence of everything in this chapter: a model that rewrites itself in the field is a model that can break itself in the field. We turn personalization's guardrails, the escape hatch, the prior anchor, and the gated trigger, into a formal safety discipline for self-updating models, covering rollback, update validation without a held-out set, and the monitoring that keeps an on-device learner from silently drifting past the point of trust.