Traducere automată · Originalul în engleză

Smart Turn

p99 · VAP

Smart Turn v3.2 răspunde la o întrebare după VAD raportează o pauză: a terminat vorbitorul sau sunt acestea mijlocul-sentinței? ascultă audio în sine prosodie, ritm, intonație . Mai degrabă decât o transcriere, acoperă 23 de limbi, și se execută o dată pe pauză pe ultimele 8 secunde ale turnului.Greutățile sunt Pipecat oficial Smart Turn v3.2 eliberare (BSD-2-Clause), compilată la CoreML pentru platforme Apple și exportată la ONNX pentru Core.

Cum funcționează

Smart Turn nu este un VAD și nu detectează vorbirea pe cont propriu. Este asociat cu streamingul Silero VAD , care decide când să ceară. Cu un calificator atașat, o pauză confirmată devine o întrebare mai degrabă decât un verdict:

1. Întreabă o dată pe pauză. Când Silero confirmă o pauză (minSilenceDuration după pragul de compensare), procesorul pune mâna pe discul audio al rotirii până acum . De la 0.5 s înainte de debutul VAD până la bucata curentă, plafonată la ultimele secunde 8.
2. Complete. Probabilitate la sau peste threshold (0,5): .speechEnded incendii ca de obicei.
3. Stai. Sub prag, segmentul rămâne deschis. În cazul în care vorbitorul reia, același segment continuă .speechStarted În continuare, pauza confirmată cere din nou cu rândul mai lung.
4. Capac de tăcere. Dacă tăcerea atinge maxSilenceDuration (2,0 s, măsurată de la începutul pauzei), segmentul se termină oricum, astfel încât un vorbitor care se retrage încă primește un răspuns. Segmentul endTime este locul unde discursul s-a oprit, nu atunci când capacul a expirat.

flush() stabileşte un segment reţinut la sfârşitul fluxului şi reset() îl curăţă. Un calificator care aruncă contează ca fiind "complet," astfel încât un model eşuat nu întârzie niciodată conversaţia. isHoldingTurn raportează starea de aşteptare şi lastTurnCompletionProbability cel mai recent răspuns.

Model

Exporturile au inclus Whisper log-mel front-end, inclusiv normalizarea formei de undă modelul din amonte a fost instruit cu, astfel încât apelanții trec audio brut Swift sau C++.

Performanță

Acurateţea este măsurată pe clipurile 1,000 din setul de încercări din amonte; CoreML şi fp32 ONNX exporturile se potrivesc cu modelul fp32 în amonte exact pe aceste clipuri. Latenţia este o fereastră 8-secundă pe un Apple M5 Pro. Un apel pe pauză nu adaugă nimic vizibil la pauză VAD deja aşteptat.

Swift API

Verificare cu un singur foc a unei declaraţii:

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
}

Ataşat la streaming VAD, astfel încât fiecare pauză confirmată să fie verificată înainte ca un segment să se încheie:

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 este conform cu TurnCompletionProvider protocol în AudioCommon, astfel încât orice alt clasificator cu aceeași formă poate fi atașat în schimb. fromPretrained(cacheDir:offlineMode:) urmează aceleași reguli cache și offline ca și celelalte modele.

VocePipelină

VoicePipeline ia aceeași clasificare, astfel încât un agent vocal încetează să mai taie oamenii fără nicio modificare a TTS, TTS sau VAD setare.Două PipelineConfig câmpuri și o metodă prin care acesta este conectat; acestea necesită speech-swift v0.0.27 sau mai târziu (S speechCore.xccommework from 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()

Cu un clasament atașat, o pauză VAD se termină doar rândul utilizatorului atunci când probabilitatea atinge pragul; sub aceasta conducta continuă să asculte, vorbire care reia aceeași turnantă (nici o a doua speechStarted), și turnCompletionMaxSilence se termină turnul ținut oricum. Eager STT respectă veto-ul, iar clasamentul rulează o dată pe pauză pe fir audio, astfel încât apelul prewarm() după încărcare.

Tuning

Silero's minSilenceDuration încă decide când se confirmă o pauză, și, prin urmare, atunci când se solicită clasificarea. Call prewarm() după încărcare, astfel încât prima pauză reală nu plătește pentru compilarea grafică.

Utilizarea 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 încarcă fișierul (orice rată de eșantionare), marchează ultimele 8 secunde și imprimă probabilitatea, fie că elimină pragul, și timpul de deducție. Utilizați-l pentru a regla pragul pe propriile înregistrări. Lista completă de pavilion este în CLI de referință.

C++ / Android

Discurs Core nave același model ca OnnxSmartTurn pentru Linux, Windows și Android (numai ONNX Runtime; nu există nicio variantă LiteRT). VoicePipeline::set_turn_completion() Ataşează-l înainte. start(); o pauză VAD apoi se termină doar rândul utilizatorului atunci când probabilitatea ajunge turn_completion_threshold (0.5) și turn_completion_max_silence (2.0 s) se termină un viraj deținut oricum. C API expune același cârlig ca sc_turn_completion_vtable_t + sc_pipeline_set_turn_completion(), astfel încât gazdele Kotlin sau Swift pot pod propriul lor clasificator în același mod ca 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 înscrie o înregistrare la fel ca pe macOS:

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

Model de fișiere, C API Contract și CLI sunt documentate pe Nucleul discursului pagina și în depozitul documente/modele.md.

Modele de descărcări

Sursă

• Surse/SpeechVAD — SmartTurnModel şi StreamingVADProcessor
• docs/modele/smart-turn-v3.md note model
• docs/inference/smart-turn.md
• Documente/modele speech-core.md — OnnxSmartTurn
• Upstream: pipecat-ai/smart-turn / pipe Cat-ai/smart-turn-v3 (Daily/ Pipecat, BSD-2-Clause)