audio#

Apprenez à utiliser Xinference pour convertir l’audio en texte ou le texte en audio.

Introduction#

L’API Audio propose trois méthodes pour interagir avec l’audio :

  • Le terminal de transcription convertit l’audio en texte dans la langue d’entrée.

  • Traduire le point de terminaison pour convertir l’audio en anglais.

  • Le terminal de transcription convertit l’audio en langage d’entrée.

Point de terminaison API

Point de terminaison compatible OpenAI

API de transcription

/v1/audio/transcriptions

API

/v1/audio/translations

API vocal

/v1/audio/speech

Liste des modèles pris en charge#

Dans Xinference, les modèles suivants prennent en charge l’API audio :

Transcription vocale en texte#

Exclusivement pour les puces Mac de la série M :

Synthèse vocale (TTS)#

Modèles prenant en charge le zero-shot (sans audio de référence)

Modèles prenant en charge le clonage vocal (nécessite un fichier audio de référence)

Modèle prenant en charge le contrôle des émotions

Exclusivement pour les puces Mac de la série M :

Démarrage rapide#

Transcription#

L’API de transcription imite l”API de création de transcriptions d’OpenAI. Vous pouvez essayer l’API de transcription via cURL, le client OpenAI ou le client Python de Xinference :

curl -X 'POST' \
  'http://<XINFERENCE_HOST>:<XINFERENCE_PORT>/v1/audio/transcriptions' \
  -H 'accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "<MODEL_UID>",
    "file": "<audio bytes>",
  }'

I am a strict technical documentation translator. Translate the given Simplified Chinese text into French. ABSOLUTE RULES: 1. Output ONLY the translation, nothing else. No explanations, no apologies. 2. Keep ALL Markdown syntax, reStructuredText directives, code blocks, URLs, and variable names unchanged. 3. If the input is a model name, identifier, or pure code string, output it verbatim. 4. Do not add any extra sentences or commentary.#

L’API de traduction imite le create translations API d’OpenAI. Vous pouvez essayer d’utiliser l’API de traduction via cURL, le client OpenAI ou le client Python de Xinference :

curl -X 'POST' \
  'http://<XINFERENCE_HOST>:<XINFERENCE_PORT>/v1/audio/translations' \
  -H 'accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "<MODEL_UID>",
    "file": "<audio bytes>",
  }'

voix#

L’API de transcription imite l’API create speech API d’OpenAI. Vous pouvez essayer l’API Speech via cURL, le client OpenAI ou le client Python de Xinference :

L’API Speech utilise par défaut le mode non-streaming.

  1. La sortie en streaming de ChatTTS n’est pas aussi efficace que la sortie non-streaming. Référence : 2noise/ChatTTS#564

  2. Exigences de streaming : ffmpeg < 7 : https://pytorch.org/audio/stable/installation.html#optional-dependencies

curl -X 'POST' \
  'http://<XINFERENCE_HOST>:<XINFERENCE_PORT>/v1/audio/speech' \
  -H 'accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "<MODEL_UID>",
    "input": "<The text to generate audio for>",
    "voice": "echo",
    "stream": True,
  }'

ChatTTS utilise#

Utilisation de base, voir la section sur l’utilisation vocale.

Timbre fixe. Nous pouvons utiliser le timbre fixe fourni par 6drf21e/ChatTTS_Speaker, télécharger evaluation_result.csv , en prenant le timbre seed_2155 comme exemple, nous utilisons les données de la colonne emb_data.

import pandas as pd

df = pd.read_csv("evaluation_results.csv")
emb_data_2155 = df[df['seed_id'] == 'seed_2155'].iloc[0]["emb_data"]

Utilisez seed_2155 pour fixer le timbre vocal et créer la voix.

from xinference.client import Client

client = Client("http://<XINFERENCE_HOST>:<XINFERENCE_PORT>")

model = client.get_model("<MODEL_UID>")
resp_bytes = model.speech(
    voice=emb_data_2155,
    input=<The text to generate audio for>
)

Modèle CosyVoice#

