Maskinoversættelse · Engelsk original

Talerdiarisering

Identificer hvem der talte, når i en multi-højttaler optagelse. Fire motorer er tilgængelige: letvægts Pyannote (CLI-standard), full-pipeline Community-1 (CoreML + native PLDA / VBx), streaming Sorterer (CoreML, Neural Engine) og Nemotron 3 (CoreML INT8 eller MLX INT8).

Motorer

Vælg motoren med --engine pyannote (standard) --engine community1, --engine sortformer, eller --engine nemotron3.

Pyannote (standard)

Two-stage rørledning: Pyannote segmentering processer overlappende vinduer med aktivitets-baserede højttaler chaining (Pearson korrelation i overlappende zoner) til at tildele globale højttaler etiketter. Post- hoc WeSpeaker indlejring ekstraktion gør det muligt mål højttaler identifikation via tilmelding lyd.

Community-1 (CoreML + native VBx)

Den fulde Pyannote Community-1 CoreML bundt: 10-anden PyanNet segmentering vinduer fremme hvert sekund, maskeret WeSpeaker Indlejringer fodrer centroid AHC og a 256→128 PLDA transformere, derefter indfødte Swift VBx og begrænset opgave producerer globale klynger. Det returnerer en 256-dimensionelle centroid per opdaget højttaler og understøtter præcise, minimum, eller maksimale højttaler- tæller grænser.

Ssortformer (CoreML)

NVIDIA 's end- to- end neurale diarization model. Direkte forudsiger per- frame højttaler aktivitet for op til 4 højttalere uden separat indlejring eller klyngestadier. Kører på Neural Engine via CoreML med streaming state buffere (FIFO + højttaler cache).

For levende lyd, SortformerStreamingSession kører .streaming Sortformer model trinvis med 16 kHz mono PCM buffere af enhver størrelse. 560 ms lookeahead er tilgængelig, det fremskridt i 480 ms lydtrin; en 5-fil M- serie Neural Engine målt pilot 12.4 m median latens per 500 ms push. Speaker etiketter følger Arrival- Order Speaker Cache i stedet for at omgruppere hvert vindue, og hvert push returnerer en helstrøm snapshot. finish() flushing bufferhale. I model- gated ækvivalens test, endelige segmenter matchede hel- buffer .streaming diarisering inden for omkring en 80 ms ramme.

Nemotron 3 (CoreML eller MLX)

NVIDIA Nemotron 3 forudsiger 10 ms højttaler aktivitet for op til otte anonyme højttalere. Den endelige INT8 eksport downloade automatisk fra CoreML eller MLXStandard CLI-motor er CoreML; vælg MLX med --nemotron3-backend mlx. Begge støtter en lokal bundt gennem --nemotron3-directory.

På en intern 132-optagelse diarization sæt (12.82 timer 0.25 s krave), den afsendte Nemotron 3 MLX og CoreML runtimes scorede 10.98% og 11.20% I begge tilfælde var der ingen svigt. 48 Engelske møder, de scorede 10.31% og 10.24%. Se per-sprogsammenligning og evalueringsgrænser.

For målte resultater på tværs af diariseringssystemer og otte sprog, scoret med én lineal, se højttaler-diariseringsbenchmarks.

Offentliggjort CALLHOME Baseline

Følgende er NVIDIA 's publicerede rå anonyme-højttaler baseline for diar_streaming_sortformer_4spk-v2Det er en ekstern reference, ikke en lokal måling af speech-swift 's CoreML konvertering og ikke et navngivet tildelingsresultat.

Alle rækker bruger 1.04 s input-buffer latency, overlap inkluderet, en 0.25 krave, og postbehandling tunet på dissocieret CALLHOME Part 1. CALLOME er licenseret og er ikke bundtet. Lokal. diarization-bench rapporterer sammenlignelige resultater separat efter referencetælling i konsollen og i JSON under byReferenceSpeakerCount.

Community-1 Pipeline

Community-1 kører både neurale faser med CoreML og alle vært behandling i Swift, så det ikke indlæse MLX eller kræver en Metal skygger bibliotek. De offentliggjorte standardværdier er bevaret: hårdt powerset dekodning, ren single- højttaler masker med opstrøms kort- spor fallback, 0.6 centroid- linkage tærskel, Fa=0.07, Fb=0.8, og højst 20 VBx iterationer.

På den faste 5-fil VoxConverse release delsæt (1,057.49 sekunder 0.25-anden krave, overlap inkluderet), Swift med en nominel spænding på ikke over 1000 V pyannote.metrics målt 4.66% DER / 21.43%; den offentliggjorte CoreML-reference målt 4.65% / 21.42%Dette er en lille paritet kontrol, ikke en data- bred kvalitet påstand.

