test(grpo): add test coverage for GRPO utilities

Author: fin-griffin

.coverage

@@ -28,3 +28,4 @@ styledistance
 Wegmann
 embs
 cdfs
+unprimed

cspell/project-words.txt

@@ -369,6 +369,20 @@ def test_comparison_group_entry_is_frozen_and_slots():
         setattr(e, "avg_percentile", 0.0)  # noqa: B010
 
 
+def test_group_entry_repr_contains_avg_percentile():
+    e = GroupEntry(
+        group=MetricGroup.WORD_LENGTH_DISTRIBUTION,
+        avg_percentile=0.75,
+        avg_tail=0.25,
+    )
+    assert repr(e) == "GroupEntry(avg_percentile=0.7500)"
+
+
+def test_comparison_results_score_zero_when_no_entries(patch_metrics):
+    r = ComparisonResults(metrics=())
+    assert r.score == 0.0
+
+
 def test_comparison_results_rejects_unknown_metrics(patch_metrics):
     with pytest.raises(ValueError, match=r"Unknown metric"):
         ComparisonResults(metrics=("len", "nope"))

tests/voice/comparison/test_comparison.py

@@ -263,3 +263,45 @@ def test_voice_dataset_bad_split_attr_raises_attribute_error():
     vd = VoiceDataset(datasets={Split.TRAIN: _canonical_hf_ds(1)}, spec=p)
     with pytest.raises(AttributeError):
         _ = vd.validation
+
+
+def test_example_seq_slice_returns_subset():
+    p = _pinned(splits=(Split.TRAIN,))
+    vd = VoiceDataset(datasets={Split.TRAIN: _canonical_hf_ds(5)}, spec=p)
+
+    subset = vd.train[1:3]
+
+    assert len(subset) == 2
+    assert subset[0].answer == "a1"
+    assert subset[1].answer == "a2"
+
+
+def test_example_seq_repr():
+    p = _pinned(splits=(Split.TRAIN,))
+    vd = VoiceDataset(datasets={Split.TRAIN: _canonical_hf_ds(4)}, spec=p)
+
+    r = repr(vd.train)
+
+    assert "Examples(" in r
+    assert "train" in r
+    assert "4" in r
+
+
+def test_example_seq_hf_returns_dataset():
+    from datasets import Dataset
+
+    p = _pinned(splits=(Split.TRAIN,))
+    vd = VoiceDataset(datasets={Split.TRAIN: _canonical_hf_ds(3)}, spec=p)
+
+    assert isinstance(vd.train.hf, Dataset)
+
+
+def test_voice_dataset_repr():
+    p = _pinned(repo_id="ns/name", revision="a1b2c3d", splits=(Split.TRAIN,))
+    vd = VoiceDataset(datasets={Split.TRAIN: _canonical_hf_ds(7)}, spec=p)
+
+    r = repr(vd)
+
+    assert "VoiceDataset(" in r
+    assert "ns/name" in r
+    assert "a1b2c3d" in r

tests/voice/datasets/test_dataset.py

