SSD Nodes Learn Hosting plans →
Guias Matt ConnorPor Matt Connor

Whisper e Piper em uma VPS sem GPU

Execute Whisper e Piper em uma VPS comum, saiba quanto gastam de CPU e disco e exponha uma API compatível com OpenAI para seus clientes.

Conversão de voz para texto e TTS autoalojados, em resumo

A conversão de voz para texto e o TTS (text to speech) autoalojados são executados num servidor que controla. A transcrição usa o Whisper através do runtime faster-whisper. A síntese usa o Piper. Ambos funcionam numa VPS com CPU comum, sem GPU. O modelo Whisper pequeno ocupa cerca de 484 MB de disco, e uma voz Piper é composta por dois ficheiros: um modelo ONNX e uma pequena configuração JSON, que em conjunto ocupam bem menos de 150 MB.

Por isso, o áudio é o melhor ponto de partida. Um gerador de imagens autoalojado e a geração de vídeo autoalojada precisam de uma GPU antes de serem utilizáveis. O áudio não precisa.

Este guia abrange as duas direções e a camada que as integra. O Whisper converte áudio em texto. O Piper converte texto em áudio. Um servidor HTTP compatível com OpenAI à frente de ambos permite apontar um cliente existente para o seu servidor, alterando apenas o URL base.

Cada versão fixada num comando deste guia foi verificada na página de releases do respetivo projeto em 11 de outubro de 2026. As versões do CTranslate2 indicadas na secção de falhas são marcadores de compatibilidade, não releases atuais.

Por que faster-whisper, e não o pacote de referência Whisper

O pacote whisper da OpenAI executa o modelo em PyTorch. O faster-whisper executa os mesmos pesos do modelo no CTranslate2, um mecanismo de inferência desenvolvido especificamente para modelos transformer. O modelo é o mesmo, mas as configurações de quantização e decodificação afetam a transcrição. O runtime explica a diferença de velocidade medida abaixo.

O CTranslate2 quantiza os pesos ao carregá-los. Por isso, compute_type="int8" é um único argumento, e não uma etapa de conversão separada. Ele também não tem dependência do PyTorch. pip install faster-whisper instala o CTranslate2, um tokenizer e o PyAV para a decodificação de áudio. Assim, o ambiente virtual ocupa centenas de megabytes, em vez de vários gigabytes. Numa VPS com um disco de 40 GB, essa diferença separa uma instalação folgada de uma instalação apertada.

Estas são as métricas publicadas pelo próprio projeto para o modelo small em CPU. O benchmark transcreve 13 minutos de áudio usando 8 threads num Intel Core i7-12700K. A coluna x_realtime é o resultado de dividir esses 13 minutos pelo tempo medido: 7.6 significa que uma gravação de 13 minutos terminou em pouco mais de 1 minuto e 40 segundos.

GráficoWhisper small on CPU, 13 minutes of audio (published project figures)
Os dados por trás deste gráfico
[
  {
    "label": "openai/whisper, fp32",
    "x_realtime": 1.9,
    "seconds": 418,
    "memory_mb": "2,335"
  },
  {
    "label": "whisper.cpp, fp32",
    "x_realtime": 6.2,
    "seconds": 125,
    "memory_mb": "1,049"
  },
  {
    "label": "faster-whisper, fp32",
    "x_realtime": 5.0,
    "seconds": 157,
    "memory_mb": "2,257"
  },
  {
    "label": "faster-whisper, int8",
    "x_realtime": 7.6,
    "seconds": 102,
    "memory_mb": "1,477"
  },
  {
    "label": "faster-whisper, int8, batch 8",
    "x_realtime": 15.3,
    "seconds": 51,
    "memory_mb": "3,608"
  }
]

Leia a segunda linha com atenção. Em fp32, o whisper.cpp é mais rápido do que o faster-whisper nesta CPU: 6.2x contra 5.0x, e usa menos de metade da memória. É a mesma família ggml usada por a parte do llama.cpp da pilha de LLM local. O faster-whisper passa à frente quando int8 e o processamento em lotes estão ativos, atingindo 15.3x, e usa 3,608 MB de RAM para isso. Portanto: escolha faster-whisper para a API Python e o processamento em lotes; escolha whisper.cpp quando a RAM for a restrição que não pode alterar.

