Smart Turn — बारी-समाप्ति पहचान

Smart Turn v3.2 VAD द्वारा विराम बताए जाने के बाद एक ही प्रश्न का उत्तर देता है: क्या वक्ता बोल चुका है, या वाक्य के बीच में है? यह ट्रांसक्रिप्ट के बजाय ऑडियो को ही सुनता है — प्रोसोडी, गति, स्वर-लहरी — 23 भाषाओं को कवर करता है, और हर विराम पर एक बार, बारी के अंतिम 8 सेकंड पर चलता है। वेट्स Pipecat की आधिकारिक Smart Turn v3.2 रिलीज़ (BSD-2-Clause) हैं, जो Apple प्लेटफ़ॉर्म के लिए CoreML में कंपाइल और Speech Core के लिए ONNX में एक्सपोर्ट किए गए हैं।

यह कैसे काम करता है

Smart Turn कोई VAD नहीं है और स्वयं वाक् का पता नहीं लगाता। इसे स्ट्रीमिंग Silero VAD के साथ जोड़ा जाता है, जो तय करता है कि कब पूछना है। क्लासिफ़ायर जुड़ने पर पुष्ट विराम निर्णय नहीं, बल्कि प्रश्न बन जाता है:

1. हर विराम पर एक बार पूछें। जब Silero विराम की पुष्टि करता है (ऑफ़सेट सीमा के बाद minSilenceDuration), प्रोसेसर अब तक की बारी का ऑडियो क्लासिफ़ायर को देता है — VAD आरंभ से 0.5 सेकंड पहले से वर्तमान चंक तक, अधिकतम अंतिम 8 सेकंड।
2. पूर्ण। संभावना threshold (0.5) पर या उससे ऊपर: .speechEnded सामान्य रूप से फ़ायर होता है।
3. रोकें। सीमा से नीचे सेगमेंट खुला रहता है। यदि वक्ता फिर बोलता है, तो वही सेगमेंट जारी रहता है — दूसरा .speechStarted नहीं — और अगला पुष्ट विराम लंबी बारी के साथ फिर पूछता है।
4. मौन की सीमा। यदि मौन maxSilenceDuration (2.0 सेकंड, विराम की शुरुआत से मापा गया) तक पहुँचता है, तो सेगमेंट वैसे भी समाप्त हो जाता है, ताकि धीरे-धीरे चुप होने वाले वक्ता को भी उत्तर मिले। सेगमेंट का endTime वहीं होता है जहाँ वाक् रुकी, न कि जहाँ सीमा समाप्त हुई।

flush() स्ट्रीम के अंत में रोके गए सेगमेंट को निपटाता है और reset() उसे साफ़ करता है। त्रुटि फेंकने वाला क्लासिफ़ायर "पूर्ण" माना जाता है, इसलिए विफल मॉडल बातचीत को कभी नहीं रोकता। isHoldingTurn रोक की स्थिति बताता है और lastTurnCompletionProbability सबसे हालिया उत्तर।

मॉडल

एक्सपोर्ट में Whisper का log-mel फ्रंट-एंड शामिल है, जिसमें वह वेवफ़ॉर्म सामान्यीकरण भी है जिस पर अपस्ट्रीम मॉडल को प्रशिक्षित किया गया था, इसलिए कॉलर कच्चा ऑडियो पास करते हैं — Swift या C++ में कोई फ़ीचर निष्कर्षण नहीं है।

प्रदर्शन

सटीकता अपस्ट्रीम टेस्ट सेट की 1,000 क्लिप पर मापी गई है; CoreML और fp32 ONNX एक्सपोर्ट उन क्लिप पर अपस्ट्रीम fp32 मॉडल से पूरी तरह मेल खाते हैं। विलंबता Apple M5 Pro पर एक 8-सेकंड विंडो की है। प्रति विराम एक कॉल उस विराम में कुछ भी ध्यान देने योग्य नहीं जोड़ती जिसकी VAD पहले ही प्रतीक्षा कर चुका है।

Swift API

रिकॉर्ड किए गए कथन की एक बार की जाँच:

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
}