@@ -0,0 +1,238 @@
+"""
+Tests for voice.rl.rewards.
+
+Scope:
+- _build_training_cdfs: dataset loading, sorted arrays per metric
+- prime_typicality_cdfs: initialisation and no-op on second call
+- _typicality: tau formula, group aggregation, eps floor
+- typicality_reward: error when unprimed, length, clip, positive signal
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+import voice.rl.rewards as rewards_mod
+from voice._defaults import SCORING_DEFAULTS, MetricGroup
+from voice.rl.rewards import (
+    _build_training_cdfs,
+    _typicality,
+    prime_typicality_cdfs,
+    typicality_reward,
+)
+from voice.stylometry.metrics import MetricSpec
+
+# -----------------------------------------------------------------------------
+# Helpers
+# -----------------------------------------------------------------------------
+
+_CDF = np.array([0.0, 0.25, 0.5, 0.75, 1.0])
+
+_FAKE_DS = [
+    {
+        "messages": [
+            {"role": "user", "content": "q1"},
+            {"role": "assistant", "content": "ans1"},
+        ]
+    },
+    {
+        "messages": [
+            {"role": "user", "content": "q2"},
+            {"role": "assistant", "content": "ans2"},
+        ]
+    },
+]
+
+
+def _patch_metrics(monkeypatch, fn=None):
+    """Replace get_metrics with a single fake metric keyed 'm'."""
+    if fn is None:
+        fn = lambda t: 0.5  # noqa: E731
+    fake = {
+        "m": MetricSpec(
+            fn=fn,
+            group=MetricGroup.WORD_LENGTH_DISTRIBUTION,
+            description="fake",
+        )
+    }
+    monkeypatch.setattr(rewards_mod, "get_metrics", lambda: fake)
+    return fake
+
+
+def _fake_cdfs(fn=None):
+    """Return a cdfs dict compatible with _patch_metrics."""
+    return {"m": _CDF.copy()}
+
+
+# -----------------------------------------------------------------------------
+# _build_training_cdfs
+# -----------------------------------------------------------------------------
+
+
+def test_build_training_cdfs_returns_dict_keyed_by_metric(monkeypatch):
+    monkeypatch.setattr(rewards_mod, "load_dataset", lambda *a, **kw: _FAKE_DS)
+    _patch_metrics(monkeypatch)
+
+    cdfs = _build_training_cdfs("fake/ds")
+
+    assert "m" in cdfs
+
+
+def test_build_training_cdfs_array_is_sorted(monkeypatch):
+    values = {"ans1": 0.8, "ans2": 0.2}
+    monkeypatch.setattr(rewards_mod, "load_dataset", lambda *a, **kw: _FAKE_DS)
+    _patch_metrics(monkeypatch, fn=lambda t: values.get(t, 0.5))
+
+    cdfs = _build_training_cdfs("fake/ds")
+
+    arr = cdfs["m"]
+    assert list(arr) == sorted(arr)
+    assert pytest.approx(arr[0]) == 0.2
+    assert pytest.approx(arr[1]) == 0.8
+
+
+# -----------------------------------------------------------------------------
+# prime_typicality_cdfs
+# -----------------------------------------------------------------------------
+
+
+def test_prime_typicality_cdfs_sets_global(monkeypatch):
+    monkeypatch.setattr(rewards_mod, "_typicality_cdfs", None)
+    monkeypatch.setattr(
+        rewards_mod, "_build_training_cdfs", lambda ds: {"m": np.array([0.5])}
+    )
+
+    prime_typicality_cdfs("fake/ds")
+
+    assert rewards_mod._typicality_cdfs is not None
+    assert "m" in rewards_mod._typicality_cdfs
+
+
+def test_prime_typicality_cdfs_noop_when_already_set(monkeypatch):
+    sentinel = {"already": np.array([1.0])}
+    monkeypatch.setattr(rewards_mod, "_typicality_cdfs", sentinel)
+
+    called = [0]
+
+    def spy(ds: str) -> dict:
+        called[0] += 1
+        return {}
+
+    monkeypatch.setattr(rewards_mod, "_build_training_cdfs", spy)
+
+    prime_typicality_cdfs("any")
+
+    assert called[0] == 0
+    assert rewards_mod._typicality_cdfs is sentinel
+
+
+# -----------------------------------------------------------------------------
+# _typicality
+# -----------------------------------------------------------------------------
+
+
+def test_typicality_returns_float(monkeypatch):
+    _patch_metrics(monkeypatch)
+
+    result = _typicality("text", _fake_cdfs())
+
+    assert isinstance(result, float)
+
+
+def test_typicality_in_unit_interval(monkeypatch):
+    _patch_metrics(monkeypatch)
+
+    result = _typicality("text", _fake_cdfs())
+
+    assert 0.0 <= result <= 1.0
+
+
+def test_typicality_applies_group_eps_floor(monkeypatch):
+    _patch_metrics(monkeypatch, fn=lambda t: 999.0)
+    cdfs = {"m": np.array([0.0, 0.5, 0.9])}
+
+    result = _typicality("any", cdfs)
+
+    assert result == pytest.approx(SCORING_DEFAULTS.group_eps)
+
+
+def test_typicality_median_value_gives_high_score(monkeypatch):
+    _patch_metrics(monkeypatch, fn=lambda t: 0.5)
+    cdfs = {"m": np.array([0.0, 0.25, 0.5, 0.75, 1.0])}
+
+    result = _typicality("text", cdfs)
+
+    assert result == pytest.approx(0.8)
+
+
+# -----------------------------------------------------------------------------
+# typicality_reward
+# -----------------------------------------------------------------------------
+
+
+def test_typicality_reward_raises_without_primed_cdfs(monkeypatch):
+    monkeypatch.setattr(rewards_mod, "_typicality_cdfs", None)
+
+    with pytest.raises(RuntimeError, match="Typicality CDFs not initialised"):
+        typicality_reward(
+            completions=[[{"role": "assistant", "content": "x"}]],
+            ref_completion=["y"],
+        )
+
+
+def test_typicality_reward_returns_list_matching_completions_length(
+    monkeypatch,
+):
+    _patch_metrics(monkeypatch)
+    monkeypatch.setattr(rewards_mod, "_typicality_cdfs", _fake_cdfs())
+
+    completions = [
+        [{"role": "assistant", "content": "a"}],
+        [{"role": "assistant", "content": "b"}],
+        [{"role": "assistant", "content": "c"}],
+    ]
+    result = typicality_reward(
+        completions=completions, ref_completion=["x", "y", "z"]
+    )
+
+    assert len(result) == 3
+
+
+def test_typicality_reward_clips_negative_to_zero(monkeypatch):
+    values = {"comp": 0.0, "ref": 0.5}
+    _patch_metrics(monkeypatch, fn=lambda t: values.get(t, 0.5))
+    monkeypatch.setattr(rewards_mod, "_typicality_cdfs", _fake_cdfs())
+
+    result = typicality_reward(
+        completions=[[{"role": "assistant", "content": "comp"}]],
+        ref_completion=["ref"],
+    )
+
+    assert result[0] == 0.0
+
+
+def test_typicality_reward_positive_when_completion_beats_ref(monkeypatch):
+    values = {"comp": 0.5, "ref": 0.0}
+    _patch_metrics(monkeypatch, fn=lambda t: values.get(t, 0.5))
+    monkeypatch.setattr(rewards_mod, "_typicality_cdfs", _fake_cdfs())
+
+    result = typicality_reward(
+        completions=[[{"role": "assistant", "content": "comp"}]],
+        ref_completion=["ref"],
+    )
+
+    assert result[0] > 0.0
+
+
+def test_typicality_reward_passes_kwargs_without_error(monkeypatch):
+    _patch_metrics(monkeypatch)
+    monkeypatch.setattr(rewards_mod, "_typicality_cdfs", _fake_cdfs())
+
+    result = typicality_reward(
+        completions=[[{"role": "assistant", "content": "x"}]],
+        ref_completion=["y"],
+        extra_kwarg="ignored",
+    )
+
+    assert len(result) == 1

tests/voice/rl/test_rewards.py

@@ -0,0 +1,63 @@
+"""
+Tests for voice.rl._utils.
+
+Scope:
+- prompt_transform: returns (callable, {}) tuple
+- inner _map function: extracts prompt, true_completion, ref_completion
+"""
+
+from __future__ import annotations
+
+from voice.rl._utils import prompt_transform
+
+_EXAMPLE = {
+    "messages": [
+        {"role": "system", "content": "You are helpful."},
+        {"role": "user", "content": "What is 2+2?"},
+        {"role": "assistant", "content": "It is 4."},
+    ],
+    "ref_completion": "The answer is 4.",
+}
+
+
+def test_prompt_transform_returns_callable_and_empty_dict():
+    fn, kwargs = prompt_transform(None)
+
+    assert callable(fn)
+    assert kwargs == {}
+
+
+def test_prompt_transform_map_extracts_true_completion():
+    fn, _ = prompt_transform(object())
+
+    result = fn(_EXAMPLE)
+
+    assert result["true_completion"] == "It is 4."
+
+
+def test_prompt_transform_map_extracts_ref_completion():
+    fn, _ = prompt_transform(None)
+
+    result = fn(_EXAMPLE)
+
+    assert result["ref_completion"] == "The answer is 4."
+
+
+def test_prompt_transform_map_removes_assistant_from_prompt():
+    fn, _ = prompt_transform(None)
+
+    result = fn(_EXAMPLE)
+
+    roles = [m["role"] for m in result["prompt"]]
+    assert "assistant" not in roles
+    assert "system" in roles
+    assert "user" in roles
+
+
+def test_prompt_transform_map_ignores_tokenizer():
+    fn, _ = prompt_transform(None)
+
+    result_without = fn(_EXAMPLE)
+    result_with = fn(_EXAMPLE, tokenizer=object())
+
+    assert result_without == result_with