3. Turn Boundary Detection from Frame-Level Speech Labels

Problem

A streaming speech model classifies each short audio frame as speech or silence, but you can't flag a turn boundary on the very first silent or speaking frame — a single flickering frame (a breath, a click) would create false turn boundaries constantly.

Real systems require a run of consecutive frames in one state before committing to a transition, then a run of consecutive frames in the other state before committing back. Given a full stream of per-frame labels and the two thresholds, detect every completed turn.

Source: src/3_turn_boundary_detector.py

def detect_turns(frame_labels: list[int], start_threshold: int, end_threshold: int) -> list[tuple[int, int]]:
    ...

Examples:
>>> detect_turns([0, 1, 1, 0, 0], 2, 2)
[(1, 2)]

>>> detect_turns([0, 0, 0], 1, 1)
[]

Step-by-Step Approach

1. Track a small state machine with two states, idle and speaking, plus two run counters: speech_run and silence_run.
2. On a speech frame, increment speech_run and reset silence_run to 0. If currently idle and speech_run just reached start_threshold, transition to speaking and record the turn's start as i - start_threshold + 1 — the first frame of the qualifying run, not the frame where the threshold was crossed.
3. On a silence frame, increment silence_run and reset speech_run to 0. If currently speaking and silence_run just reached end_threshold, transition back to idle and close the turn at i - end_threshold — the last speech frame before the silence run began.
4. Append each closed (start, end) pair to the results list as soon as it closes; don't wait until the end of the stream to build them.
5. After the loop, check whether the state machine is still speaking — the stream ended before a full silence run closed the turn. If so, close it at the last frame index so no in-progress turn is silently dropped.
6. Handle the trivial cases: a stream with no speech at all never reaches start_threshold and returns an empty list; thresholds of 1 make every single frame flip the state immediately, which is a valid degenerate case, not a special one.

The key insight is hysteresis: entering and leaving "speaking" both require sustained evidence, and the recorded boundary always points back to where the sustained run actually began, not to the frame where the threshold counter happened to tick over.

Reference solution

def detect_turns(frame_labels: list[int], start_threshold: int, end_threshold: int) -> list[tuple[int, int]]:
    state = "idle"
    speech_run = 0
    silence_run = 0
    turn_start = None
    turns: list[tuple[int, int]] = []
    for i, label in enumerate(frame_labels):
        if label == 1:
            speech_run += 1
            silence_run = 0
            if state == "idle" and speech_run == start_threshold:
                # crossed the hysteresis threshold: the run's first frame is the true start
                state = "speaking"
                turn_start = i - start_threshold + 1
        else:
            silence_run += 1
            speech_run = 0
            if state == "speaking" and silence_run == end_threshold:
                # last speech frame is end_threshold frames before this one
                state = "idle"
                turns.append((turn_start, i - end_threshold))
                turn_start = None
    if state == "speaking":
        # stream ended mid-turn: close it at the final frame
        turns.append((turn_start, len(frame_labels) - 1))
    return turns

Key Functions & Tricks

• Two independent run counters — speech_run and silence_run, each reset by the opposite label, drive the hysteresis without needing a lookback window.
• i - start_threshold + 1 — back-computes the true start index from the frame where the threshold check fires.
• i - end_threshold — back-computes the last speech frame from the frame where the closing silence run completes.
• State variable gating the transition checks — if state == "idle" / if state == "speaking" prevents re-triggering a transition mid-run.
• Post-loop flush — closes any turn still open when the input ends, matching how a real system forces turn.end at stream close.

How to Recognize This Pattern