स्ट्रीमिंग VAD से जुड़ा हुआ, ताकि सेगमेंट समाप्त होने से पहले हर पुष्ट विराम की जाँच हो:

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 AudioCommon के TurnCompletionProvider प्रोटोकॉल का पालन करता है, इसलिए उसी आकार का कोई भी अन्य क्लासिफ़ायर इसकी जगह जोड़ा जा सकता है। fromPretrained(cacheDir:offlineMode:) अन्य मॉडलों के समान कैश और ऑफ़लाइन नियमों का पालन करता है।

VoicePipeline

VoicePipeline वही क्लासिफ़ायर स्वीकार करता है, इसलिए वॉइस एजेंट अपनी STT, TTS या VAD सेटिंग बदले बिना लोगों को बीच में टोकना बंद कर देता है। PipelineConfig के दो फ़ील्ड और एक मेथड इसे जोड़ते हैं; इनके लिए speech-swift v0.0.27 या नया (speech-core v0.0.14 का SpeechCore.xcframework) चाहिए।

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()

क्लासिफ़ायर जुड़ा होने पर VAD विराम उपयोगकर्ता की बारी तभी समाप्त करता है जब संभावना थ्रेशोल्ड तक पहुँचे; उससे नीचे पाइपलाइन सुनती रहती है, दोबारा शुरू हुई बोली उसी बारी को जारी रखती है (दूसरा speechStarted नहीं आता), और turnCompletionMaxSilence रोकी गई बारी को वैसे भी समाप्त कर देता है। Eager STT भी इस रोक का पालन करता है, और क्लासिफ़ायर ऑडियो थ्रेड पर हर विराम में एक बार चलता है, इसलिए लोड करने के बाद prewarm() कॉल करें।

ट्यूनिंग

Silero का minSilenceDuration अब भी तय करता है कि विराम की पुष्टि कब होती है, और इसलिए क्लासिफ़ायर से कब पूछा जाता है। लोड करने के बाद prewarm() कॉल करें ताकि पहले वास्तविक विराम को ग्राफ़ कंपाइलेशन की कीमत न चुकानी पड़े।

CLI उपयोग

# 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 फ़ाइल (कोई भी सैंपल रेट) लोड करता है, अंतिम 8 सेकंड को स्कोर करता है और संभावना, सीमा पार हुई या नहीं, तथा अनुमान समय प्रिंट करता है। अपनी रिकॉर्डिंग पर सीमा ट्यून करने के लिए इसका उपयोग करें। पूरी फ़्लैग सूची CLI संदर्भ में है।

C++ / Android

Speech Core वही मॉडल OnnxSmartTurn के रूप में Linux, Windows और Android के लिए देता है (केवल ONNX Runtime; कोई LiteRT संस्करण नहीं)। VoicePipeline::set_turn_completion() इसे start() से पहले जोड़ता है; फिर VAD विराम उपयोगकर्ता की बारी तभी समाप्त करता है जब संभावना turn_completion_threshold (0.5) तक पहुँचे, और turn_completion_max_silence (2.0 सेकंड) रोकी गई बारी को वैसे भी समाप्त कर देता है। C API वही हुक sc_turn_completion_vtable_t + sc_pipeline_set_turn_completion() के रूप में देता है, इसलिए Kotlin या Swift होस्ट अपना क्लासिफ़ायर 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 Core का speech CLI रिकॉर्डिंग को macOS की तरह ही स्कोर करता है:

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

मॉडल फ़ाइलें, C API अनुबंध और CLI Speech Core पेज और रिपॉज़िटरी के docs/models.md में प्रलेखित हैं।

मॉडल डाउनलोड

स्रोत

• Sources/SpeechVAD — SmartTurnModel और StreamingVADProcessor
• docs/models/smart-turn-v3.md — मॉडल नोट्स
• docs/inference/smart-turn.md — अनुमान और ट्यूनिंग
• speech-core docs/models.md — OnnxSmartTurn
• अपस्ट्रीम: pipecat-ai/smart-turn / pipecat-ai/smart-turn-v3 (Daily / Pipecat, BSD-2-Clause)