CosyVoice a deux versions : CosyVoice 1.0 et CosyVoice 2.0. CosyVoice 1.0 dispose de 3 modèles différents :

  • CosyVoice-300M-SFT: Choisissez ce modèle si vous souhaitez simplement convertir du texte en audio. Des voix pré-entraînées sont disponibles : [“中文女”, “中文男”, “日语男”, “粤语女”, “英文女”, “英文男”, “韩语女”]

  • CosyVoice-300M : Si vous souhaitez cloner une voix ou convertir du texte en parole dans une autre langue, choisissez ce modèle. Pour utiliser ce modèle, vous devez fournir un fichier audio prompt_speech au format WAV, en utilisant un taux d’échantillonnage de 16 000 Hz pour de meilleures performances.

  • CosyVoice-300M-Instruct : Si vous souhaitez contrôler précisément le ton et le timbre, choisissez ce modèle.

Utilisation de base, chargement du modèle CosyVoice-300M-SFT.

curl -X 'POST' \
  'http://<XINFERENCE_HOST>:<XINFERENCE_PORT>/v1/audio/speech' \
  -H 'accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "<MODEL_UID>",
    "input": "<The text to generate audio for>",
    # ['中文女', '中文男', '日语男', '粤语女', '英文女', '英文男', '韩语女']
    "voice": "中文女"
  }'

Clone la voix, charge le modèle CosyVoice-300M.

from xinference.client import Client

client = Client("http://<XINFERENCE_HOST>:<XINFERENCE_PORT>")

model = client.get_model("<MODEL_UID>")

zero_shot_prompt_text = ("<the words in the text exactly match "
                         "the audio file of the zero-shot prompt>")
# The words said in the audio file should be identical
# to zero_shot_prompt_text.
#
# The audio input file must be in WAV format.
# For optimal performance, use a 16,000 Hz sample rate.
#
# Files with different sample rates will be resampled to 16,000 Hz,
# which may increase processing time.
with open(zero_shot_prompt_file, "rb") as f:
    zero_shot_prompt = f.read()

speech_bytes = model.speech(
    "<The text to generate audio for>",
    prompt_text=zero_shot_prompt_text,
    prompt_speech=zero_shot_prompt,
)

Utilisation multilingue, chargement du modèle CosyVoice-300M.

from xinference.client import Client

client = Client("http://<XINFERENCE_HOST>:<XINFERENCE_PORT>")

model = client.get_model("<MODEL_UID>")

# The audio input file must be in WAV format.
# For optimal performance, use a 16,000 Hz sample rate.
#
# Files with different sample rates will be resampled to 16,000 Hz,
# which may increase processing time.
with open(cross_lingual_prompt_file, "rb") as f:
    cross_lingual_prompt = f.read()

speech_bytes = model.speech(
    "<The text to generate audio for>",  # text could be another language
    prompt_speech=cross_lingual_prompt,
)

Synthèse vocale basée sur les instructions, chargement du modèle CosyVoice-300M-Instruct.

from xinference.client import Client

client = Client("http://<XINFERENCE_HOST>:<XINFERENCE_PORT>")

model = client.get_model("<MODEL_UID>")

response = model.speech(
    "在面对挑战时，他展现了非凡的<strong>勇气</strong>与<strong>智慧</strong>。",
    voice="中文男",
    instruct_text="Theo 'Crimson', is a fiery, passionate rebel leader. "
    "Fights with fervor for justice, but struggles with impulsiveness.",
)

CosyVoice 2.0 ne contient qu’un seul modèle, mais il intègre toutes les capacités des trois modèles CosyVoice. Son utilisation est identique à celle de CosyVoice.

Utilisation en streaming de CosyVoice 2.0, chargement du modèle CosyVoice2-0.5B.

# Launch model
from xinference.client import Client

model_uid = client.launch_model(
    model_name=model_name,
    model_type="audio",
    download_hub="modelscope",
)

endpoint = "http://127.0.0.1:9997"
input_string = "你好，我是通义生成式语音大模型，请问有什么可以帮您的吗？"

# Stream request by openai client
import openai
import tempfile

openai_client = openai.Client(api_key="not empty", base_url=f"{endpoint}/v1")
# ['中文女', '中文男', '日语男', '粤语女', '英文女', '英文男', '韩语女']
response = openai_client.audio.speech.with_streaming_response.create(
    model=model_uid, input=input_string, voice="英文女"
)
with tempfile.NamedTemporaryFile(suffix=".mp3", delete=True) as f:
    response.stream_to_file(f.name)
    assert os.stat(f.name).st_size > 0

