Traduzione automatica · Originale inglese

Clonazione vocale

IndexTTS2 aggiunge nativo MLX clonazione a zero-shot con comandi di emozione, tempo e pausa, insieme a Qwen3-TTS e CosyVoice3 clonaggio diffusore-encoder.

Come funziona

1. Registri o fornisca un campione audio di riferimento della voce target
2. Speaker embedding estrazione — un diffusore codifica l'audio di riferimento in un vettore di incorporazione fissa
3. Iniezione di incorporazione — il diffusore incorpora le condizioni del modello TTS durante la sintesi
4. Sintesi vocale — Il modello TTS genera un discorso che corrisponde alle caratteristiche vocali del campione di riferimento

Motori

La clonazione vocale è disponibile con più motori TTS. IndexTTS2 utilizza l'audio rapido e il condizionamento dello stile; Qwen3-TTS e CosyVoice3 utilizzano gli codificatori dell'altoparlante:

F5-TTS e Higgs TTS 3 saltare completamente il diffusore encoder: F5 condizioni sul mel di riferimento grezzo più la sua trascrizione, Higgs continua cornici di riferimento codificati in codice.

IndexTTS2 Clonazione vocale

IndexTTS2 è un motore nativo MLX a zero-shot per la riproduzione vocale. --voice-sample, downloads aufklarer/IndexTTS2-MLX-fp16 per impostazione predefinita, e supporta riferimenti facoltativi di emozione/stile, controllo di emozione preimpostato o vettoriale, regolazione della frequenza di conversazione e copertura interna-pausa. Attualmente funziona solo la sintesi batch. L'emozione può provenire da un vettore preimpostato oppure da un vettore 8-valore (--indextts2-emotion, ponderato --indextts2-emotion-weight) o da un riferimento di stile separato (--indextts2-emotion-audio); --indextts2-s2mel-steps I numeri di flusso per la velocità (default 15, orecchio-validated). Dopo la rielaborazione del decode float32-attention si sintetizzano a RTF ≈ 1.0 su un testo M5 Pro. Il mandarino e il testo misto cinese/inglese sono gestiti in modo nativo: la scrittura di punteggiatura di upstream e le parole di per-kenacter

F5-TTS Clonazione vocale

cloni F5-TTS da un riferimento ~10-secondo più la sua trascrizione (--f5-reference-text) attraverso l'accoppiamento del flusso DiT — nessun encoder del diffusore affatto. È il percorso di clonazione più veloce nel pacchetto (RTF 0.57 ai passi di flusso 16 predefiniti, più basso è più veloce) e il più piccolo (~0.8 GB picco RSS), che copre l'inglese e il mandarino. Guida F5-TTS.

Higgs TTS 3 Clonazione vocale

Higgs TTS 3 (4B) codifica il clip di riferimento in cornici codec e lo prosegue: consegna espressiva di conversazione con emozione in linea, stile e tag SFX, 100+ lingue, RTF 0.78. Una trascrizione di riferimento (--higgs-ref-text) migliora la clonazione. Higgs TTS Guida 3.

CosyVoice3 + CAM++

CosyVoice3 utilizza l'encoder di diffusori CAM++ (Context-Aware Masking++) del progetto 3D-Speaker di Alibaba. Le condizioni di embedding di 192-dim il modello di flusso DiT tramite uno strato di proiezione affine (192 → 80) formato congiuntamente con CosyVoice3

CAM++ Architettura

Il modello CoreML (~14 MB, FP16) si esegue sul Neural Engine. Viene scaricato automaticamente da aufklarer/CamPlusPlus-Speaker-CoreML

Qwen3-TTS Clonazione vocale

Qwen3-TTS supporta due modalità di clonazione vocale:

Modalità ICL (consigliato)

In-Context Learning mode codifica l'audio di riferimento in token codec tramite il Mimi