A primeira linha é o ponto desta seção. O pacote de referência atinge 1.9x do tempo real na mesma máquina. Isso significa que 1 hora de áudio demora meia hora de CPU.

Quanto espaço em disco ocupam os pesos dos modelos Whisper?

Gráficofaster-whisper model weights on disk (Systran CTranslate2 conversions, float16)
Os dados por trás deste gráfico
[
  {
    "label": "tiny",
    "weights_mb": 75.5
  },
  {
    "label": "base",
    "weights_mb": 145
  },
  {
    "label": "small",
    "weights_mb": 484
  },
  {
    "label": "medium",
    "weights_mb": "1,530"
  },
  {
    "label": "large-v3",
    "weights_mb": "3,090"
  }
]

Estas são as conversões publicadas pelo CTranslate2, em float16. Tenha em atenção o que compute_type="int8" não faz: não reduz o tamanho do download. Os pesos são obtidos em float16, e o CTranslate2 quantiza-os na memória no momento do carregamento. Por isso, large-v3 ocupa 3,090 MB em disco, quer seja executado em float16, quer em int8. int8 reduz o uso de RAM e aumenta a velocidade, mas não reduz o espaço em disco.

Os modelos são descarregados na primeira utilização para ~/.cache/huggingface/hub. Num VPS com um volume raiz pequeno, indique um local com espaço suficiente utilizando o argumento download_root ou a variável de ambiente HF_HOME. Caso contrário, a primeira execução pode encher o disco e o processo termina a meio do download.

Instalar faster-whisper sem danificar o Python do sistema

O Ubuntu 24.04 e o Debian 13 marcam o Python do sistema como gerido externamente. Executar pip install faster-whisper fora de um ambiente virtual termina imediatamente com:

error: externally-managed-environment

Esse é o sistema de empacotamento a proteger os ficheiros pertencentes a apt. Use um ambiente virtual.

sudo apt update
sudo apt install -y python3-venv ffmpeg
python3 -m venv ~/stt
~/stt/bin/pip install --upgrade pip
~/stt/bin/pip install faster-whisper==1.2.1

A versão 1.2.1 é a versão atual, publicada em outubro de 2025. O faster-whisper descodifica áudio através do PyAV, que inclui as suas próprias bibliotecas ffmpeg. Por isso, lê ficheiros mp3 ou m4a sem um binário ffmpeg separado. O pacote ffmpeg acima é usado para o processamento de vídeo mais adiante neste guia.

Verifique a instalação antes de transferir três gigabytes de pesos:

~/stt/bin/python -c "from faster_whisper import WhisperModel; print('ok')"

Uma linha com ok significa que os wheels foram instalados. Um ImportError com o nome ctranslate2 significa que o runtime está em falta ou que a biblioteca compilada não foi carregada. O restante da mensagem indica qual dos casos ocorreu. Em imagens ARM de 32 bits, não existe qualquer wheel do CTranslate2. Nesse caso, o pip falha durante a instalação.

Transcrever uma gravação de reunião ou uma nota de voz

Guarde isto como transcribe.py:

from faster_whisper import WhisperModel

model = WhisperModel("small", device="cpu", compute_type="int8", cpu_threads=4)
segments, info = model.transcribe("meeting.m4a", beam_size=5, vad_filter=True)

print("language: %s (%.2f)" % (info.language, info.language_probability))
for segment in segments:
    print("[%.2fs -> %.2fs] %s" % (segment.start, segment.end, segment.text))

Execute-o com ~/stt/bin/python transcribe.py. Na primeira execução, os pesos são transferidos, por isso nada é apresentado durante algum tempo. Depois disso, o modelo é carregado da cache em poucos segundos.

segments é um gerador, por isso a transcrição só começa quando faz iteração sobre ele. É comum medir a chamada transcribe(), verificar que ela retorna imediatamente e concluir que algo está errado. Nada está errado. O processamento ocorre no loop.

