156 lines
5.8 KiB
Python
156 lines
5.8 KiB
Python
"""Tests for the eval metrics module."""
|
|
from __future__ import annotations
|
|
|
|
import numpy as np
|
|
import pytest
|
|
|
|
|
|
class TestKinematics:
|
|
def test_compute_speed_constant_velocity(self):
|
|
"""Constant-velocity trajectory has constant speed."""
|
|
from tools.eval.metrics import compute_speed
|
|
# 10 points, moving 10 px in 100 ms each step → speed = 0.1 px/ms
|
|
xs = np.arange(0, 100, 10, dtype=float)
|
|
ys = np.zeros(10, dtype=float)
|
|
ts = np.arange(0, 1000, 100, dtype=float)
|
|
v = compute_speed(xs, ys, ts)
|
|
# All speeds should be ≈ 0.1 px/ms
|
|
assert v.shape == (9,) # n-1 differences
|
|
np.testing.assert_allclose(v, 0.1, rtol=1e-4)
|
|
|
|
def test_compute_speed_handles_zero_dt(self):
|
|
"""Adjacent points with same timestamp must not produce NaN/inf."""
|
|
from tools.eval.metrics import compute_speed
|
|
xs = np.array([0.0, 10.0, 20.0])
|
|
ys = np.array([0.0, 0.0, 0.0])
|
|
ts = np.array([0.0, 0.0, 100.0]) # zero dt between [0] and [1]
|
|
v = compute_speed(xs, ys, ts)
|
|
assert np.isfinite(v).all()
|
|
|
|
def test_compute_acceleration(self):
|
|
"""Linearly increasing speed → constant acceleration."""
|
|
from tools.eval.metrics import compute_acceleration
|
|
# speeds: 0.1, 0.2, 0.3, 0.4 over dt = 100 ms each → a = 0.001 px/ms²
|
|
speeds = np.array([0.1, 0.2, 0.3, 0.4])
|
|
ts = np.array([100.0, 200.0, 300.0, 400.0])
|
|
a = compute_acceleration(speeds, ts)
|
|
np.testing.assert_allclose(a, 0.001, rtol=1e-4)
|
|
|
|
def test_compute_jerk(self):
|
|
from tools.eval.metrics import compute_jerk
|
|
# accelerations: 0.001, 0.002, 0.003 over dt = 100 ms → j = 0.00001
|
|
accels = np.array([0.001, 0.002, 0.003])
|
|
ts = np.array([200.0, 300.0, 400.0])
|
|
j = compute_jerk(accels, ts)
|
|
np.testing.assert_allclose(j, 1e-5, rtol=1e-4)
|
|
|
|
|
|
class TestStatsSummary:
|
|
def test_compute_stats_returns_expected_keys(self):
|
|
from tools.eval.metrics import compute_stats
|
|
x = np.array([1.0, 2.0, 3.0, 4.0, 5.0])
|
|
s = compute_stats(x)
|
|
assert "mean" in s
|
|
assert "std" in s
|
|
assert "cv" in s
|
|
assert "p25" in s
|
|
assert "p50" in s
|
|
assert "p75" in s
|
|
assert "p95" in s
|
|
|
|
def test_cv_for_constant_is_zero(self):
|
|
from tools.eval.metrics import compute_stats
|
|
x = np.full(10, 3.0)
|
|
s = compute_stats(x)
|
|
assert s["cv"] == 0.0
|
|
|
|
|
|
class TestFftSpectrum:
|
|
def test_finds_dominant_frequency(self):
|
|
"""A pure 8 Hz signal should have its peak near 8 Hz."""
|
|
from tools.eval.metrics import fft_spectrum
|
|
# Sample at 100 Hz for 1 second
|
|
sample_rate_hz = 100.0
|
|
ts_ms = np.arange(0, 1000, 1000 / sample_rate_hz)
|
|
signal = np.sin(2 * np.pi * 8 * ts_ms / 1000) # 8 Hz sine
|
|
freqs, mags = fft_spectrum(signal, sample_rate_hz)
|
|
peak_freq = freqs[np.argmax(mags)]
|
|
assert abs(peak_freq - 8.0) < 1.0 # within 1 Hz
|
|
|
|
def test_returns_only_positive_frequencies(self):
|
|
from tools.eval.metrics import fft_spectrum
|
|
signal = np.random.randn(64)
|
|
freqs, mags = fft_spectrum(signal, 50.0)
|
|
assert (freqs >= 0).all()
|
|
assert len(freqs) == len(mags)
|
|
|
|
|
|
class TestKlDivergence:
|
|
def test_identical_distributions_zero_kl(self):
|
|
"""KL(p, p) ≈ 0."""
|
|
from tools.eval.metrics import kl_divergence_histograms
|
|
rng = np.random.default_rng(42)
|
|
x = rng.normal(0, 1, 5000)
|
|
y = rng.normal(0, 1, 5000)
|
|
kl = kl_divergence_histograms(x, y, bins=50)
|
|
assert kl < 0.05
|
|
|
|
def test_different_distributions_positive_kl(self):
|
|
"""Different means → positive KL."""
|
|
from tools.eval.metrics import kl_divergence_histograms
|
|
rng = np.random.default_rng(42)
|
|
x = rng.normal(0, 1, 5000)
|
|
y = rng.normal(3, 1, 5000)
|
|
kl = kl_divergence_histograms(x, y, bins=50)
|
|
assert kl > 0.5
|
|
|
|
def test_handles_disjoint_supports(self):
|
|
"""No NaN even when histograms have non-overlapping bins."""
|
|
from tools.eval.metrics import kl_divergence_histograms
|
|
x = np.array([1.0, 1.1, 1.2, 1.3, 1.4])
|
|
y = np.array([10.0, 10.1, 10.2, 10.3, 10.4])
|
|
kl = kl_divergence_histograms(x, y, bins=10)
|
|
assert np.isfinite(kl)
|
|
|
|
|
|
class TestReportGeneration:
|
|
def test_generates_report_md(self, tmp_path):
|
|
"""Smoke test: build_report writes an MD file with all expected sections."""
|
|
from tools.eval.report import build_report
|
|
|
|
# Synthetic generated traces (3 traces, 50 points each)
|
|
rng = np.random.default_rng(0)
|
|
gen_traces = []
|
|
for _ in range(3):
|
|
xs = np.cumsum(rng.uniform(0, 5, 50))
|
|
ys = np.cumsum(rng.uniform(-1, 1, 50))
|
|
ts = np.cumsum(rng.uniform(5, 20, 50))
|
|
gen_traces.append({"xs": xs, "ys": ys, "ts": ts})
|
|
|
|
# Synthetic reference
|
|
ref_traces = []
|
|
for _ in range(5):
|
|
xs = np.cumsum(rng.uniform(0, 5, 50))
|
|
ys = np.cumsum(rng.uniform(-1, 1, 50))
|
|
ts = np.cumsum(rng.uniform(5, 20, 50))
|
|
ref_traces.append({"xs": xs, "ys": ys, "ts": ts})
|
|
|
|
out_md = tmp_path / "report.md"
|
|
build_report(
|
|
generated_traces=gen_traces,
|
|
reference_traces=ref_traces,
|
|
output_md=out_md,
|
|
tag="smoke-test",
|
|
model_dir="/fake/model/dir",
|
|
)
|
|
assert out_md.exists()
|
|
content = out_md.read_text(encoding="utf-8")
|
|
assert "# Eval Report" in content
|
|
assert "smoke-test" in content
|
|
assert "速度" in content or "speed" in content.lower()
|
|
assert "FFT" in content.upper()
|
|
# PNG plots should exist next to MD
|
|
plot_dir = tmp_path / "plots"
|
|
assert plot_dir.exists()
|
|
assert any(plot_dir.iterdir())
|