let (model, encoder) = try await Qwen3TTSModel.fromPretrainedWithEncoder()
let audio = model.synthesizeWithVoiceCloneICL(
    text: "Target text to synthesize.",
    referenceAudio: refSamples,
    referenceSampleRate: 24000,
    referenceText: "Exact transcript of reference audio.",
    language: "english",
    codecEncoder: encoder
)

Qwen3-TTS conserva 1920 campioni per frame codec a 24 kHz, anche attraverso sovrapposizioni di blocchi di decodifica. Entrambi i livelli di pre-upsampling utilizzano la larghezza del kernel 2 e lo sforzo 2 senza rifilatura giusta, preservando la forma d'onda di destinazione a limiti di pezzi e durante la rimozione di riferimento di ICL.

Modalità X-Vector

Utilizza un encoder ECAPA-TDNN che produce un vettore x 1024-dim. Nessuna trascrizione necessaria ma di qualità inferiore. Può non emettere EOS su testi brevi o alcune lingue.

Architettura ECAPA-TDNN

I pesi (76 parametri) sono inclusi nel Qwen3-TTS safetensors — nessun download separato richiesto.

Uso CLI

# CosyVoice3 voice cloning (CAM++, CoreML Neural Engine)
.build/release/speech speak "Text in the cloned voice" \
    --engine cosyvoice --voice-sample reference.wav -o output.wav

# IndexTTS2 voice cloning (expanded MLX bundle)
.build/release/speech speak "Text in the cloned voice" \
    --engine indextts2 --voice-sample reference.wav \
    --indextts2-speaking-rate 1.35 \
    --indextts2-max-pause 0.05 \
    -o output.wav

# F5-TTS voice cloning (reference + transcript, MLX GPU)
.build/release/speech speak "Text in the cloned voice" \
    --engine f5 --voice-sample reference.wav \
    --f5-reference-text "Transcript of the reference clip." -o output.wav

# Higgs TTS 3 voice cloning (4B, expressive, MLX GPU)
.build/release/speech speak "Text in the cloned voice" \
    --engine higgs --voice-sample reference.wav \
    --higgs-ref-text "Transcript of the reference clip." -o output.wav

# Qwen3-TTS voice cloning (ECAPA-TDNN, MLX GPU)
.build/release/speech speak "Text in the cloned voice" \
    --voice-sample reference.wav -o output.wav

Esempi

# CosyVoice3: multilingual voice cloning (9 languages)
.build/release/speech speak "Hello, this is my cloned voice." \
    --engine cosyvoice --voice-sample my_voice.wav -o cloned_hello.wav

# CosyVoice3: clone voice in a different language
.build/release/speech speak "Guten Tag, das ist meine geklonte Stimme." \
    --engine cosyvoice --voice-sample my_voice.wav --language german -o german.wav

# Qwen3-TTS: English voice cloning
.build/release/speech speak "The quick brown fox jumps over the lazy dog." \
    --voice-sample recording_15s.wav -o cloned_fox.wav

# IndexTTS2: local exported bundle
.build/release/speech speak "This voice was cloned locally." \
    --engine indextts2 --voice-sample my_voice.wav \
    --indextts2-speaking-rate 1.35 \
    --indextts2-max-pause 0.05 \
    --indextts2-bundle-dir /path/to/IndexTTS2-MLX-fp16 \
    -o indextts2.wav

Dialogo multi-Speaker

CosyVoice3 supporta il dialogo multi-altoparlante con clonazione vocale per diffusore. Utilizzare la bandiera --speakers per mappare i tag dei diffusori ai file audio di riferimento:

# Two-speaker dialogue with voice cloning
.build/release/speech speak "[S1] Hello there! [S2] Hey, how are you?" \
    --engine cosyvoice --speakers s1=alice.wav,s2=bob.wav -o dialogue.wav

# Dialogue with emotion tags + voice cloning
.build/release/speech speak "[S1] (happy) Great news! [S2] (surprised) Really? Tell me more." \
    --engine cosyvoice --speakers s1=alice.wav,s2=bob.wav -o emotional_dialogue.wav

