Clonage vocal

Clonez n'importe quelle voix à partir d'un court échantillon audio de référence. Qwen3-TTS et CosyVoice3 prennent tous deux en charge le clonage vocal avec différents encodeurs de locuteur — ECAPA-TDNN (1024 dim) et CAM++ (192 dim) respectivement.

Fonctionnement

1. Enregistrez ou fournissez un échantillon audio de référence de la voix cible
2. Extraction de l'empreinte de locuteur — un encodeur de locuteur traite l'audio de référence en un vecteur d'embedding à dimension fixe
3. Injection de l'embedding — l'embedding de locuteur conditionne le modèle TTS pendant la synthèse
4. Synthèse vocale — le modèle TTS génère une parole qui correspond aux caractéristiques vocales de l'échantillon de référence

Moteurs

Le clonage vocal est disponible avec les deux moteurs TTS. Chacun utilise un encodeur de locuteur différent :

CosyVoice3 + CAM++

CosyVoice3 utilise l'encodeur de locuteur CAM++ (Context-Aware Masking++) du projet 3D-Speaker d'Alibaba. L'embedding 192 dim conditionne le modèle flow DiT via une couche de projection affine (192 → 80) qui a été entraînée conjointement avec CosyVoice3.

Architecture CAM++

Le modèle CoreML (~14 Mo, FP16) s'exécute sur le Neural Engine. Il est téléchargé automatiquement depuis aufklarer/CamPlusPlus-Speaker-CoreML à la première utilisation.

Clonage vocal Qwen3-TTS

Qwen3-TTS prend en charge deux modes de clonage vocal :

Mode ICL (recommandé)

Le mode In-Context Learning encode l'audio de référence en tokens de codec via l'encodeur du tokenizer de parole Mimi et les préfixe avec la transcription de référence. Cela donne au modèle un contexte acoustique complet — qualité supérieure et EOS fiable (corrige les problèmes sur les textes courts et les langues non anglaises).

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
)

Mode x-vector

Utilise un encodeur ECAPA-TDNN qui produit un x-vector 1024 dim. Pas besoin de transcription mais qualité inférieure. Peut échouer à émettre EOS sur des textes courts ou certaines langues.

Architecture ECAPA-TDNN

Les poids (76 paramètres) sont inclus dans les safetensors de Qwen3-TTS — aucun téléchargement séparé requis.

Utilisation en 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

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

Exemples

# 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

Dialogue multi-locuteurs

CosyVoice3 prend en charge les dialogues multi-locuteurs avec clonage vocal par locuteur. Utilisez l'option --speakers pour associer les tags de locuteur aux fichiers audio de référence :

# 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 de référence de chaque locuteur est traité par l'encodeur CAM++ pour extraire un embedding 192 dim. Le modèle est chargé une fois et réutilisé pour tous les locuteurs. Voir le guide CosyVoice3 pour tous les détails sur la syntaxe de dialogue et les tags d'émotion.

Conseils sur l'audio de référence

• Durée : 5 à 15 secondes de parole fonctionnent le mieux. Des clips plus courts peuvent ne pas capturer assez de caractéristiques vocales ; des clips plus longs donnent des rendements décroissants.
• Locuteur unique : La référence ne doit contenir qu'un seul locuteur. Un audio multi-locuteurs produira des résultats imprévisibles.
• Audio propre : Minimisez le bruit de fond, la musique et la réverbération. Utilisez le module d'amélioration de la parole pour nettoyer les références bruitées avant le clonage.
• Parole naturelle : Utilisez une parole conversationnelle et naturelle plutôt que des chuchotements, cris ou chants.

API Swift

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
)

Reference Audio Caching

Both synthesizeWithVoiceClone (x-vector) and synthesizeWithVoiceCloneICL (ICL) cache their per-reference preprocessing across calls on the same model instance. The x-vector path caches the ECAPA-TDNN speaker embedding; the ICL path additionally caches the Mimi codec encoder output. The cache is content-addressed (hash of raw samples + sample rate) and bounded to a small LRU (default 4 entries), so repeated generations against the same reference waveform skip the mel + encoder passes without unbounded memory growth.

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