Whisper e Piper em uma VPS sem GPU

Fala para texto e TTS auto-hospedados, em resumo

A conversão de fala para texto e o TTS (texto para fala) auto-hospedados são os tipos mais baratos de IA que pode executar num servidor sob o seu controlo. A transcrição executa o Whisper através do runtime faster-whisper. A síntese usa o Piper. Ambos funcionam numa VPS com CPU comum, sem qualquer GPU. O modelo Whisper pequeno precisa de cerca de 484 MB de disco, e uma voz do Piper é composta por dois ficheiros, um modelo ONNX e uma pequena configuração JSON, que juntos ocupam bem menos de 150 MB.

É por isso que o áudio é o melhor ponto de partida. Um gerador de imagens auto-hospedado e a geração de vídeo auto-hospedada precisam de uma GPU antes de serem minimamente utilizáveis. O áudio não precisa.

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

Todas as versões fixadas nos comandos deste guia foram verificadas 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. Os pesos são idênticos, portanto a transcrição também é idêntica. A diferença está exclusivamente no ambiente de execução.

O CTranslate2 quantiza os pesos durante o carregamento. Por isso, compute_type="int8" é um único argumento, e não uma etapa de conversão separada. Ele também não depende do PyTorch. pip install faster-whisper instala o CTranslate2, um tokenizer e o PyAV para descodificação de áudio. Assim, o ambiente virtual ocupa algumas centenas de megabytes, em vez de vários gigabytes. Num VPS com um disco de 40 GB, essa diferença separa uma instalação confortável de uma instalação apertada.

Estes são os números publicados 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 corresponde a esses 13 minutos divididos pelo tempo medido: 7.6 significa que uma gravação de 13 minutos terminou em pouco mais de 1 minuto e 40 segundos.

