Maskinoversættelse · Engelsk original

Smart Turn - End- of- Turn Detection

p99 · VAP - Modeller

Smart Turn v3.2 svar på et spørgsmål efter den VAD rapporterer en pause: er højttaleren færdig, eller er de midt-sætning? Det lytter til lyden selv - prosodi, tempo, intonation - snarere end en udskrift, dækker 23 sprog, og kører en gang pr. pause på den sidste 8 sekunder af drejning. Vægten er den officielle Pipecat Smart Turn v3.2 frigivelse (BSD-2-Clause), udarbejdet til CoreML for Apple-platforme og eksporteret til ONNX for Tale Core.

Sådan virker det

Smart Turn er ikke en VAD og registrerer ikke tale alene. Det er parret med streaming Silero VAD, som bestemmer hvornår man skal spørge. Med en klassifikator vedhæftet, en bekræftet pause bliver et spørgsmål snarere end en dom:

1. Spørg én gang pr. pause. Når Silero bekræfter en pause (minSilenceDuration Efter offset tærskel), giver processoren klassifikatoren lyden af drejningen indtil videre - fra 0.5 s før VAD debut op til den nuværende stykke, begrænset på de sidste 8 sekunder.
2. Komplet. Sandsynlighed på eller over threshold (0.5): .speechEnded Brand som sædvanlig.
3. Vent. Under tærsklen forbliver segmentet åbent. Hvis højttaleren genoptager, fortsætter det samme segment - intet sekund .speechStarted - og den næste bekræftede pause spørger igen med den længere drejning.
4. Stille kasket. Hvis stilheden når maxSilenceDuration (2.0 s, målt fra starten af pausen), segmentet slutter alligevel, så en højttaler, der kører ud stadig får et svar. Segmentet er endTime er hvor talen stoppede, ikke når låget udløb.

flush() afregner et holdt segment i slutningen af stream og reset() Rydder det. En klassifikator, der kaster tæller som "komplet", så en mislykket model aldrig stopper samtalen. isHoldingTurn rapporterer tilbageholdelsestilstand og lastTurnCompletionProbability Det seneste svar.

Model

Eksporten omfattede Whisper log- mel frontend, herunder kurveformens normalisering af opstrøms modellen blev trænet med, så opkaldere passerer rå lyd - der er ingen feature udvinding i Swift eller C++.

Præstation

Nøjagtighed måles på 1,000 klip fra opstrøms testsæt; CoreML og fp32 ONNX eksport matcher opstrøms fp32 model nøjagtigt på disse klip. Latency er et 8- andet vindue på en Apple M5 Pro. Et opkald per pause tilføjer intet mærkbar til pause VAD allerede ventede på.

Swift API

Kontrol af skud på en registreret udtale:

import SpeechVAD

let turn = try await SmartTurnModel.fromPretrained()
try turn.prewarm()   // compile the graph before the first real pause

let probability = try turn.turnCompleteProbability(
    audio: utterance, sampleRate: 16_000)
if probability >= SmartTurnModel.defaultThreshold {
    // finished turn — reply now
}

Vedhæftet streaming VAD, så hver bekræftet pause er kontrolleret, før et segment slutter:

let vad = try await SileroVADModel.fromPretrained(engine: .coreml)
let turn = try await SmartTurnModel.fromPretrained()

let processor = StreamingVADProcessor(
    model: vad,
    config: .sileroDefault,
    turnCompletion: turn,
    turnCompletionConfig: TurnCompletionConfig(threshold: 0.5, maxSilenceDuration: 2.0))

for chunk in microphoneChunks {            // Float32 @ 16 kHz
    for event in processor.process(samples: chunk) {
        switch event {
        case .speechStarted(let time): print("speech at \(time)s")
        case .speechEnded(let segment): print("turn \(segment.startTime)–\(segment.endTime)s")
        }
    }
}
let remaining = processor.flush()

SmartTurnModel er i overensstemmelse med TurnCompletionProvider protokol i AudioCommon, så enhver anden klassifikator med samme form kan fastgøres i stedet. fromPretrained(cacheDir:offlineMode:) følger de samme cache og offline regler som de andre modeller.

VoicePipeline