# Stream request by xinference client
response = model.speech(input_string, stream=True)
assert inspect.isgenerator(response)
with tempfile.NamedTemporaryFile(suffix=".mp3", delete=True) as f:
    for chunk in response:
        f.write(chunk)

Pour plus d’instructions et d’exemples, veuillez consulter https://fun-audio-llm.github.io/ .

Modèle FishSpeech#

Utilisation de base, voir la section sur l’utilisation vocale.

Cloner la voix, lancer le modèle FishSpeech-1.5. Veuillez utiliser prompt_speech au lieu de reference_audio ainsi que prompt_text au lieu de reference_text pour fournir l’audio de référence au modèle FishSpeech. Ce paramètre est cohérent avec le clonage vocal de CosyVoice.

from xinference.client import Client

client = Client("http://<XINFERENCE_HOST>:<XINFERENCE_PORT>")

model = client.get_model("<MODEL_UID>")

# The reference audio file is the voice file
# the words said in the file should be identical to reference_text
with open(reference_audio_file, "rb") as f:
    reference_audio = f.read()
reference_text = ""  # text in the audio

speech_bytes = model.speech(
    "<The text to generate audio for>",
    prompt_speech=reference_audio,
    prompt_text=reference_text
)

Instructions d’utilisation de Paraformer#

model

Détection d’activité vocale (VAD)

Restitution de la ponctuation (punc)

horodatage

Locuteur

hotword

paraformer-zh

Oui

Oui

non

non

non

paraformer-zh-hotword

Oui

Oui

non

non

Oui

paraformer-zh-spk

Oui

Oui

Oui

Oui

non

paraformer-zh-long

Oui

Oui

Oui

Oui

non

seaco-paraformer-zh (recommandé)

Oui

Oui

Oui

Oui

Oui

  1. Utilisation de la VAD et des signes de ponctuation

    Tous les modèles Paraformer prennent en charge les fonctionnalités VAD et de ponctuation.

  2. Instructions d’utilisation de l’horodatage et de l’identification du locuteur

    Seuls les modèles suivants prennent en charge la reconnaissance de timestamp et locuteur :

    • paraformer-zh-spk

    • paraformer-zh-long

    • seaco-paraformer-zh

    Parmi eux, seule la fonction de reconnaissance du locuteur est activée par défaut pour paraformer-zh-spk.

    Si vous utilisez paraformer-zh-long ou seaco-paraformer-zh et devez activer la fonction de reconnaissance du locuteur :

    • Dans l’interface Web : ajoutez un paramètre nommé spk_model avec la valeur cam++.

    • Dans la ligne de commande : ajoutez le paramètre --spk_model cam++

    Spécimen :

    from xinference.client import Client
client = Client("http://<XINFERENCE_HOST>:<XINFERENCE_PORT>")
model = client.get_model("seaco-paraformer-zh")
with open("asr_example.wav", "rb") as audio_file:
    audio = audio_file.read()
    model.transcriptions(audio, response_format="verbose_json")

  3. Instructions d’utilisation de la fonctionnalité de mots-clés

    Seuls les modèles suivants prennent en charge hotword (fonction de mot clé) :

    • paraformer-zh-hotword

    • seaco-paraformer-zh

    Spécimen :

    from xinference.client import Client
client = Client("http://<XINFERENCE_HOST>:<XINFERENCE_PORT>")
model = client.get_model("seaco-paraformer-zh")
with open("asr_example.wav", "rb") as audio_file:
    audio = audio_file.read()
    model.transcriptions(audio, hotword="小艾 魔搭")

Utilisation hors ligne de SenseVoiceSmall#

Désormais, SenseVoiceSmall utilise un petit modèle VAD fsmn-vad, ce qui nécessite un réseau pour le téléchargement.

Pour un environnement hors ligne, vous pouvez télécharger ce modèle VAD à l’avance.

Téléchargez depuis huggingface ou modelscope. Supposez que le téléchargement se fait dans /path/to/fsmn-vad.

