audio#

Impara come utilizzare Xinference per convertire audio in testo o testo in audio.

Introduzione#

L’API Audio offre tre metodi per interagire con l’audio:

  • Il terminale di trascrizione trascrive l’audio nella lingua di input.

  • Traduci l’audio in inglese utilizzando l’endpoint.

  • Il terminale di trascrizione converte l’audio nella lingua di input.

Punto finale API

Endpoint compatibile con OpenAI

API di trascrizione

/v1/audio/transcriptions

API

/v1/audio/translations

API vocale

/v1/audio/speech

Elenco dei modelli supportati#

In Xinference, i seguenti modelli supportano l’API audio:

Trascrizione vocale#

Solo per chip della serie Mac M:

Sintesi vocale (TTS)#

Modelli che supportano zero-shot (senza necessità di audio di riferimento)

Modelli che supportano la clonazione vocale (richiedono un audio di riferimento)

Modello con supporto al controllo emotivo

Solo per chip della serie Mac M:

Guida rapida#

Trascrizione#

L’API di trascrizione imita l”API create transcriptions di OpenAI. Puoi provare l’API di trascrizione tramite cURL, il client OpenAI o il client Python di 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. Please provide the Simplified Chinese text you would like me to translate into Italian.#

L’API di Traduzione imita l”API di creazione traduzioni di OpenAI. Puoi provare a utilizzare l’API di Traduzione tramite cURL, OpenAI Client o il client Python di 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>",
  }'

Voce#

L’API di Trascrizione replica la create speech API di OpenAI. Puoi provare l’API Speech tramite cURL, il Client OpenAI o il client Python di Xinference.

Le API di Speech utilizzano la modalità non streaming per impostazione predefinita.

  1. L’output in streaming di ChatTTS non è efficace quanto quello non in streaming, riferimento: 2noise/ChatTTS#564

  2. Requisiti per lo 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 è utilizzato.#

Uso base, fare riferimento alla sezione Uso vocale.

Timbro fisso. Possiamo utilizzare il timbro fisso fornito da 6drf21e/ChatTTS_Speaker, scaricare evaluation_result.csv , prendendo come esempio il timbro seed_2155, utilizziamo i dati della colonna 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"]

Usa seed_2155 per fissare il timbro vocale e creare la voce.

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

Modello CosyVoice in uso#

CosyVoice ha due versioni: CosyVoice 1.0 e CosyVoice 2.0. CosyVoice 1.0 ha 3 modelli diversi:

  • CosyVoice-300M-SFT: Scegli questo modello se vuoi semplicemente convertire testo in audio. Sono disponibili voci pre-addestrate: [“中文女”, “中文男”, “日语男”, “粤语女”, “英文女”, “英文男”, “韩语女”]

  • CosyVoice-300M: Se desideri clonare una voce o convertire un testo in parlato di un’altra lingua, scegli questo modello. Per utilizzarlo, devi fornire un file audio in formato WAV prompt_speech, utilizza una frequenza di campionamento di 16.000 Hz per ottenere prestazioni migliori.

  • CosyVoice-300M-Instruct: Se desideri controllare con precisione il tono e il timbro della voce, scegli questo modello.

Uso base, caricare il modello 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": "中文女"
  }'

Clona la voce, carica il modello 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,
)

Utilizzo multilingue, carica il modello 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,
)

Basato sulla sintesi vocale basata su comandi, carica il modello 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 ha un solo modello, ma racchiude tutte le capacità dei tre modelli di CosyVoice. Le modalità d’uso sono le stesse di CosyVoice.

CosyVoice 2.0 utilizzo in streaming, caricamento del modello 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)

Per ulteriori istruzioni ed esempi, fare riferimento a https://fun-audio-llm.github.io/.

Modello FishSpeech in uso#

Uso base, fare riferimento alla sezione Uso vocale.

Clona la voce, avvia il modello FishSpeech-1.5. Utilizza prompt_speech invece di reference_audio e prompt_text invece di reference_text per fornire l’audio di riferimento al modello FishSpeech. Questo parametro è coerente con la clonazione vocale di 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
)

Istruzioni per l’uso di Paraformer#

model

Rilevamento dell’attività vocale (VAD)

Punteggiatura (punc)

timestamp

Parlante

Hot words

paraformer-zh

Sì

Sì

No

No

No

paraformer-zh-hotword

Sì

Sì

No

No

Sì

paraformer-zh-spk

Sì

Sì

Sì

Sì

No

paraformer-zh-long

Sì

Sì

Sì

Sì

No

seaco-paraformer-zh (consigliato)

Sì

Sì

Sì

Sì

Sì

  1. Uso di VAD e punteggiatura

    Tutti i modelli Paraformer supportano le funzionalità VAD e di punteggiatura.

  2. Istruzioni per l’uso dei timestamp e del riconoscimento del parlante

    Solo i seguenti modelli supportano il riconoscimento di timestamp e parlante:

    • paraformer-zh-spk

    • paraformer-zh-long

    • seaco-paraformer-zh

    Tra questi, solo paraformer-zh-spk abilita per default la funzione di riconoscimento del parlante.

    Se stai utilizzando paraformer-zh-long o seaco-paraformer-zh e devi abilitare la funzione di riconoscimento del parlante:

    • Nell’interfaccia Web: aggiungi un parametro chiamato spk_model con valore cam++.

    • Sulla riga di comando: aggiungere il parametro --spk_model cam++

    Esempio:

    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. Istruzioni per l’uso della funzionalità parole calde

    Solo i seguenti modelli supportano hotword (funzione di parole chiave):

    • paraformer-zh-hotword

    • seaco-paraformer-zh

    Esempio:

    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="小艾 魔搭")

