Maskinöversättning · Engelskt original

Smart Turn - End-of-Turn Detection

p99 VAP -- Models

Smart Turn v3.2 svarar på en fråga efter VAD rapporterar en paus: har högtalaren avslutats, eller är de mitten av meningen? Det lyssnar på ljudet självt - prosody, takt, intonation - snarare än ett utskrift, täcker 23 språk och körs en gång per paus på sista 8 sekunder av turen. Vikterna är den officiella pipecat Smart Turn v3.2 frisläppande (BSD-2-Clause), sammanställd till CoreML för Apple-plattformar och exporteras till ONNX För tal Core.

Hur det fungerar

Smart Turn är inte en VAD och detekterar inte tal på egen hand. Det är parat med streaming Silero VAD, som bestämmer sig för att fråga. Med en klassificeringsansluten blir en bekräftad paus en fråga snarare än en dom:

1. Fråga en gång per paus. När Silero bekräftar en paus (minSilenceDuration efter kompensationströskeln) gör processorn klassificerar ljudet av svängningen så långt - från 0,5 s före VAD inställd upp till den nuvarande chunk, kapad på de senaste 8 sekunderna.
2. Complete. Sannolikhet vid eller över threshold (0.5): .speechEnded bränder som vanligt.
3. Hold. Nedanför tröskeln förblir segmentet öppet. Om högtalaren återupptar fortsätter samma segment - ingen andra .speechStarted - och nästa bekräftade paus frågar igen med den längre svängningen.
4. Silence cap. Om tystnaden når maxSilenceDuration (2,0 s, mätt från början av pausen), slutar segmentet ändå, så en högtalare som spårar av fortfarande får ett svar. segmentets endTime är där talet stannade, inte när locket löpte ut.

flush() avgör ett hållet segment i slutet av strömmen och reset() rensar det. En klassificerare som kastar räknas som "fullständig", så en misslyckad modell stallar aldrig konversationen. isHoldingTurn rapporterar hold state och lastTurnCompletionProbability det senaste svaret.

Modell

Exporten bäddade in Whisper log-mel front-end, inklusive vågform normalisering uppströms modellen utbildades med, så kallare passerar rå ljud - det finns ingen funktion utvinning i Swift eller C++.

Prestanda

Noggrannhet mäts på 1,000-klipp från den uppströms testuppsättningen; CoreML och fp32 ONNX export matchar den uppströmda fp32 modellen exakt på dessa klipp. Latency är en 8 sekund fönster på en Apple M5 Pro. En samtal per paus lägger inget märkbart till pausen VAD redan väntade på.

Swift API

En-shot check på en inspelad yttrande:

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
}

Bifogad till streaming VAD, så varje bekräftad paus kontrolleras innan ett segment slutar:

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 överensstämmer med TurnCompletionProvider-protokollet i AudioCommon, så att alla andra klassificerare med samma form kan fästas istället. fromPretrained(cacheDir:offlineMode:) följer samma cache och offline regler som de andra modellerna.

VoicePipeline

VoicePipeline tar samma klassificerare, så en röstagent slutar skära människor utan någon förändring till STT, TTS eller VAD-inställningen. PipelineConfig fält och en metod trådar in den; de kräver speech-swift v0.0.27 eller senare (SpeechCore.xcframework från 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 klassificerare bifogad slutar en VAD-paus bara användarens tur när sannolikheten når tröskeln; under den fortsätter rörledningen att lyssna, tal som återupptar fortsätter samma sväng (ingen sekund). speechStarted), och turnCompletionMaxSilence slutar den hållna turen ändå. Eager STT respekterar veto, och klassificeraren körs en gång per paus på ljudtråden, så ring prewarm() Efter lastning.

Tuning

Silero minSilenceDuration bestämmer fortfarande när en paus bekräftas, och därför när klassificeraren tillfrågas. Call prewarm() efter lastning så att den första riktiga pausen inte betalar för grafkompilering.

CLI Användning

# 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 laddar filen (någon provfrekvens), gör de senaste 8 sekunderna och skriver ut sannolikheten, oavsett om det rensar tröskeln och inferenstiden. Använd den för att ställa in tröskelvärdet på dina egna inspelningar. Den fullständiga flagglistan finns i CLI-referensen .

C++ / Android

Speech Core levererar samma modell som OnnxSmartTurn för Linux, Windows och Android (ONNX Runtime endast; det finns ingen LiteRT variant). VoicePipeline::set_turn_completion() fäster den innan start()En VAD paus slutar sedan bara användarens tur när sannolikheten når turn_completion_threshold (0.5) och turn_completion_max_silence (2.0) slutar en hållen sväng ändå. C API exponerar samma krok som sc_turn_completion_vtable_t + sc_pipeline_set_turn_completion()Kotlin eller Swift värdar kan överbrygga sin egen klassificerare på samma sätt 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 gör en inspelning på samma sätt 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 kontrakt och CLI dokumenteras på sidan Speech Core och i förvarets docs/models.md.

Modell nedladdningar

Källa

• Källor/SpeechVAD -- SmartTurnModel och StreamingVADProcessor
• docs/models/smart-turn-v3.md -- modellanteckningar
• docs/inference/smart-turn.md -- inferens och tuning
• speech-core docs/models.md -- OnnxSmartTurn
• Uppströms: pipecat-ai/smart-turn/pipecat–ai/smart-turn-v3 (Daily/Pipecat, BSD-2-Clause)