Ensuite, lors du chargement de SenseVoiceSmall avec l’interface Web UI, ajoutez une option supplémentaire, dont la clé est vad_model et la valeur est le chemin de téléchargement précédent /path/to/fsmn-vad. Lors du chargement en ligne de commande, ajoutez l’option --vad_model /path/to/fsmn-vad.

Modèle Kokoro utilisé#

Le modèle Kokoro prend en charge plusieurs langues, par défaut c’est l’anglais. Si vous souhaitez utiliser une langue non par défaut, comme le chinois, vous devez installer des dépendances supplémentaires et ajouter les paramètres correspondants lors du démarrage du modèle.

  1. pip install misaki[zh]

  2. Initialisez le modèle avec le paramètre lang_code=”z”. Vous pouvez consulter le code source de kokoro pour voir tous les lang_code pris en charge. Si vous démarrez le modèle via l’interface Web UI, vous devez ajouter un paramètre supplémentaire, avec la clé lang_code et la valeur z. Si vous démarrez le modèle via le client xinference, vous pouvez transmettre les paramètres en vous référant au code suivant :

    model_uid = client.launch_model(
    model_name="Kokoro-82M",
    model_type="audio",
    compile=False,
    download_hub="huggingface",
    lang_code="z",
)

  3. Lors de l’inférence, il est nécessaire d’utiliser une voix commençant par “z”, par exemple : zf_xiaoyi. Les voix actuellement prises en charge peuvent être consultées sur https://huggingface.co/hexgrad/Kokoro-82M/tree/main/voices. La méthode d’utilisation est la suivante :

    input_string = "重新启动即可更新"
response = model.speech(input_string, voice="zf_xiaoyi")

IndexTTS2 utilise#

Le modèle IndexTTS2 prend en charge le contrôle des émotions, et vous pouvez utiliser cette fonctionnalité en ajoutant quelques paramètres supplémentaires. Voici comment utiliser IndexTTS2 :

  1. Audio de référence unique (clonage de voix) :

    from xinference.client import Client
client = Client("http://0.0.0.0:6735")
model = client.get_model("IndexTTS2")

with open("../mp3_test_voice.mp3", "rb") as f:
    test_prompt_speech = f.read()

response = model.speech(
    input="Translate for me, what is a surprise!",
    prompt_speech=test_prompt_speech,
)

  2. Spécifier l’audio de référence émotionnelle :

    from xinference.client import Client
client = Client("http://0.0.0.0:6735")
model = client.get_model("IndexTTS2")

with open("../mp3_test_voice.mp3", "rb") as f:
    test_prompt_speech = f.read()

with open("example/emo_sad.wav", "rb") as f:
    emo_prompt_speech = f.read()

response = model.speech(
    input="It's such a shame the singer didn't make it to the finals.",
    prompt_speech=test_prompt_speech,
    emo_audio_prompt=emo_prompt_speech
)

  3. Lors de la définition d’un fichier audio de référence émotionnelle, vous pouvez choisir de régler le paramètre emo_alpha pour ajuster son degré d’influence sur la sortie. La plage valide est 0.0 - 1.0, avec une valeur par défaut de 1.0 (100 %).

    from xinference.client import Client
client = Client("http://0.0.0.0:6735")
model = client.get_model("IndexTTS2")

with open("../mp3_test_voice.mp3", "rb") as f:
    test_prompt_speech = f.read()

with open("example/emo_sad.wav", "rb") as f:
    emo_prompt_speech = f.read()

response = model.speech(
    input="It's such a shame the singer didn't make it to the finals.",
    prompt_speech=test_prompt_speech,
    emo_audio_prompt=emo_prompt_speech,
    emo_alpha=0.9
)

  4. Vous pouvez omettre la référence audio émotionnelle et fournir à la place une liste de 8 nombres à virgule flottante, spécifiant l’intensité de chaque émotion dans l’ordre suivant : [joie, colère, tristesse, peur, dégoût, mélancolie, surprise, calme]. Vous pouvez également utiliser le paramètre use_random pour introduire des émotions aléatoires lors de l’inférence ; la valeur par défaut est False, réglez-la sur True pour activer les émotions aléatoires.

    from xinference.client import Client
client = Client("http://0.0.0.0:6735")
model = client.get_model("IndexTTS2")

with open("../mp3_test_voice.mp3", "rb") as f:
    test_prompt_speech = f.read()