SoloSenseVoiceSmall#

Ora SenseVoiceSmall utilizza un piccolo modello VAD fsmn-vad, pertanto necessita di una rete per il download.

Per gli ambienti offline, puoi scaricare in anticipo questo modello VAD.

Scarica da huggingface o modelscope. Supponi di aver scaricato in /path/to/fsmn-vad.

Poi, quando si carica SenseVoiceSmall con Web UI, aggiungere un’opzione extra, la chiave è vad_model, il valore è il percorso di download precedente /path/to/fsmn-vad. Quando si carica con la riga di comando, aggiungere l’opzione --vad_model /path/to/fsmn-vad.

Modello Kokoro utilizzato#

Il modello Kokoro supporta più lingue, di default è in inglese. Se si desidera utilizzare una lingua non predefinita, ad esempio il cinese, è necessario installare pacchetti di dipendenze aggiuntivi e aggiungere i parametri corrispondenti all’avvio del modello.

  1. pip install misaki[zh]

  2. Inizializza il modello con il parametro lang_code=”z”. Puoi consultare il codice sorgente di kokoro per vedere tutti i lang_code supportati. Se hai avviato il modello tramite l’Interfaccia Web, devi aggiungere un parametro aggiuntivo: la chiave è lang_code e il valore è z. Se hai avviato il modello tramite il client xinference, puoi passare il parametro facendo riferimento al seguente codice:

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

  3. Durante l’inferenza, è necessario utilizzare una voce che inizia con “z”, ad esempio: zf_xiaoyi. Per le voci attualmente supportate, fare riferimento a https://huggingface.co/hexgrad/Kokoro-82M/tree/main/voices. Il metodo di utilizzo è il seguente:

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

IndexTTS2 uso#

Il modello IndexTTS2 supporta il controllo delle emozioni. Puoi utilizzare questa funzione aggiungendo alcuni parametri extra. Di seguito è riportato il metodo di utilizzo di IndexTTS2:

  1. Referenza audio singola (clonazione timbrica):

    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. Specificare il riferimento audio per le emozioni:

    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. Quando si specifica un riferimento audio per l’emozione, è possibile impostare il parametro emo_alpha per regolare il suo grado di influenza sull’output. Il range valido è 0.0 - 1.0, con un valore predefinito di 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. Puoi omettere l’audio di riferimento per le emozioni e fornire invece una lista di 8 numeri in virgola mobile, che specifica l’intensità di ciascuna emozione nel seguente ordine: [felicità, rabbia, tristezza, paura, disgusto, malinconia, sorpresa, calma]. Puoi anche utilizzare il parametro use_random per introdurre emozioni casuali durante l’inferenza; il valore predefinito è False, impostalo su True per abilitare le emozioni casuali.

    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. In alternativa, è possibile abilitare la funzione use_emo_text per guidare l’espressione emotiva in base allo script text fornito. Il vostro script testuale verrà automaticamente convertito in un vettore emotivo. Quando si utilizza la modalità emotiva testuale, si consiglia di impostare emo_alpha su circa 0,6 (o inferiore) per ottenere un effetto vocale più naturale. È possibile introdurre casualità tramite use_random (valore predefinito: False; True abilita la casualità).

    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. Puoi anche fornire una descrizione testuale specifica dell’emozione tramite il parametro emo_text. Il testo della tua emozione verrà automaticamente convertito in un vettore emotivo. Questo ti permette di controllare separatamente lo script testuale e la descrizione testuale dell’emozione:

    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 offline#

IndexTTS2 richiede diversi modelli di piccole dimensioni, che vengono scaricati automaticamente durante il processo di inizializzazione. In un ambiente offline, è possibile scaricare questi modelli in una singola directory e specificare il percorso di tale directory.

Metodo di configurazione semplice

Il metodo più semplice per configurare l’uso offline è utilizzare il comando hf download per scaricare in anticipo tutti i modelli piccoli.

# 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 struttura delle directory finale dovrebbe apparire come segue:

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

Elenco dei modelli supportati

I modelli di piccole dimensioni saranno automaticamente mappati nel modo seguente:

  1. w2v-bert-2.0 (models--facebook--w2v-bert-2.0) - Modello di estrazione delle caratteristiche

  2. campplus (models--funasr--campplus) - Modello di riconoscimento del parlante

  3. bigvgan (models--nvidia--bigvgan_v2_22khz_80band_256x) - modello encoder vocale

  4. Decodificatore semantico (models--amphion--MaskGCT) - Modello di codifica/decodifica semantica

Avviare IndexTTS2 in modalità offline

All’avvio di IndexTTS2 tramite Web UI, è possibile aggiungere parametri aggiuntivi: - small_models_dir - percorso della directory contenente tutti i modelli di piccole dimensioni.

Quando si avvia tramite riga di comando, è possibile aggiungere le seguenti opzioni:

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

Usando il client Python all’avvio:

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