vad_filter=True executa primeiro o Silero VAD (deteção de atividade vocal) e remove os trechos silenciosos antes de o Whisper os processar. Numa gravação de reunião com pausas longas, este é o maior ganho de velocidade isolado disponível, porque o Whisper não perde tempo com áudio sem fala. Isto também reduz os loops de frases repetidas que o Whisper produz quando recebe silêncio e tenta encontrar palavras nele.

Defina cpu_threads como o número de cores que realmente tem. Defini-lo acima do número de vCPUs torna a transcrição mais lenta, porque as threads adicionais competem pelo mesmo core e o scheduler paga o custo de cada troca.

Legendas para uma biblioteca Jellyfin

O Jellyfin lê ficheiros de legendas externos que ficam junto do vídeo e têm o mesmo nome. Assim, Movie (2019).en.srt junto de Movie (2019).mkv aparece como uma faixa em inglês sem reconstruir a biblioteca. O facto de um cliente reproduzir essa faixa diretamente, de o servidor fazer remux ou de a incorporar no vídeo depende do que esse cliente suporta.

Extraia primeiro o áudio. O Whisper reamostra internamente tudo para mono a 16 kHz. Fornecer-lhe áudio mono a 16 kHz evita trabalho nos dois lados:

ffmpeg -i "Movie (2019).mkv" -vn -ac 1 -ar 16000 -c:a pcm_s16le "Movie (2019).wav"

O faster-whisper não tem um gravador de SRT. Por isso, formate os segmentos manualmente. Guarde isto como srt.py:

import sys
from faster_whisper import WhisperModel

def ts(seconds):
    ms = int(round(seconds * 1000))
    hours, ms = divmod(ms, 3600000)
    minutes, ms = divmod(ms, 60000)
    secs, ms = divmod(ms, 1000)
    return "%02d:%02d:%02d,%03d" % (hours, minutes, secs, ms)

model = WhisperModel("small", device="cpu", compute_type="int8")
segments, info = model.transcribe(sys.argv[1], vad_filter=True)

with open(sys.argv[2], "w", encoding="utf-8") as out:
    for index, segment in enumerate(segments, start=1):
        out.write("%d\n" % index)
        out.write("%s --> %s\n" % (ts(segment.start), ts(segment.end)))
        out.write("%s\n\n" % segment.text.strip())

Depois, percorra a biblioteca:

for f in /srv/media/films/*.mkv; do
  ffmpeg -nostdin -y -i "$f" -vn -ac 1 -ar 16000 -c:a pcm_s16le "${f%.mkv}.wav"
  nice -n 15 ~/stt/bin/python srt.py "${f%.mkv}.wav" "${f%.mkv}.en.srt"
  rm -f "${f%.mkv}.wav"
done

-nostdin desativa a interação por teclado do ffmpeg. Também impede que o ffmpeg consuma nomes de ficheiros quando é executado dentro de um ciclo que os lê da entrada padrão. O ciclo baseado em glob acima não lê a lista de ficheiros da entrada padrão.

Calcule o tempo necessário antes de começar. Com o valor de 7.6x indicado acima, um filme de 100 minutos precisa de cerca de 13 minutos de CPU. Assim, uma biblioteca com cinquenta filmes é uma tarefa para executar durante a noite. Num plano vCPU partilhado, o processo é ainda mais lento. É para isso que serve nice: o processamento das legendas cede então tempo de CPU a qualquer outra tarefa que o servidor esteja a executar.

Conversão de texto em voz com Piper

Piper é um mecanismo neuronal de conversão de texto em voz que executa um modelo de voz ONNX na CPU. Inclui o espeak-ng para converter texto em fonemas, por isso não é necessário instalar um fonemizador separado. A versão atual é a 1.8.0, publicada em setembro de 2026.

python3 -m venv ~/tts
~/tts/bin/pip install piper-tts==1.8.0
~/tts/bin/python -m piper.download_voices en_US-lessac-medium
~/tts/bin/python -m piper -m en_US-lessac-medium -f test.wav -- 'This is a test.'

download_voices escreve dois ficheiros no diretório de trabalho: os pesos .onnx e uma configuração .onnx.json que contém a frequência de amostragem e a lista de locutores. Estes ficheiros têm de permanecer juntos. Se guardar as vozes num local fixo, passe --data-dir aos dois comandos, porque, caso contrário, o leitor procura no diretório de trabalho e não encontra uma voz que não esteja lá.

O -- antes do texto também é importante. Separa o texto das opções da linha de comandos, incluindo opções que uma frase iniciada por um hífen poderia ativar.

As vozes são disponibilizadas com vários níveis de qualidade. Uma voz inglesa de qualidade média ocupa aproximadamente 60 MB e uma de alta qualidade ocupa cerca do dobro. Uma qualidade superior significa um modelo maior e mais CPU por segundo de fala, não um locutor diferente.

Não invoque a CLI num ciclo. O modelo é carregado em cada invocação, e o carregamento do modelo domina o custo de uma frase curta. Execute antes o servidor HTTP:

~/tts/bin/pip install 'piper-tts[http]==1.8.0'
~/tts/bin/python -m piper.http_server -m en_US-lessac-medium --host 127.0.0.1 --port 5000
curl -X POST -H 'Content-Type: application/json' \
  -d '{ "text": "This is a test." }' \
  -o test.wav localhost:5000/synthesize

Se conseguir reproduzir um test.wav, significa que está a funcionar. Esse endpoint tem o formato próprio do Piper, não o da OpenAI, por isso um cliente que espere /v1/audio/speech não conseguirá comunicar com ele. A secção seguinte corrige isso.

Mantenha-o em execução com um ficheiro de unidade, em vez de depender de um terminal que irá fechar. A unidade executa o Piper como o utilizador piper, sem login, a partir do diretório pessoal desse utilizador. Assim, o serviço não depende da sua conta. Crie o utilizador e instale aí o Piper e a voz:

sudo useradd --system --create-home --home-dir /home/piper --shell /usr/sbin/nologin piper
sudo -u piper python3 -m venv /home/piper/tts
sudo -u piper /home/piper/tts/bin/pip install 'piper-tts[http]==1.8.0'
sudo -u piper /home/piper/tts/bin/python -m piper.download_voices --data-dir /home/piper/voices en_US-lessac-medium

Pare o servidor que iniciou no seu terminal e depois escreva a unidade:

[Unit]
Description=Piper text to speech HTTP server
After=network-online.target

[Service]
User=piper
ExecStart=/home/piper/tts/bin/python -m piper.http_server -m en_US-lessac-medium --data-dir /home/piper/voices --host 127.0.0.1 --port 5000
Restart=on-failure

[Install]
WantedBy=multi-user.target

sudo systemctl enable --now piper inicia-o e volta a iniciá-lo depois de um reboot. Se o curl acima não devolver nada, journalctl -u piper -n 50 contém o motivo. Um ficheiro de voz em falta é a causa mais comum.

O formato de servidor compatível com OpenAI

A maioria dos softwares que processam áudio já usa a API de áudio da OpenAI: um POST multipart para /v1/audio/transcriptions para enviar um ficheiro e um POST JSON para /v1/audio/speech para enviar uma frase. Disponibilize esses dois caminhos e o cliente precisará de uma única alteração: o URL base.

O Speaches é um servidor que suporta as duas direções. Usa faster-whisper para transcrição e Piper ou Kokoro para síntese de voz, através dos caminhos da OpenAI. A versão atual é v0.9.0-rc.3, de December 2025, e o projeto ainda está antes da versão 1.0. Fixe a tag da imagem e leia as notas da versão antes de atualizar.

curl --silent --remote-name https://raw.githubusercontent.com/speaches-ai/speaches/master/compose.yaml
curl --silent --remote-name https://raw.githubusercontent.com/speaches-ai/speaches/master/compose.cpu.yaml
export COMPOSE_FILE=compose.cpu.yaml
docker compose up --detach

A forma de executar tudo num único contentor, se preferir não manter ficheiros compose:

docker run --rm --detach --publish 8000:8000 --name speaches \
  --volume hf-hub-cache:/home/ubuntu/.cache/huggingface/hub \
  ghcr.io/speaches-ai/speaches:latest-cpu

O volume nomeado é a parte que costuma ser esquecida. Sem ele, a cache dos modelos fica dentro do contentor. Remover e recriar o contentor apaga os pesos transferidos. Reiniciar o mesmo contentor preserva-os.

A síntese de voz precisa de uma voz transferida antes de /v1/audio/speech responder:

uvx speaches-cli model download speaches-ai/Kokoro-82M-v1.0-ONNX

Depois disso, qualquer cliente OpenAI funciona se alterar o URL base:

from pathlib import Path
from openai import OpenAI

openai = OpenAI(base_url="http://localhost:8000/v1", api_key="cant-be-empty")
res = openai.audio.speech.create(
    model="speaches-ai/Kokoro-82M-v1.0-ONNX",
    voice="af_heart",
    input="Hello, world!",
    response_format="mp3",
    speed=1,
)
with Path("output.mp3").open("wb") as f:
    f.write(res.response.read())

O marcador api_key é obrigatório porque a biblioteca cliente da OpenAI recusa enviar um pedido sem ele. O servidor ignora o seu valor até configurar uma chave real.

O vox-box é o outro projeto que vale a pena mencionar. É um pacote Python, e não um contentor, e disponibiliza os mesmos caminhos com Whisper, FunASR, Bark, Dia ou CosyVoice. A versão atual é 0.0.21, de December 2025, e requer Python 3.10 ou posterior.

python3 -m venv ~/voice
~/voice/bin/pip install vox-box==0.0.21
~/voice/bin/vox-box start --huggingface-repo-id Systran/faster-whisper-small \
  --data-dir ~/voice/data --host 127.0.0.1 --port 8010

O exemplo do próprio projeto associa-se à porta 80, o que requer root ou a capability CAP_NET_BIND_SERVICE. Num servidor que execute outros serviços, é melhor usar uma porta alta atrás de um reverse proxy. vox-box start aceita um único modelo. Para suportar as duas direções, execute uma segunda instância numa segunda porta, com um speech repo id.

Peça ao servidor a lista do que carregou e use esse id no campo model:

curl http://127.0.0.1:8010/v1/models
curl http://127.0.0.1:8010/v1/audio/transcriptions \
  -H "Content-Type: multipart/form-data" \
  -F file="@voice-note.m4a" \
  -F model="faster-whisper-small"

Um corpo JSON no formato {"text": "..."} indica que todo o caminho funciona. Em caso de 404, leia o corpo da resposta e compare o model id com /v1/models. O Speaches também devolve 404 quando o modelo é válido, mas não está instalado localmente. Se o erro indicar isso, transfira o modelo pedido com uvx speaches-cli model download MODEL_ID e tente novamente. A rota de transferência é POST /v1/models/{model_id}.

Nenhum destes servidores ativa a autenticação por predefinição. Associe-os a 127.0.0.1 e aceda-lhes através de uma VPN ou de um reverse proxy que peça credenciais. Um /v1/audio/transcriptions aberto num IP público fornece CPU gratuitamente a quem o encontrar, e será encontrado.

Uma interface de voz para um assistente autoalojado

Quando ambos os sentidos respondem através de endpoints OpenAI, uma interface de chat pode controlá-los. O Open WebUI e as respetivas alternativas aceitam um URL base compatível com OpenAI para o áudio nas definições, pelo que uma única máquina pode executar um LLM local com Ollama e fechar o circuito de voz em ambas as extremidades.

Faça uma estimativa realista da latência, porque estes três passos são executados sequencialmente nos mesmos núcleos. Uma pergunta de 10 segundos demora cerca de 1.3 segundos a transcrever no valor de 7.6x indicado acima, antes de o modelo ler um único token. Some a geração de tokens no CPU e o tempo total é suficientemente elevado para os testadores assumirem que o serviço falhou. A transcrição em lote é confortável no CPU. A conversação não é, e é neste ponto que um VPS com GPU começa a justificar o preço.

Quando a GPU vale realmente a pena?

GráficoWhisper large-v2 on an RTX 3070 Ti, 13 minutes of audio (published project figures)
Os dados por trás deste gráfico
[
  {
    "label": "openai/whisper, fp16",
    "x_realtime": 5.5,
    "seconds": 143,
    "memory_mb": "4,708"
  },
  {
    "label": "faster-whisper, fp16",
    "x_realtime": 12.4,
    "seconds": 63,
    "memory_mb": "4,525"
  },
  {
    "label": "faster-whisper, int8",
    "x_realtime": 13.2,
    "seconds": 59,
    "memory_mb": "2,926"
  },
  {
    "label": "faster-whisper, int8, batch 8",
    "x_realtime": 48.8,
    "seconds": 16,
    "memory_mb": "4,500"
  }
]

Na GPU, o modelo large em int8 é executado a 13.2x do tempo real e utiliza 2,926 MB de VRAM. Com processamento em lote, chega a 48.8x. Observe com atenção o que os dois gráficos não mostram. Eles usam modelos diferentes: as linhas da GPU usam o large-v2, e as linhas da CPU usam o small. A GPU não torna o modelo small seis vezes mais rápido. Ela torna o modelo mais preciso utilizável.

De onde vêm estes números

Os dois gráficos reproduzem o benchmark publicado no README do faster-whisper. O áudio é um único ficheiro de 13 minutos. As linhas da CPU usaram 8 threads num Intel Core i7-12700K, e as linhas da GPU usaram CUDA 12.4 numa NVIDIA RTX 3070 Ti com 8 GB de VRAM. As colunas de segundos e memória contêm os valores publicados. A coluna x_realtime é calculada a partir desses valores: 780 segundos de áudio divididos pelo tempo medido, arredondados para uma casa decimal. A coluna de memória representa a RAM do sistema no gráfico da CPU e a VRAM no gráfico da GPU.

Um plano partilhado de vCPU não atingirá os valores da CPU. Esse benchmark tinha 8 threads de um processador desktop rápido dedicadas exclusivamente à tarefa. Considere 7.6x como um limite superior e meça o seu próprio servidor com time numa gravação real antes de planear qualquer coisa com base nesse valor.

Quatro regras práticas que costumam funcionar:

  • Transcrição ocasional das suas próprias gravações: CPU, small, int8. Comece com duas vCPU dedicadas e meça o tempo de transcrição.
  • Processamento em lote durante a noite, como gerar legendas: CPU, small ou medium, int8, executado com nice.
  • Qualquer utilização interativa ou processamento de uma biblioteca inteira numa só noite: GPU.
  • Piper: CPU, sempre. Um modelo de voz deste tamanho quase não beneficia de uma GPU.

Se estiver a avaliar que outras cargas o mesmo hardware pode suportar, a questão mais ampla sobre quais modelos de IA pode alojar localmente aborda os tamanhos que cabem e os que não cabem.

Modos de falha e as mensagens que verá

error: externally-managed-environment na instalação. O Python do sistema está protegido pela distribuição. Crie um ambiente virtual conforme mostrado acima.

Incompatibilidade do cuDNN numa máquina com GPU. A falha aparece assim:

Unable to load any of {libcudnn_ops.so.9.1.0, libcudnn_ops.so.9.1, libcudnn_ops.so.9, libcudnn_ops.so}
Invalid handle. Cannot load symbol cudnnCreateTensorDescriptor

O CTranslate2 4.5.0 passou as suas compilações para CUDA 12 para o cuDNN 9, mas o host tem o cuDNN 8. Instale o cuDNN 9 ou fixe o runtime antigo com pip install --force-reinstall ctranslate2==4.4.0. Faça uma das duas coisas. Fazer ambas deixa-o na situação inicial.

This CTranslate2 package was not compiled with CUDA support é uma falha diferente, mas com um comportamento semelhante. A compilação instalada do CTranslate2 não tem suporte para CUDA. Os wheels oficiais para Linux e Windows suportam execução na GPU. Verifique a plataforma e a origem do pacote e instale uma compilação com suporte para CUDA. Recriar o mesmo ambiente com a mesma compilação apenas para CPU não resolve o problema.

Frases repetidas na transcrição. Uma frase que se repete dez vezes quase sempre indica que silêncio ou música estão a ser descodificados como fala. Ative primeiro vad_filter=True. Se o problema persistir, ouça o segmento: um áudio quase silencioso não fornece ao Whisper informação suficiente para se orientar, e o programa repete a última hipótese em que confiou.

Idioma detetado incorretamente. Por predefinição, o faster-whisper faz a previsão apenas com a primeira janela de 30 segundos. Um info.language_probability muito abaixo de 1.0 indica incerteza. Isto acontece quando a gravação começa com música ou com vozes sobrepostas. Passe language="en" quando já souber a resposta ou aumente language_detection_segments para que o programa examine mais janelas antes de decidir.

O processo imprime Killed e para. Verifique dmesg à procura de uma linha oom-kill correspondente, para confirmar que o kernel terminou o processo por falta de memória. O large-v3 descarrega mais de 3 GB de pesos float16, mas o int8 reduz a memória necessária no carregamento. O benchmark publicado do modelo small com int8 usa 1,477 MB de RAM, pelo que uma VPS com 2 GB deixa pouco espaço para o sistema operativo e os restantes serviços.

O Piper não encontra a voz. O player procura no diretório de trabalho, a menos que passe --data-dir. Execute ls no diretório esperado e confirme que .onnx e .onnx.json estão presentes. A ausência de qualquer um dos dois impede o funcionamento.

FAQ

Posso executar conversão de voz para texto numa VPS apenas com CPU?

Sim. Para processamento em lote, essa é a opção mais sensata. Com faster-whisper e o modelo small em int8, o benchmark publicado pelo projeto converte 13 minutos de áudio em 102 segundos usando 8 threads de um i7 de desktop, cerca de 7.6x o tempo real, com 1,477 MB de RAM. Um plano com vCPU partilhada é mais lento do que isso, por isso meça o desempenho no seu próprio servidor. A conversão de texto para voz com Piper é ainda mais simples e não precisa de GPU em nenhuma circunstância.

Que tamanho de modelo Whisper devo usar?

Comece pelo small em int8. O modelo ocupa 484 MB em disco e lida bem com voz gravada nítida. Passe para medium quando os sotaques ou o ruído de fundo causarem erros que não possa aceitar. Use large-v3 apenas quando a precisão for mais importante do que tudo o resto, pois requer 3,090 MB de disco. O consumo de RAM depende do tipo de computação e da carga de trabalho, por isso meça-o antes de escolher o tamanho da VPS. No sentido oposto, tiny, com 75.5 MB, é útil para deteção de idioma e para testar um pipeline, mas não para transcrições que uma pessoa vá ler.

Por que faster-whisper é mais rápido do que o pacote Whisper original?

O modelo é o mesmo. O runtime não é. O pacote de referência executa o Whisper em PyTorch, enquanto faster-whisper executa os mesmos pesos no CTranslate2, um mecanismo criado para inferência de transformers que quantiza os pesos durante o carregamento e não precisa de uma instalação do PyTorch. No benchmark de CPU publicado, o pacote de referência atinge 1.9x o tempo real, contra 7.6x do faster-whisper em int8, com menor consumo de memória.

Por que a minha transcrição repete a mesma frase continuamente?

O Whisper está a interpretar silêncio ou música como fala e a reutilizar a última previsão em que teve confiança. Defina vad_filter=True na chamada transcribe(). Essa opção executa primeiro a deteção de atividade de voz do Silero e remove os trechos silenciosos antes de o modelo os processar. Se a repetição continuar, verifique o nível do áudio. Uma gravação quase totalmente silenciosa não fornece informação suficiente ao modelo.

Como obtenho um endpoint de áudio compatível com OpenAI no meu próprio servidor?

Execute um servidor que implemente POST /v1/audio/transcriptions e POST /v1/audio/speech. Depois, aponte o cliente para esse servidor usando um novo URL base. Speaches é uma opção. É publicado como uma imagem de contentor com uma build para CPU, usando faster-whisper para transcrição e Piper ou Kokoro para conversão de texto para voz. vox-box é outra opção. Instala-se com pip install vox-box e inicia-se com vox-box start --huggingface-repo-id. Cada processo disponibiliza um modelo. Nenhuma das duas opções ativa a autenticação por predefinição. Por isso, faça o bind em localhost e coloque um proxy ou uma VPN à frente.

Este artigo foi útil?

#whisper#tts#piper#speech-to-text#self-hosted-ai