Add active-voiced pace correction ablation

app.py

@@ -18,6 +18,7 @@ from transformers import PreTrainedTokenizerFast
 from bluemagpie import BlueMagpieModel
 from production import (
     StopHysteresisController,
+    active_pace_correction_speed,
     apply_loudness_floor,
     count_speech_units,
     effective_generation_cfg,
@@ -323,7 +324,27 @@ def _generate_chunk(
         target_cps=TARGET_CPS,
         min_speed=MIN_PACE_SPEED,
     )
-    return _apply_speed(audio, pace_speed)
+    waveform = _apply_speed(audio, pace_speed)
+    try:
+        active_duration = active_voiced_duration_seconds(waveform, SR)
+    except (TypeError, ValueError, RuntimeError, OverflowError):
+        # Invalid pace evidence must never turn into an unbounded correction.
+        # The unchanged waveform will still face the ordinary local gate.
+        return waveform
+    active_speed = active_pace_correction_speed(
+        active_duration,
+        text,
+        target_cps=TARGET_CPS,
+        prior_speed=pace_speed,
+        min_total_speed=MIN_PACE_SPEED,
+    )
+    if active_speed < 1.0:
+        print(
+            "[BlueMagpie] active pace correction "
+            f"active_duration={active_duration:.3f} rate={active_speed:.6f} "
+            f"combined_rate={pace_speed * active_speed:.6f}"
+        )
+    return _apply_speed(waveform, active_speed)
 
 
 def _speaker_anchor_array(centroid: torch.Tensor) -> np.ndarray:

production.py

@@ -968,6 +968,53 @@ def target_pace_speed(
     return min(1.0, max(float(min_speed), actual_seconds / target_seconds))
 
 
+def active_pace_correction_speed(
+    active_duration_seconds: float,
+    text: str,
+    *,
+    target_cps: float,
+    prior_speed: float = 1.0,
+    min_total_speed: float = 0.80,
+) -> float:
+    """Return a second stretch rate from active-voice duration.
+
+    ``prior_speed`` is the rate already applied by ``target_pace_speed``.
+    Successive pitch-preserving stretch rates multiply, so the second rate is
+    floored at ``min_total_speed / prior_speed``.  Invalid evidence and audio
+    that is already at or below the target active CPS fail safely to ``1.0``;
+    this helper never speeds audio up.
+    """
+
+    units = count_speech_units(text)
+    try:
+        active_seconds = float(active_duration_seconds)
+        target = float(target_cps)
+        previous_rate = float(prior_speed)
+        total_floor = float(min_total_speed)
+    except (TypeError, ValueError, OverflowError):
+        return 1.0
+    if (
+        units <= 0
+        or not math.isfinite(active_seconds)
+        or active_seconds <= 0.0
+        or not math.isfinite(target)
+        or target <= 0.0
+        or not math.isfinite(previous_rate)
+        or not 0.0 < previous_rate <= 1.0
+        or not math.isfinite(total_floor)
+        or not 0.0 < total_floor <= 1.0
+    ):
+        return 1.0
+
+    desired_rate = active_seconds * target / float(units)
+    if not math.isfinite(desired_rate) or desired_rate >= 1.0:
+        return 1.0
+    remaining_floor = total_floor / previous_rate
+    if remaining_floor >= 1.0:
+        return 1.0
+    return min(1.0, max(remaining_floor, desired_rate))
+
+
 def duration_hard_stop_steps(
     expected_steps: int,
     *,

tests/test_production.py

@@ -7,6 +7,7 @@ from torch import nn
 
 from production import (
     StopHysteresisController,
+    active_pace_correction_speed,
     candidate_local_score,
     candidate_transition_score,
     compare_asr_text,
@@ -226,6 +227,78 @@ def test_target_pace_speed_slows_completed_audio_without_extending_generation():
     assert target_pace_speed(2500, 1000, text, target_cps=4.0) == 1.0
 
 
+def test_active_pace_correction_uses_active_duration_formula():
+    text = "一二三四五六七八"
+
+    assert active_pace_correction_speed(
+        1.8,
+        text,
+        target_cps=4.0,
+        prior_speed=1.0,
+    ) == pytest.approx(0.9)
+
+
+def test_active_pace_correction_never_speeds_up_slow_audio():
+    assert active_pace_correction_speed(
+        2.2,
+        "一二三四五六七八",
+        target_cps=4.0,
+        prior_speed=1.0,
+    ) == 1.0
+
+
+def test_active_pace_correction_respects_combined_stretch_cap():
+    text = "一二三四五六七八"
+    second_rate = active_pace_correction_speed(
+        1.0,
+        text,
+        target_cps=4.0,
+        prior_speed=0.9,
+        min_total_speed=0.8,
+    )
+
+    assert second_rate == pytest.approx(0.8 / 0.9)
+    assert 0.9 * second_rate == pytest.approx(0.8)
+    assert active_pace_correction_speed(
+        1.0,
+        text,
+        target_cps=4.0,
+        prior_speed=0.8,
+        min_total_speed=0.8,
+    ) == 1.0
+
+
+@pytest.mark.parametrize(
+    ("active_duration", "text", "target_cps", "prior_speed", "minimum"),
+    [
+        (0.0, "完整文字", 4.0, 1.0, 0.8),
+        (-1.0, "完整文字", 4.0, 1.0, 0.8),
+        (float("nan"), "完整文字", 4.0, 1.0, 0.8),
+        (float("inf"), "完整文字", 4.0, 1.0, 0.8),
+        (1.0, "", 4.0, 1.0, 0.8),
+        (1.0, "完整文字", 0.0, 1.0, 0.8),
+        (1.0, "完整文字", 4.0, 0.0, 0.8),
+        (1.0, "完整文字", 4.0, float("nan"), 0.8),
+        (1.0, "完整文字", 4.0, 1.0, 0.0),
+        (1.0, "完整文字", 4.0, 1.0, float("nan")),
+    ],
+)
+def test_active_pace_correction_invalid_evidence_fails_safe(
+    active_duration,
+    text,
+    target_cps,
+    prior_speed,
+    minimum,
+):
+    assert active_pace_correction_speed(
+        active_duration,
+        text,
+        target_cps=target_cps,
+        prior_speed=prior_speed,
+        min_total_speed=minimum,
+    ) == 1.0
+
+
 def test_finish_audio_fades_endpoint_and_appends_silence():
     output = finish_audio(
         np.ones(10, dtype=np.float32),

tests/test_release_pins.py

@@ -242,6 +242,41 @@ def test_app_reverifies_the_post_join_speed_adjusted_whole_waveform():
     assert "RELEASE_SPEAKER_TRIGGER_SECONDS" in source
 
 
+def test_chunk_generation_corrects_active_pace_after_total_duration_pace():
+    source = (ROOT / "app.py").read_text(encoding="utf-8")
+    tree = ast.parse(source)
+    functions = {
+        node.name: node
+        for node in tree.body
+        if isinstance(node, ast.FunctionDef)
+    }
+    generate_source = ast.get_source_segment(source, functions["_generate_chunk"])
+
+    assert generate_source is not None
+    total_pace_index = generate_source.index("pace_speed = target_pace_speed(")
+    first_stretch_index = generate_source.index(
+        "waveform = _apply_speed(audio, pace_speed)"
+    )
+    active_measure_index = generate_source.index(
+        "active_voiced_duration_seconds(waveform, SR)"
+    )
+    active_pace_index = generate_source.index(
+        "active_speed = active_pace_correction_speed("
+    )
+    second_stretch_index = generate_source.index(
+        "return _apply_speed(waveform, active_speed)"
+    )
+    assert (
+        total_pace_index
+        < first_stretch_index
+        < active_measure_index
+        < active_pace_index
+        < second_stretch_index
+    )
+    assert "prior_speed=pace_speed" in generate_source
+    assert "min_total_speed=MIN_PACE_SPEED" in generate_source
+
+
 def test_whole_candidate_qualification_uses_the_exact_return_assembler_after_local_pass():
     source = (ROOT / "app.py").read_text(encoding="utf-8")
     tree = ast.parse(source)