Maskinoversettelse · Engelsk original

Smart Turn — Slutt på tur-deteksjon

p99 · VAP — Modeller

Smart Turn v3.2 Svar på et spørsmål etter VAD rapporterer en pause: har høyttaleren ferdig, eller er de midt-sentens? Den lytter til lyden selv - prosodi, tempo, intonasjon - i stedet for en transkripsjon, dekker 23 språk, og kjører én gang per pause på den siste 8 sekunder av turen. Vektene er den offisielle Pipecat Smart Turn v3.2 frigjøring (BSD-2-Clause), samlet til CoreML for Apple-plattformer og eksportert til ONNX For talekjernen.

Hvordan det fungerer

Smart Turn er ikke en VAD og registrerer ikke tale på egen hånd. Det er koblet til streaming Silero VAD, som bestemmer når du skal spørre. Med en klassifier vedlagt, blir en bekreftet pause et spørsmål i stedet for en dom:

1. Spør en gang per pause. Når Silero bekrefter en pause (minSilenceDuration etter offset-grensen), tar prosessoren i seg lyden av turen så langt - fra 0,5 s før VAD starter opp til den aktuelle delen, dekket i de siste 8 sekunder.
2. Ferdig. Sannsynlighet ved eller over threshold (0,5): .speechEnded branner som vanlig.
3. Hold. Nedenfor terskelen forblir segmentet åpent. Hvis høyttaleren fortsetter, fortsetter det samme segmentet - ingen andre .speechStarted - og neste bekreftede pause spør igjen med den lengre turen.
4. Silence cap. Hvis stillhet når maxSilenceDuration (2.0 s, målt fra starten av pausen), avsluttes segmentet uansett, så en høyttaler som går av får fortsatt et svar. segmentets endTime er der tale stoppet, ikke når lokket utløpte.

flush() bosettes et holdt segment ved enden av strømmen og reset() En klasse som kaster teller som - komplett - så en sviktende modell aldri stopper samtalen. isHoldingTurn rapporterer holdstaten og lastTurnCompletionProbability Det siste svaret.

Modell

Eksporten innebygde Whisper log-mel front-end, inkludert bølgeform normalisering oppstrømsmodellen ble trent med, så callers passerer rå lyd - det er ingen funksjon ekstraksjon i Swift eller C++.

Ytelse

Nøyaktighet måles på 1,000 klipp fra oppstrømstestsettet; CoreML og fp32 ONNX eksporten samsvarer oppstrøms fp32-modellen nøyaktig på disse klippene. Latensen er et 8 -sekunder vindu på en Apple M5 Pro. Ett kall per pause legger ikke merkbar til pausen som VAD allerede ventet på.

Swift API

One-shot sjekk på en registrert uttalelse:

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
}

Festet til streaming VAD, så hver bekreftet pause er kontrollert 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 samsvar med TurnCompletionProvider protokoll i AudioCommon, så enhver annen klassifisering med samme form kan festes i stedet. fromPretrained(cacheDir:offlineMode:) følger den samme cache og offline regler som de andre modellene.

VoicePipeline

VoicePipeline tar samme klasse, så en stemmeagent slutter å kutte av mennesker uten å endre STT, TTS eller VAD oppsett. To PipelineConfig felt og én metodetråd det i; de krever speech-swift v0.0.27 eller senere (RequentCore.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 klasseifier vedlagt, en VAD pause bare avslutter brukerens tur når sannsynligheten når terskelen; under den fortsetter rørledningen å lytte, tale som fortsetter den samme svingen (ingen andre speechStarted), og turnCompletionMaxSilence avslutter den holdne turen uansett. Eager STT respekterer veto, og klassifieren kjører én gang per pause på lydtråden, så ring prewarm() etter lasting.

Tuning

Sileros minSilenceDuration bestemmer fortsatt når pausen er bekreftet, og derfor når klassifieren blir spurt. Ring prewarm() etter lasting så betaler den første virkelige pausen ikke for grafsammenstilling.

CLI bruk

# 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 laster filen (alle prøvehastigheter), scorer de siste 8 sekunder og skriver ut sannsynligheten, om den fjerner terskelen, og inferenstiden. Bruk den til å justere terskelen på dine egne opptak. Den fulle flagglisten er i CLI referanse.

C++ / Android

Tale Core skip den samme modellen som OnnxSmartTurn Linux, Windows og Android (bare ONNX Runtime; det er ingen LiteRT-variant). VoicePipeline::set_turn_completion() Legg den før start(); en VAD pause så bare avslutter brukerens tur når sannsynligheten når turn_completion_threshold (0.5) og turn_completion_max_silence (2.0 s) avslutter en holdt sving uansett. C API avslører samme krok som sc_turn_completion_vtable_t + sc_pipeline_set_turn_completion(), så Kotlin eller Swift verter kan slå sin egen klassifier på samme måte 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);

speech CLI of Speech Core Scorer en innspilling på samme måte som på macOS:

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

Modellfiler, C API kontrakten og CLI er dokumentert på talekjernen siden og i lagerets docs/models.md.

Modellnedlastninger

Kilde

• Kilde/ServiceVAD — SmartTurnModel og StreamingVADProcessor
• docs/models/smart-turn-v3.md - modellnoter
• docs/inferens/smart-turn.md - inferens og tuning
• speech-core docs/models.md — OnnxSmartTurn
• Upstream: pipecat-ai/smart-turn / pipekat-ai /smart-turn-v3 (Daglig / Pipecat, BSD-2-Clause)