Evaluation of sensor-language systems

"You scored me at 0.71 BLEU and declared me competent. I had described a sprint as a nap, fluently, in the annotator's exact phrasing. The metric applauded my grammar and never once looked at the accelerometer."

A Well-Scored AI Agent

This section leans on the leakage-safe splitting discipline of Chapter 5 and the general benchmarking protocols of Chapter 65; it also assumes the calibration and reliability vocabulary of Chapter 18, since a trustworthy verbal answer must also be a calibrated one. Where 21.6 asked how to prevent hallucination, this section asks how to measure whether you succeeded.

Why borrowed metrics lie here

Sensor-language evaluation inherits two toolkits, and both are wrong out of the box. From natural language generation come n-gram overlap scores (BLEU, ROUGE, METEOR) and embedding-similarity scores (BERTScore). These measure surface or semantic agreement with a reference sentence. The problem is that the reference space for a sensor description is tiny and paraphrase-rich: "the subject was walking" and "the person went for a run" share most tokens and much embedding mass, yet they differ on the one fact that matters, the activity label. A model that swaps walking for running loses almost no BLEU while being clinically or operationally wrong. Overlap metrics are numerically stable and completely blind to the physical error.

From classification come accuracy, precision, recall, and F1. These are sharp and physically grounded, but they only apply once you have coerced a free-form answer into a label, which for open-ended questions ("why did my heart rate spike?") is not possible without another model doing the coercing. The result is a gap: the metrics that are grounded cannot read sentences, and the metrics that read sentences are not grounded. The whole craft of evaluating sensor-language systems is closing that gap deliberately, rather than picking one side and hoping.

Building a faithfulness metric

Faithfulness is the degree to which the claims in an answer are entailed by the signal. You cannot compute it directly against raw samples, so you route it through structured intermediate facts. The recipe that generalizes: extract a small set of checkable atomic claims from the generated text (activity = running, duration = 22 min, peak HR = 168 bpm), compute each corresponding quantity from the signal with a trusted classical or learned estimator, and score the match. For categorical claims this is an exact or taxonomy-aware comparison; for numeric claims it is a tolerance band. A clean way to express the numeric case is a relative-error gate,

where \(\hat{v}_c\) is the value the model asserted for claim \(c\), \(v_c\) is the signal-derived reference, \(\tau\) is a domain tolerance (tight for a glucose figure, loose for a step count), and \(\epsilon\) guards the division near zero. The answer-level faithfulness is then the fraction of claims that pass, and you report it alongside a coverage number (how many claims were checkable at all), because a model can game any claim-level metric by making only vague, uncheckable statements. Faithfulness without coverage is the sensor-language equivalent of a witness who answers every question with "things happened."

LLM-as-judge, and how to keep it honest

For the open-ended, unscorable-by-label answers (explanations, comparisons, trends), the pragmatic modern default is an LLM judge: a strong model reads the question, the candidate answer, and a reference or the extracted signal facts, then rates correctness and grounding on a rubric. It scales, it reads sentences, and it can be pointed at the physical axis if you feed it the ground-truth facts rather than only a gold sentence. But a judge is a measurement instrument, and an uncalibrated instrument produces confident nonsense. Three biases dominate and must be controlled: position bias (the judge prefers whichever answer is shown first, so randomize or swap order), verbosity bias (longer answers score higher regardless of correctness, so normalize or instruct against it), and self-preference (a judge favors outputs from its own model family, so never judge a model with a sibling). The non-negotiable validation step is to measure the judge against human ratings on a held-out slice and report the agreement, typically Cohen's or Krippendorff's \(\kappa\); a judge with \(\kappa\) below roughly 0.6 against humans is not yet a metric, it is a hypothesis.

A minimal faithfulness harness

The snippet below scores a batch of answers on the two axes at once: a reference-free fluency proxy and a signal-grounded faithfulness rate over extracted numeric claims. It deliberately keeps the claim extractor and signal estimator as pluggable stubs, because those are the domain-specific parts; the scoring skeleton is what stays constant across wearable, industrial, and automotive deployments.

import numpy as np

def numeric_faithfulness(claims, signal_facts, tau=0.10, eps=1e-6):
    """claims, signal_facts: dicts {name: value}. Returns (rate, coverage)."""
    checkable = [k for k in claims if k in signal_facts]
    if not checkable:
        return float("nan"), 0.0            # nothing to verify: flag it
    passed = 0
    for k in checkable:
        v_hat, v = claims[k], signal_facts[k]
        rel_err = abs(v_hat - v) / max(abs(v), eps)
        passed += int(rel_err <= tau)
    coverage = len(checkable) / len(claims)  # fraction of claims verifiable
    return passed / len(checkable), coverage

def evaluate(batch):
    """batch: list of dicts with 'claims' and 'signal_facts'."""
    rates, covs = [], []
    for item in batch:
        r, c = numeric_faithfulness(item["claims"], item["signal_facts"])
        if not np.isnan(r):
            rates.append(r)
        covs.append(c)
    n = len(rates)
    mean = float(np.mean(rates)) if n else float("nan")
    # 95% bootstrap CI so a single number never travels without its error bar
    boot = [np.mean(np.random.choice(rates, n, replace=True)) for _ in range(2000)] if n else []
    ci = (float(np.percentile(boot, 2.5)), float(np.percentile(boot, 97.5))) if boot else (float("nan"),)*2
    return {"faithfulness": mean, "ci95": ci, "coverage": float(np.mean(covs))}

demo = [
    {"claims": {"activity": 1, "duration_min": 22, "peak_hr": 168},
     "signal_facts": {"activity": 1, "duration_min": 21, "peak_hr": 148}},  # HR hallucinated
    {"claims": {"duration_min": 40, "peak_hr": 150},
     "signal_facts": {"duration_min": 41, "peak_hr": 152}},
]
print(evaluate(demo))

The confidence interval in that harness is not decoration. Sensor-language test sets are small and expensive (human-written questions, signal-verified answers), so differences between two systems are routinely inside the noise. Reporting a bootstrap interval, and refusing to declare a winner when intervals overlap, is the single cheapest defense against the over-claiming that plagues this young field.

Leakage, cost, and the protocol around the number

A faithfulness score is only as honest as the split it was computed on. Sensor-language datasets leak in ways NLP practitioners never anticipate: the same subject appears in train and test with different questions, so the model memorizes a person's routine rather than reasoning about a signal; consecutive windows from one recording straddle the split; or the LLM under test saw the public benchmark during pretraining, the sensor-language version of the contamination problem. The defenses are the subject-wise, recording-wise splitting rules of Chapter 5, plus a held-out private test set whose questions were never published. Report the split policy next to every number; a leaderboard without a stated split policy is uninterpretable.

Finally, evaluate the axes a leaderboard forgets. A sensor-language answer has a latency and a dollar cost, and for on-device wearable or vehicle use those often dominate the accuracy delta between two models. A faithful answer that arrives in nine seconds and drains the battery is a worse product than a slightly less faithful one that answers instantly on-device. Report faithfulness, coverage, calibration, latency, and cost as a vector, and choose along the frontier rather than by a single scalar. This is the same efficiency-versus-quality discipline that governs the edge deployment of Chapter 59, applied to words instead of tensors.

What's Next

In Chapter 22, the sensor-language model stops being a passive describer and becomes an actor: an LLM agent that queries sensors, calls tools, and drives operations. Everything in this section becomes the safety harness for that agent, because an agent that acts on an unfaithful reading does not just produce a wrong sentence, it produces a wrong action, and the faithfulness metric you built here is what stands between a plausible paragraph and a false alarm on the plant floor.