response = model.speech(
    input="Wow, I'm so lucky!",
    prompt_speech=test_prompt_speech,
    emo_vector=[0, 0, 0, 0, 0, 0, 0.45, 0],
    use_random=False
)

  5. Vous pouvez également activer la fonction use_emo_text pour guider l’expression émotionnelle en fonction du script text fourni. Votre script textuel sera automatiquement converti en vecteurs émotionnels. Lors de l’utilisation du mode émotionnel textuel, il est recommandé de définir emo_alpha autour de 0,6 (ou moins) pour un rendu vocal plus naturel. Vous pouvez introduire de l’aléatoire via use_random (valeur par défaut : False ; True active l’aléatoire) :

    from xinference.client import Client
client = Client("http://0.0.0.0:6735")
model = client.get_model("IndexTTS2")

with open("../mp3_test_voice.mp3", "rb") as f:
    test_prompt_speech = f.read()

response = model.speech(
    input="Quick, hide! He's coming! He's coming to get us!",
    prompt_speech=test_prompt_speech,
    emo_alpha=0.6,
    use_emo_text=True,
    use_random=False
)

  6. Vous pouvez également fournir directement une description textuelle d’émotion spécifique via le paramètre emo_text. Votre texte émotionnel sera automatiquement converti en vecteur émotionnel. Cela vous permet de contrôler séparément le script textuel et la description textuelle de l’émotion :

    from xinference.client import Client
client = Client("http://0.0.0.0:6735")
model = client.get_model("IndexTTS2")

with open("../mp3_test_voice.mp3", "rb") as f:
    test_prompt_speech = f.read()

response = model.speech(
    input="Quick, hide! He's coming! He's coming to get us!",
    prompt_speech=test_prompt_speech,
    emo_alpha=0.6,
    use_emo_text=True,
    emo_text="You scared the hell out of me! Are you a ghost?",
    use_random=False
)

IndexTTS2 hors ligne#

IndexTTS2 nécessite plusieurs petits modèles, qui seront automatiquement téléchargés lors de l’initialisation. Dans un environnement hors ligne, vous pouvez télécharger ces modèles dans un seul répertoire et spécifier le chemin de ce répertoire.

Méthode de configuration simple

La méthode la plus simple pour configurer une utilisation hors ligne est d’utiliser la commande hf download pour télécharger tous les petits modèles à l’avance.

# Create your local models directory
mkdir -p /path/to/small_models

# Download models from Hugging Face
hf download facebook/w2v-bert-2.0 --local-dir /path/to/small_models/w2v-bert-2.0
hf download funasr/campplus --local-dir /path/to/small_models/campplus
hf download nvidia/bigvgan_v2_22khz_80band_256x --local-dir /path/to/small_models/bigvgan
hf download amphion/MaskGCT --local-dir /path/to/small_models/MaskGCT

La structure de répertoire finale devrait ressembler à ceci :

/path/to/small_models/
├── w2v-bert-2.0/                 # Feature extraction model
├── campplus/                     # Speaker recognition model
├── bigvgan/                      # Vocoder model
└── MaskGCT/                      # Semantic codec model

Liste des modèles supportés

Les petits modèles seront automatiquement mappés comme suit :

  1. w2v-bert-2.0 (models--facebook--w2v-bert-2.0) - Modèle d’extraction de caractéristiques

  2. campplus (models--funasr--campplus) - modèle de reconnaissance du locuteur

  3. bigvgan (models--nvidia--bigvgan_v2_22khz_80band_256x) - modèle d’encodeur vocal

  4. Codec sémantique (models--amphion--MaskGCT) - Modèle de codage/décodage sémantique

Démarrer IndexTTS2 en mode hors ligne

Au démarrage d’IndexTTS2 via l’interface Web, vous pouvez ajouter un paramètre supplémentaire : - small_models_dir - le chemin du répertoire contenant tous les petits modèles

Lors du lancement en ligne de commande, vous pouvez ajouter les options suivantes :

xinference launch --model-name IndexTTS2 --model-type audio \
    --small_models_dir /path/to/small_models

Lors du démarrage avec le client Python :

model_uid = client.launch_model(
    model_name="IndexTTS2",
    model_type="audio",
    small_models_dir="/path/to/small_models"
)