Inferência

Como o modelo vocoder foi alterado, você precisa de mais VRAM do que antes, sendo recomendado 12GB para inferência fluente.

Suportamos linha de comando, API HTTP e WebUI para inferência, você pode escolher qualquer método que preferir.

Baixar Pesos

Primeiro você precisa baixar os pesos do modelo:

hf download fishaudio/openaudio-s1-mini --local-dir checkpoints/openaudio-s1-mini

Inferência por Linha de Comando

Note

Se você planeja deixar o modelo escolher aleatoriamente um timbre de voz, pode pular esta etapa.

1. Obter tokens VQ do áudio de referência

python fish_speech/models/dac/inference.py \
    -i "ref_audio_name.wav" \
    --checkpoint-path "checkpoints/openaudio-s1-mini/codec.pth"

Você deve obter um fake.npy e um fake.wav.

2. Gerar tokens semânticos do texto:

python fish_speech/models/text2semantic/inference.py \
    --text "O texto que você quer converter" \
    --prompt-text "Seu texto de referência" \
    --prompt-tokens "fake.npy" \
    --compile

Este comando criará um arquivo codes_N no diretório de trabalho, onde N é um inteiro começando de 0.

Note

Você pode querer usar --compile para fundir kernels CUDA para inferência mais rápida (~30 tokens/segundo -> ~500 tokens/segundo). Correspondentemente, se você não planeja usar aceleração, pode comentar o parâmetro --compile.

Info

Para GPUs que não suportam bf16, você pode precisar usar o parâmetro --half.

3. Gerar vocais a partir de tokens semânticos:

Aviso Futuro

Mantivemos a interface acessível do caminho original (tools/vqgan/inference.py), mas esta interface pode ser removida em versões subsequentes, então por favor altere seu código o mais breve possível.

python fish_speech/models/dac/inference.py \
    -i "codes_0.npy"

Inferência com API HTTP

Fornecemos uma API HTTP para inferência. Você pode usar o seguinte comando para iniciar o servidor:

python -m tools.api_server \
    --listen 0.0.0.0:8080 \
    --llama-checkpoint-path "checkpoints/openaudio-s1-mini" \
    --decoder-checkpoint-path "checkpoints/openaudio-s1-mini/codec.pth" \
    --decoder-config-name modded_dac_vq

Se você quiser acelerar a inferência, pode adicionar o parâmetro --compile.

Depois disso, você pode visualizar e testar a API em http://127.0.0.1:8080/.

Inferência GUI

Baixar cliente

Inferência WebUI

Você pode iniciar o WebUI usando o seguinte comando:

python -m tools.run_webui \
    --llama-checkpoint-path "checkpoints/openaudio-s1-mini" \
    --decoder-checkpoint-path "checkpoints/openaudio-s1-mini/codec.pth" \
    --decoder-config-name modded_dac_vq

Ou simplesmente

python -m tools.run_webui

Se você quiser acelerar a inferência, pode adicionar o parâmetro --compile.

Note

Você pode salvar o arquivo de rótulo e o arquivo de áudio de referência antecipadamente na pasta references no diretório principal (que você precisa criar), para que possa chamá-los diretamente no WebUI.

Note

Você pode usar variáveis de ambiente do Gradio, como GRADIO_SHARE, GRADIO_SERVER_PORT, GRADIO_SERVER_NAME para configurar o WebUI.

Inferência com Docker

O OpenAudio fornece contentores Docker para inferência tanto na WebUI como no servidor API. Pode usar diretamente o comando docker run para iniciar o contentor.

É necessário preparar o seguinte: - Docker e NVIDIA Docker runtime instalados (para suporte de GPU) - Pesos do modelo descarregados (consulte a secção Baixar Pesos) - Ficheiros de áudio de referência (opcional, para clonagem de voz)

# Criar diretórios para os pesos do modelo e áudios de referência
mkdir -p checkpoints references

# Descarregar os pesos do modelo (se ainda não o fez)
# hf download fishaudio/openaudio-s1-mini --local-dir checkpoints/openaudio-s1-mini

# Iniciar a WebUI com suporte CUDA (recomendado para melhor desempenho)
docker run -d \
    --name fish-speech-webui \
    --gpus all \
    -p 7860:7860 \
    -v ./checkpoints:/app/checkpoints \
    -v ./references:/app/references \
    -e COMPILE=1 \
    fishaudio/fish-speech:latest-webui-cuda

# Inferência apenas com CPU (mais lento, mas funciona sem GPU)
docker run -d \
    --name fish-speech-webui-cpu \
    -p 7860:7860 \
    -v ./checkpoints:/app/checkpoints \
    -v ./references:/app/references \
    fishaudio/fish-speech:latest-webui-cpu

# Iniciar o servidor API com suporte CUDA
docker run -d \
    --name fish-speech-server \
    --gpus all \
    -p 8080:8080 \
    -v ./checkpoints:/app/checkpoints \
    -v ./references:/app/references \
    -e COMPILE=1 \
    fishaudio/fish-speech:latest-server-cuda

# Inferência apenas com CPU
docker run -d \
    --name fish-speech-server-cpu \
    -p 8080:8080 \
    -v ./checkpoints:/app/checkpoints \
    -v ./references:/app/references \
    fishaudio/fish-speech:latest-server-cpu

Pode personalizar os contentores Docker usando estas variáveis de ambiente:

• COMPILE=1 - Ativa o torch.compile para uma inferência mais rápida (cerca de 10x, apenas com CUDA)
• GRADIO_SERVER_NAME=0.0.0.0 - Anfitrião do servidor WebUI (padrão: 0.0.0.0)
• GRADIO_SERVER_PORT=7860 - Porta do servidor WebUI (padrão: 7860)
• API_SERVER_NAME=0.0.0.0 - Anfitrião do servidor API (padrão: 0.0.0.0)
• API_SERVER_PORT=8080 - Porta do servidor API (padrão: 8080)
• LLAMA_CHECKPOINT_PATH=checkpoints/openaudio-s1-mini - Caminho para os pesos do modelo
• DECODER_CHECKPOINT_PATH=checkpoints/openaudio-s1-mini/codec.pth - Caminho para os pesos do descodificador
• DECODER_CONFIG_NAME=modded_dac_vq - Nome da configuração do descodificador ```

O uso da WebUI e do servidor API é o mesmo que o descrito no guia acima.

Divirta-se!