# Adjust silence between turns
.build/release/speech speak "[S1] First line. [S2] Second line." \
    --engine cosyvoice --speakers s1=a.wav,s2=b.wav --turn-gap 0.5 -o gapped.wav

L'audio di riferimento di ciascun diffusore viene elaborato attraverso l'encoder CAM++ per estrarre un'integrazione 192-dim. Il modello viene caricato una volta e riutilizzato per tutti gli altoparlanti. Guida CosyVoice3 per dettagli completi su dialog sintassi e tag di emozione.

Riferimento Audio Suggerimenti

• Durata: 5 a 15 secondi di opere vocali migliori. Le clip più brevi non possono catturare abbastanza caratteristiche vocali; le clip più lunghe forniscono ritorni in diminuzione.
• Altoparlante singolo: Il riferimento dovrebbe contenere solo un diffusore. L'audio multialtoparlante produrrà risultati imprevedibili.
• Audio pulito: Minimizza il rumore di fondo, la musica e il riverbero. valorizzazione del discorso modulo per pulire riferimenti rumorosi prima di clonazione.
• Discorso naturale: Utilizzare discorso di conversazione, naturale-suono piuttosto che bisbigli, grida, o canto.

Swift API

import CosyVoiceTTS

// CosyVoice3 voice cloning
let model = try await CosyVoiceTTSModel.fromPretrained()
let speaker = try await CamPlusPlusSpeaker.fromPretrained()

// Extract 192-dim speaker embedding from reference audio
let embedding = try speaker.embed(audio: refSamples, sampleRate: 16000)

// Synthesize with cloned voice
let audio = model.synthesize(
    text: "Hello in a cloned voice!",
    speakerEmbedding: embedding
)

// With custom instruction + speaker embedding
let styledAudio = model.synthesize(
    text: "Hello!",
    instruction: "Speak happily and with excitement.",
    speakerEmbedding: embedding
)

// Multi-speaker dialogue
let segments = DialogueParser.parse("[S1] (happy) Hi! [S2] Hey there.")
let embeddings = ["S1": aliceEmbedding, "S2": bobEmbedding]
let dialogueAudio = DialogueSynthesizer.synthesize(
    segments: segments,
    speakerEmbeddings: embeddings,
    model: model,
    language: "english"
)

import Qwen3TTS

// Qwen3-TTS voice cloning
let model = try await Qwen3TTSModel.fromPretrained()
let audio = model.synthesizeWithVoiceClone(
    text: "Hello in a cloned voice!",
    referenceAudio: refSamples,
    referenceSampleRate: 24000
)

import IndexTTS2TTS

// IndexTTS2 zero-shot voice cloning
let model = try await IndexTTS2TTSModel.fromPretrained()
let audio = try await model.generate(
    text: "Hello in a cloned voice!",
    referenceAudio: URL(fileURLWithPath: "reference.wav"),
    synthesisOptions: try IndexTTS2SynthesisOptions(
        speakingRate: 1.35,
        maxInternalPauseDuration: 0.05)
)

Caching audio di riferimento

Entrambi. synthesizeWithVoiceClone (x-vector) e synthesizeWithVoiceCloneICL Il percorso x-vector memorizza l'integrazione dell'altoparlante ECAPA-TDNN; il percorso ICL memorizza inoltre la cache dell'indice Mimi output codec encoder. La cache è indirizzata ai contenuti (hash of raw sample + sample rate) e limitata a una piccola LRU (default 4 voci), così ripetute generazioni contro la stessa forma d'onda di riferimento saltare il mel + encoder passa senza la crescita della memoria in eccesso.

let tts = try await Qwen3TTSModel.fromPretrained()

// First call: runs ECAPA-TDNN, caches the embedding
_ = tts.synthesizeWithVoiceClone(text: "Hello", referenceAudio: ref, ...)

// Subsequent calls with the same reference: cache hit
_ = tts.synthesizeWithVoiceClone(text: "How are you?", referenceAudio: ref, ...)

// Explicit eviction (rarely needed — LRU handles capacity)
tts.clearReferenceAudioCache()