Med speech-swift 's ramme-grid scorer på samme delsæt, Community-1 målt 9.31% DER / 16.20% JER, 25.5 × real- time, og 1.54 GB peak RSS. Standard Pyannote motor målt 5.03% / 9.28%, 105.7 × real- time, og 393 MB. Community-1 er derfor en valgfri upstream- paritet rørledning med speaker- tæller grænser og returnerede centroider, ikke en universel nøjagtighed eller hastighed opgradering. Scores fra de to scoring metoder er ikke direkte sammenlignelige.

Pyannote Pipeline

Standardrørledningen kører i to faser:

Fase 1: Segmentering + speaker Chaining

Pyannote segmentation-3.0 behandler 10- sekund glidende vinduer med 50% overlap. A powerset dekoder konverterer 7- class output til per- højttaler sandsynligheder (op til 3 lokale højttalere per vindue). Address windows deler en 5-anden overlap - højttaleridentitet er formeret på tværs af vinduer ved at computere Pearson-korrelation mellem sandsynlighedsspor i overlappende zone, med grådige eksklusive matchning for konsistente globale højttalerid 'er.

Fase 2: Post- hoc-indlejring

Efter diarisering, WeSpeaker ResNet34-LM udtrækker en 256- dimensional centroid indlejring pr. højttaler. Disse indlejringer muliggør mål højttaler udtrækning (--target-speaker), men ikke selv at køre i højttaleropgaven.

Migrering fra pyanote.audio

Hvis du kommer fra Python pyannote.audio bibliotek - erstatning af en Pipeline underklasse, der sætter pipeline.segmentation = ..., eller flytte væk fra en server hosting pyannote/speaker-diarization-3.1 - Soniqo wraps den samme Pyannote-Segmentation-3.0 model og kører det helt on- enhed på Apple Silicon. No Python runtime, ingen CUDA, ingen Hugging Face token på inferens tid.

Pyannote-Segmentation-3.0 vægte konverteres fra opstrøms HuggingFace checkpoint, så segmenteringslogitter er numerisk ækvivalente inden for float- præcision tolerance. Post- segmentering chaining (Pearson korrelation på tværs overlappende vinduer + grådige eksklusive matchning) og post- hoc WeSpeaker indlejring faser genimplementeres i Swift men producerer sammenlignelige RTTM output til reference Python rørledning.

CLI-brug

# Basic diarization (pyannote, default)
.build/release/speech diarize meeting.wav

# Community-1 (CoreML + native PLDA/VBx)
.build/release/speech diarize meeting.wav --engine community1
.build/release/speech diarize meeting.wav --engine community1 --num-speakers 2

# End-to-end Sortformer (CoreML)
.build/release/speech diarize meeting.wav --engine sortformer

# Nemotron 3 (CoreML default; MLX optional)
.build/release/speech diarize meeting.wav --engine nemotron3
.build/release/speech diarize meeting.wav --engine nemotron3 --nemotron3-backend mlx

# RTTM output format (for evaluation)
.build/release/speech diarize meeting.wav --rttm

# JSON output
.build/release/speech diarize meeting.wav --json

Målfortaler udtrækning

Giv tilmelding lyd af en kendt højttaler til kun at udtrække deres segmenter fra en optagelse. Rørledningen beregner højttaleren indlejring af tilmelding lyd og finder klyngen med den højeste cosin lighed.

# Extract segments for a specific speaker
.build/release/speech diarize meeting.wav --target-speaker enrollment.wav

DER Scoring

Evaluere diarization kvalitet ved at score mod en reference RTTM-fil. Rørledningen beregner Diarization Error Rate (DER), som måler den andel af tid, der er forkert tilskrives.

# Score against reference RTTM
.build/release/speech diarize meeting.wav --score-against reference.rttm

RTTM Output

Den --rttm flag producerer Rich Transcription Time Market output, et standardformat, der anvendes til diarisering evaluering. Hver linje følger formatet:

SPEAKER filename 1 start_time duration <NA> <NA> speaker_id <NA> <NA>

Indstillinger

Model Downloads

Modeller downloades automatisk ved første brug:

Swift API

import SpeechVAD

let pipeline = try await DiarizationPipeline.fromPretrained()
let result = pipeline.diarize(audio: samples, sampleRate: 16000)
for seg in result.segments {
    print("Speaker \(seg.speakerId): [\(seg.startTime)s - \(seg.endTime)s]")
}

// Target speaker extraction
let targetEmb = pipeline.embeddingModel.embed(audio: enrollmentAudio, sampleRate: 16000)
let segments = pipeline.extractSpeaker(
    audio: meetingAudio, sampleRate: 16000,
    targetEmbedding: targetEmb
)

// Full Community-1 pipeline with bounded speaker counts
let community1 = try await Community1DiarizationPipeline.fromPretrained()
try community1.prewarm()
let attributed = try community1.diarize(
    audio: meetingAudio,
    sampleRate: 16000,
    speakerBounds: Community1SpeakerBounds(minimum: 2, maximum: 6)
)