VoicePipeline tager den samme klassifikator, så en stemme agent stopper skære folk ud uden nogen ændring til sin STT, TTS eller VAD setup. To PipelineConfig felter og en metode wire det i; de kræver speech-swift v0.0.27 eller senere (SpeechCore.xcframework fra speech-core v0.0.14).

import SpeechCore
import SpeechVAD

let smartTurn = try await SmartTurnModel.fromPretrained()
try smartTurn.prewarm()

var config = PipelineConfig()
config.turnCompletionThreshold = 0.5   // pause ends the turn when p >= this
config.turnCompletionMaxSilence = 2.0  // seconds of silence that end a held turn anyway; 0 = never

let pipeline = VoicePipeline(stt: stt, tts: tts, vad: vad, config: config, onEvent: { print($0) })
pipeline.setTurnCompletion(smartTurn)   // before start(); nil detaches
pipeline.start()

Med en klassifikator vedhæftet, en VAD pause kun slutter brugerens tur, når sandsynligheden når tærsklen; under det rørledningen holder lytte, tale, der genoptager fortsætter den samme tur (ingen anden speechStarted), og turnCompletionMaxSilence ender den hold turn alligevel. Eager STT respekterer veto, og klassifikatoren kører en gang per pause på lydtråden, så ring prewarm() efter indladning.

Tunering

Silero 'er minSilenceDuration stadig bestemmer, hvornår en pause er bekræftet, og derfor når klassifikatoren bliver spurgt. prewarm() efter indlæsning, så den første virkelige pause ikke betaler for grafkompilering.

CLI-brug

# Probability, complete/incomplete verdict and inference time for one utterance
speech turn utterance.wav

# Custom threshold, JSON output
speech turn utterance.wav --threshold 0.7 --json

# Local bundle, no download
speech turn utterance.wav --model-dir ~/smart-turn-coreml

# Streaming VAD with Smart Turn confirming each pause; mid-sentence pauses merge
speech vad-stream call.wav --smart-turn
speech vad-stream call.wav --smart-turn --turn-threshold 0.6 --turn-max-silence 1.5

speech turn indlæser filen (en eventuel prøvesats), scorer de sidste 8 sekunder og udskriver sandsynligheden, om den rydder tærsklen, og inferens tid. Brug den til at tune tærsklen på dine egne optagelser. Den fulde flag liste er i CLI-reference.

C++ / Android

Tale Core sender den samme model som OnnxSmartTurn for Linux, Windows og Android (kun ONNX Runtime; der er ingen LiteRT variant). VoicePipeline::set_turn_completion() tillægger det før start(); en VAD pause derefter kun slutter brugerens tur, når sandsynligheden når turn_completion_threshold (0.5) og turn_completion_max_silence (2.0 s) ender en holdt drejning alligevel. C API udsætter den samme krog som sc_turn_completion_vtable_t + sc_pipeline_set_turn_completion(), så Kotlin eller Swift værter kan bygge bro over deres egen klassifikator på samme måde som VAD.

#include <speech_core/models/onnx_smart_turn.h>

speech_core::OnnxSmartTurn model("/models/smart-turn-v3.2-int8.onnx");

// Audio of the turn so far at any rate (resampled to 16 kHz internally).
float p = model.turn_complete_probability(turn.data(), turn.size(), rate);

// Or let the pipeline ask it on every VAD pause (before start()).
pipeline.set_turn_completion(&model);

Den speech CLI af Tale Core scorer en optagelse på samme måde som på macOS:

speech download-models        # fetches the int8 graph with the other ONNX models
speech turn recording.wav --threshold 0.5 --json

Model filer, C API kontrakt og CLI er dokumenteret på Talekerner side og i arkivet docs / models.md.

Model Downloads

Kilde

• Kilder / SpeechVAD — SmartTurnModel og StreamingVADProcessor
• Docs / model / smart-turn-v3.md - modelnoter
• docs / inferens / smart- turn.md - inferens og tuning
• speech-core docs / models.md — OnnxSmartTurn
• Upstream: pipecat- ai / smart- turn / pipecat- ai / smart-turn-v3 (Daglig / Pipecat, BSD-2-Clause)