[
  {
    "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. Além disso, usa menos de metade da memória. É a mesma família ggml usada pelo componente llama.cpp da stack de LLM local. O faster-whisper torna-se mais rápido quando int8 e o processamento em lotes estão ativados, chegando a 15.3x, e usa 3,608 MB de RAM para isso. Portanto: escolha o faster-whisper para a API Python e o processamento em lotes; escolha o whisper.cpp quando a RAM for a limitação que não pode ultrapassar.

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

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

[
  {
    "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 externos de legendas colocados junto ao vídeo e com 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 cliente pode reproduzi-la diretamente, ou o servidor pode fazer remux ou incorporá-la no vídeo. Isto depende do que o cliente suporta.

Extraia primeiro o áudio. O Whisper reamostra tudo internamente para mono a 16 kHz. Fornecer áudio mono a 16 kHz reduz o 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 SRT. Por isso, formate você mesmo os segmentos. 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 não é decoração. Sem essa opção, o ffmpeg lê a entrada padrão do loop, consome o restante da lista de ficheiros e o loop para depois de um único filme, sem apresentar qualquer mensagem de erro.

Calcule o tempo necessário antes de começar. À velocidade de 7.6x indicada acima, um filme de 100 minutos precisa de aproximadamente 13 minutos de CPU. Uma biblioteca com cinquenta filmes será processada durante a noite. Num plano com vCPU partilhada, o processo será ainda mais lento. É para isso que serve nice: o processamento das legendas cede então tempo de CPU às restantes tarefas do servidor.

Texto para fala com Piper

Piper é um mecanismo neural de conversão de texto em fala 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 oradores. 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 reprodutor procura no diretório de trabalho e não encontra uma voz que não esteja nesse diretório.

O -- antes do texto também é importante. Sem ele, qualquer frase iniciada por um hífen é interpretada como uma opção da linha de comandos.

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

Não chame a CLI dentro de um ciclo. O modelo é carregado em cada execução, e esse carregamento 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 funciona. Esse endpoint usa 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 resolve esse problema.

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

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 terminal e 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 serviço e volta a iniciá-lo depois de um reboot. Se o comando curl acima não devolver nada, journalctl -u piper -n 50 contém o motivo. O mais comum é faltar o ficheiro da voz.

O formato de servidor compatível com OpenAI

A maioria dos programas que processam áudio já utiliza 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. Sirva esses dois caminhos diretamente e o cliente só precisa de uma alteração: o URL base.

O Speaches é um servidor que trata das duas direções. Executa 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. O projeto ainda não chegou à versão 1.0. Por isso, fixe a tag da imagem e leia as notas de 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 com um ú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 muitas pessoas esquecem. Sem ele, a cache dos modelos fica dentro do contentor. Assim, cada reinício volta a transferir gigabytes de pesos antes de responder ao primeiro pedido.

A síntese de voz precisa que uma voz seja 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 é necessário porque a biblioteca cliente da OpenAI recusa enviar um pedido sem esse valor. O servidor ignora o valor até configurar uma chave real.

O vox-box é o outro projeto que vale a pena mencionar. É um pacote Python, 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 a porta 80, o que requer root ou a capacidade 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, precisa de uma segunda instância numa segunda porta, com um repo id de voz.

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. Um 404 para o nome do modelo significa que tentou adivinhar em vez de ler a saída de /v1/models.

Nenhum destes servidores ativa a autenticação por predefinição. Associe-os a 127.0.0.1 e aceda a eles 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 qualquer pessoa que o encontre. E essas pessoas vão encontrá-lo.

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 realmente vale a pena?

[
  {
    "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 grande em int8 funciona a 13.2x do tempo real e ocupa 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 large-v2 e as linhas da CPU usam small. A GPU não torna o modelo small seis vezes mais rápido. Ela torna o modelo mais preciso utilizável.

Um plano partilhado de vCPU não atingirá os valores da CPU. Esse benchmark tinha 8 threads de um processador de desktop rápido exclusivamente disponíveis. Considere 7.6x 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 se confirmam no uso real:

• Transcrição ocasional das suas próprias gravações: CPU, small, int8. Duas vCPU dedicadas são suficientes.
• Processamento em lote durante a noite, como a geração de legendas: CPU, small ou medium, int8, executado com nice.
• Qualquer tarefa interativa ou o 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 abrangente sobre que 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 durante a instalação. O Python do sistema está protegido pela distribuição. Crie um ambiente virtual como mostrado acima.

Incompatibilidade do cuDNN num host 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 mais antigo com pip install --force-reinstall ctranslate2==4.4.0. Faça apenas uma destas opções. Fazer ambas deixa o sistema no estado inicial.

This CTranslate2 package was not compiled with CUDA support indica uma falha diferente, mas com um aspeto semelhante. O wheel instalado é a compilação apenas para CPU. Recrie o ambiente virtual no host com GPU e deixe o pip escolher novamente o wheel.

Frases repetidas na transcrição. Uma frase repetida dez vezes quase sempre significa que silêncio ou música está a ser descodificado como fala. Ative primeiro vad_filter=True. Se o problema persistir, ouça o segmento: áudio quase silencioso não fornece ao Whisper um ponto de referência e o modelo repete a última hipótese em que teve confiança.

Idioma detetado incorretamente. Por predefinição, o faster-whisper faz a estimativa apenas com a primeira janela de 30 segundos. Um info.language_probability muito abaixo de 1.0 significa que o modelo ficou inseguro. 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 modelo analise mais janelas antes de decidir.

O processo imprime Killed e para. Esse é o mecanismo do kernel que termina processos por falta de memória, e dmesg mostrará a linha correspondente de oom-kill. O large-v3 precisa de mais de 3 GB apenas para os pesos, antes de qualquer memória de trabalho. Numa VPS de 2 GB, o small com int8 é o maior modelo que cabe.

O Piper não encontra a voz. O reprodutor 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, porque a ausência de qualquer um dos dois causa uma falha, tal como a ausência de ambos.

FAQ

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

Sim. Para processamento em lote, é 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 do tempo real, com 1,477 MB de RAM. Um plano com vCPU partilhada é mais lento do que isso, por isso meça o 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 com small em int8. Ocupa 484 MB em disco e lida bem com voz gravada e 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, porque requer 3,090 MB de disco e mais de 3 GB de memória. No sentido oposto, tiny, com 75.5 MB, é útil para detetar o idioma e testar um pipeline, mas não para transcrições que uma pessoa vá ler.

Por que o 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 o faster-whisper executa os mesmos pesos em CTranslate2, um motor 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, isso corresponde a 1.9x do tempo real para o pacote de referência, contra 7.6x para o faster-whisper em int8, com menor utilização 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 voz e a reutilizar a sua última previsão com elevada confiança. Defina vad_filter=True na chamada transcribe(). Essa opção executa primeiro a deteção de atividade vocal do Silero e remove os trechos silenciosos antes de o modelo os processar. Se continuar a repetir, verifique o nível de áudio. Uma gravação praticamente silenciosa do princípio ao fim 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, indique esse servidor ao cliente através de uma nova URL base. Speaches é uma opção. É publicado como uma imagem de container com uma build para CPU e usa faster-whisper para transcrição e Piper ou Kokoro para síntese de voz. vox-box é outra opção. Instale-o com pip install vox-box e inicie-o com vox-box start --huggingface-repo-id. Ele disponibiliza um modelo por processo. Nenhuma das opções ativa autenticação por predefinição. Por isso, faça o bind em localhost e coloque um proxy ou uma VPN à frente.