Automatische vertaling · Engels origineel

Smart Turn

p99 · VAP › Modellen

Smart Turn v3.2 beantwoordt één vraag na de VAD meldt een pauze: is de luidspreker klaar, of zijn ze halverwege de zin? Hij luistert naar de audio zelf, luistert naar het prosodie, tempo, intonatie en niet naar een transcript, beslaat 23 talen, en draait één keer per pauze op de laatste 8 seconden van de beurt. De gewichten zijn de officiële Pipecat Smart Turn v3.2 release (BSD-2-Clause), gecompileerd naar CoreML voor Apple platforms en geëxporteerd naar ONNX voor Speech Core.

Hoe het werkt

Smart Turn is geen VAD en detecteert geen spraak op zich. Het wordt gekoppeld aan de streaming Silero VAD, die bepaalt wanneer het moet worden gevraagd. Met een classifier wordt een bevestigde pauze eerder een vraag dan een uitspraak:

1. Vraag het één keer per pauze. Wanneer Silero een pauze bevestigt (minSilenceDuration Na de offsetdrempel geeft de processor de klassifier de audio van de turn tot nu toe uit 0.5 s voordat de VAD begint tot de huidige chunk, afgetopt op de laatste 8 seconden.
2. Voltooien. Waarschijnlijkheid op of boven threshold (0,5): .speechEnded branden zoals gewoonlijk.
3. Houd. Onder de drempel blijft het segment open. Als de spreker weer doorgaat, gaat hetzelfde segment door met een nulseconde .speechStarted .De volgende bevestigde pauze vraagt opnieuw met de langere draai.
4. Silence cap. Als de stilte maxSilenceDuration (2.0 s, gemeten vanaf het begin van de pauze), eindigt het segment toch, dus een spreker die trailt krijgt nog steeds een antwoord. De segment endTime is waar de toespraak is gestopt, niet wanneer de dop is verlopen.

flush() een aangehouden segment aan het einde van de stroom vastlegt en reset() Een classifier die gooit telt als "compleet," dus een falend model houdt het gesprek nooit tegen. isHoldingTurn de status van het ruim rapporteert en lastTurnCompletionProbability Het meest recente antwoord.

Model

De export insigned de Whisper log-mel front-end, met inbegrip van de golfvorm normalisatie van het upstream-model werd getraind met, dus bellers passeren ruwe audio .Er is geen functie extractie in Swift of C++.

Prestaties

Nauwkeurigheid wordt gemeten op 1,000 clips van de stroomopwaarts uitgevoerde testset; CoreML en fp32 ONNX De uitvoer komt overeen met de stroomopwaarts fp32 model precies op die clips. 8-tweede venster op een Apple M5 Pro. Een oproep per pauze voegt niets merkbaars toe aan de pauze VAD Ik heb al op gewacht.

Swift API

One-shot check op een geregistreerde uitspraak:

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
}

Aan de streaming VAD bevestigd, zodat elke bevestigde pauze wordt gecontroleerd voordat een segment eindigt:

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 voldoet aan de TurnCompletionProvider protocol in AudioCommon, zodat elke andere classifier met dezelfde vorm kan worden aangesloten. fromPretrained(cacheDir:offlineMode:) volgt dezelfde cache en offline regels als de andere modellen.

VoicePipeline

VoicePipeline neemt dezelfde classifier, zodat een spraakagent stopt met het afsnijden van mensen zonder enige verandering in zijn STT, TTS of VAD instellen. Twee PipelineConfig velden en één methode draad het in; ze vereisen speech-swift v0.0.27 of later (SpeechCore.xcframework van 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()

Met een klassifier eraan is een VAD pauze is alleen de beurt van de gebruiker beëindigd wanneer de waarschijnlijkheid de drempel bereikt; eronder blijft de pijpleiding luisteren, de spraak die weer dezelfde beurt doorzet (geen seconde speechStarted), en turnCompletionMaxSilence eindigt toch de gedraaide turn. Eager STT respecteert het veto, en de classifier draait eenmaal per pauze op de audiothread, dus bel prewarm() na het laden.

Tuning

Silero's minSilenceDuration bepaalt nog steeds wanneer een pauze wordt bevestigd, en dus wanneer de classifier wordt gevraagd. Call prewarm() na het laden, zodat de eerste echte pauze niet betaalt voor het compileren van de grafiek.

CLI-gebruik

# 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 laadt het bestand (elke sample rate), scoort de laatste 8 seconden en drukt de waarschijnlijkheid af, of het de drempel en de inferentietijd opruimt. Gebruik het om de drempel af te stemmen op uw eigen opnames. De volledige vlaglijst staat in de CLI-referentie.

C++ / Android

Speech Core schepen hetzelfde model als OnnxSmartTurn voor Linux, Windows en Android (alleen ONNX Runtime; er is geen LiteRT variant). VoicePipeline::set_turn_completion() hecht het voor start(); een VAD-pauze eindigt dan alleen de beurt van de gebruiker wanneer de waarschijnlijkheid bereikt turn_completion_threshold (0.5), en turn_completion_max_silence (2.0 s) eindigt toch een aangehouden draai. De C API stelt dezelfde haak bloot als sc_turn_completion_vtable_t + sc_pipeline_set_turn_completion(), zodat Kotlin of Swift hosts hun eigen classifier kunnen overbruggen op dezelfde manier als de 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);

De speech CLI van Speech Core scoort een opname op dezelfde manier als op macOS:

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

Modelbestanden, de C API contract en de CLI zijn gedocumenteerd op de Spraakkern pagina en in de repository docs/models.md.

Modeldownloads

Bron

• Bronnen/SpeechVAD — SmartTurnModel en StreamingVADProcessor
• docs/models/smart-turn-v3.md Modelnoten
• docs/inferentie/smart-turn.md
• speech-core docs/models.md — OnnxSmartTurn
• Upstream: pipecat-ai/smart-turn / pipecat -ai/smart-turn-v3 (Daily / Pipecat, BSD-2-Clause)