cerebro-vip INEMA.CLUB
início › INEMA.VOZ

Guia completo de STT (Speech-to-Text) local, cobrindo ferramentas…

INEMA.VOZ · 2025-09-09 · ~8 min · ver no Telegram ↗

INEMA

Aqui está o passo a passo já organizado em blocos de comandos, pronto para você copiar e colar.

Windows (PowerShell)⌗

# 1) Instalar pré-requisitos winget install -e --id Python.Python.3.10 winget install -e --id Git.Git winget install -e --id Gyan.FFmpeg

# 2) Criar e ativar ambiente (Conda) conda create -n asr python=3.10 -y conda activate asr

```# 3) Instalar PyTorch (CPU) pip install --index-url download.pytorch.org/whl/cpu ↗ torch torchvision torchaudio

ou GPU (CUDA 12.1)⌗

pip install torch torchvision torchaudio --index-url download.pytorch.org/whl/cu121``` ↗

# 4) Instalar bibliotecas de ASR pip install openai-whisper faster-whisper librosa soundfile jiwer

# 5) Testar python -c "import torch, whisper; print('ok', torch.cuda.is_available())" ffmpeg -version

# 6) Extrair áudio de vídeo ffmpeg -i input.mp4 -vn -ac 1 -ar 16000 -acodec pcm_s16le input.wav

# 7) Transcrever (Whisper CLI) whisper input.wav --model small --language pt --task transcribe --output_format txt,srt,vtt

# 8) Transcrever todos .wav da pasta Get-ChildItem *.wav | ForEach-Object { whisper $_.FullName --model small --language pt --output_format txt }

# 9) Script mínimo com faster-whisper @' from faster_whisper import WhisperModel import sys, torch, os audio = sys.argv[1] device = "cuda" if torch.cuda.is_available() else "cpu" model = WhisperModel("small", device=device, compute_type=("float16" if device=="cuda" else "int8")) segments, info = model.transcribe(audio, language="pt") base, _ = os.path.splitext(audio) with open(base + ".txt", "w", encoding="utf-8") as f: for s in segments: f.write(s.text.strip() + "\n") '@ | Set-Content transcrever.py python transcrever.py input.wav

Ubuntu (bash)⌗

# 1) Instalar pré-requisitos sudo apt-get update sudo apt-get install -y python3.10 python3.10-venv python3-pip git ffmpeg

# 2) Criar e ativar venv python3.10 -m venv asr source asr/bin/activate python -m pip install --upgrade pip

```# 3) Instalar PyTorch (CPU) pip install --index-url download.pytorch.org/whl/cpu ↗ torch torchvision torchaudio

ou GPU (CUDA 12.1)⌗

pip install torch torchvision torchaudio --index-url download.pytorch.org/whl/cu121``` ↗

# 4) Instalar bibliotecas de ASR pip install openai-whisper faster-whisper librosa soundfile jiwer

# 5) Testar python -c "import torch, whisper; print('ok', torch.cuda.is_available())" ffmpeg -version

# 6) Extrair áudio de vídeo ffmpeg -i input.mp4 -vn -ac 1 -ar 16000 -acodec pcm_s16le input.wav

# 7) Transcrever (Whisper CLI) whisper input.wav --model small --language pt --task transcribe --output_format txt,srt,vtt

# 8) Transcrever todos .wav da pasta for f in *.wav; do whisper "$f" --model small --language pt --output_format txt; done

# 9) Script mínimo com faster-whisper cat > transcrever.py << 'PY' from faster_whisper import WhisperModel import sys, torch, os audio = sys.argv[1] device = "cuda" if torch.cuda.is_available() else "cpu" model = WhisperModel("small", device=device, compute_type=("float16" if device=="cuda" else "int8")) segments, info = model.transcribe(audio, language="pt") base, _ = os.path.splitext(audio) with open(base + ".txt", "w", encoding="utf-8") as f: for s in segments: f.write(s.text.strip() + "\n") PY python transcrever.py input.wav

Beleza, vou resumir de forma breve o que faz cada item da lista:

Ferramentas básicas⌗

  • Python 3.10+ – linguagem em que a maioria dos sistemas de transcrição é escrita.
  • pip – gerenciador de pacotes do Python, usado para instalar bibliotecas.
  • ffmpeg – ferramenta para manipular áudio e vídeo (extrair, converter, cortar).
  • Git – sistema para baixar e versionar códigos de repositórios.
  • CUDA Toolkit – permite usar a GPU da NVIDIA para acelerar a transcrição (opcional).
  • Virtualenv / Conda – criam ambientes isolados para evitar conflito de pacotes.

Bibliotecas principais⌗

  • torch – framework de deep learning usado como base para rodar modelos.
  • torchaudio – complementa o Torch para lidar com áudio.
  • transformers – biblioteca da Hugging Face com modelos de IA, incluindo ASR.
  • datasets – para carregar e usar bancos de dados de áudio/texto em treino ou teste.
  • librosa – análise de sinais de áudio (frequência, espectrogramas, etc.).
  • openai-whisper / faster-whisper – modelos de transcrição de voz para texto.
  • soundfile – leitura e gravação de arquivos de áudio.
  • jiwer – mede a precisão da transcrição (Word Error Rate).

Ferramentas de apoio⌗

  • Editor de código (VS Code, PyCharm, etc.) – onde você vai programar e ajustar scripts.
  • Reprodutor/gravador de áudio – para testar os arquivos de entrada.

Quer que eu já organize isso em blocos de instalação (um comando pronto para você rodar no terminal)?

Aqui está a lista do que você precisa para rodar um sistema de transcrição de textos na sua máquina local (sem explicações, apenas itens):

  • Python 3.10+
  • pip
  • ffmpeg
  • Git
  • CUDA Toolkit (opcional, se for usar GPU NVIDIA)
  • Virtualenv ou Conda (para ambiente isolado)

  • Bibliotecas principais:

  • torch

  • torchaudio
  • transformers
  • datasets
  • librosa
  • openai-whisper (ou faster-whisper)
  • soundfile
  • jiwer
  • Editor de código (VS Code, PyCharm ou similar)
  • Reprodutor/gravador de áudio (para testes)

Vou organizar blocos de instalação (comandos prontos) para cada ferramenta de transcrição local.

1) Whisper (OpenAI)⌗

# Ubuntu / Linux sudo apt-get update && sudo apt-get install -y ffmpeg pip install torch torchvision torchaudio pip install openai-whisper

# Windows (PowerShell + Conda) conda create -n whisper python=3.10 -y conda activate whisper winget install -e --id Gyan.FFmpeg pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cpu pip install openai-whisper

2) Faster-Whisper⌗

pip install faster-whisper pip install ctranslate2 onnxruntime

3) Whisper.cpp⌗

```# Dependências sudo apt-get install -y build-essential cmake ffmpeg

Clonar e compilar⌗

git clone github.com/ggerganov/whisper.cpp ↗ cd whisper.cpp make```

# Baixar modelo (exemplo small) bash ./models/download-ggml-model.sh small

4) Vosk⌗

pip install vosk sudo apt-get install -y ffmpeg

# Exemplo de uso python3 - << 'PY' from vosk import Model, KaldiRecognizer import sys, os, wave model = Model("model") wf = wave.open("input.wav", "rb") rec = KaldiRecognizer(model, wf.getframerate()) while True: data = wf.readframes(4000) if len(data) == 0: break if rec.AcceptWaveform(data): print(rec.Result()) print(rec.FinalResult()) PY

5) DeepSpeech (Mozilla)⌗

pip install deepspeech==0.9.3 pip install deepspeech-gpu==0.9.3 # (opcional, se tiver GPU) sudo apt-get install -y ffmpeg

# Baixar modelo pré-treinado wget https://github.com/mozilla/DeepSpeech/releases/download/v0.9.3/deepspeech-0.9.3-models.pbmm wget https://github.com/mozilla/DeepSpeech/releases/download/v0.9.3/deepspeech-0.9.3-models.scorer

6) Kaldi⌗

```# Dependências sudo apt-get update && sudo apt-get install -y build-essential automake autoconf \ sox gfortran python3 git subversion wget

Clonar Kaldi⌗

git clone github.com/kaldi-asr/kaldi.git ↗ cd kaldi/tools make -j $(nproc) cd ../src ./configure make clean -j $(nproc) make depend -j $(nproc) make -j $(nproc)```

7) NVIDIA NeMo⌗

pip install nemo_toolkit[asr] pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121 # GPU sudo apt-get install -y ffmpeg

8) SpeechBrain⌗

pip install speechbrain pip install torch torchvision torchaudio sudo apt-get install -y ffmpeg

9) ESPnet⌗

# Dependências sudo apt-get install -y ffmpeg sox pip install torch torchvision torchaudio pip install espnet

10) Julius⌗

```sudo apt-get update && sudo apt-get install -y build-essential gcc g++ make \ libasound2-dev libpulse-dev portaudio19-dev

wget github.com ↗ tar -xvzf v4.6.tar.gz cd julius-4.6 ./configure make sudo make install```

Aqui está uma lista objetiva dos pré-requisitos para rodar cada uma das principais ferramentas de transcrição local que citei antes:

Whisper (OpenAI)⌗

  • Python 3.8+
  • pip
  • ffmpeg
  • torch (CPU ou GPU com CUDA/cuDNN)

Faster-Whisper⌗

  • Python 3.8+
  • pip
  • ffmpeg
  • torch (CPU ou GPU com CUDA/cuDNN)
  • onnxruntime / ctranslate2 (para aceleração)

Whisper.cpp⌗

  • C++17+
  • CMake
  • ffmpeg (para conversão de áudio)
  • Compilador (g++, clang++, MSVC)

Vosk⌗

  • Python 3.6+ ou Java/C++ bindings
  • pip (pacote vosk)
  • ffmpeg (opcional, para conversão de formatos)

DeepSpeech (Mozilla)⌗

  • Python 3.6–3.10
  • pip (pacote deepspeech)
  • TensorFlow 1.15 (versão compatível)
  • ffmpeg (opcional, para extrair áudio)

Kaldi⌗

  • Linux (recomendado)
  • g++/clang
  • make, automake, autoconf
  • OpenBLAS/ATLAS (para cálculos numéricos)
  • Python (opcional, para bindings)

NVIDIA NeMo⌗

  • Python 3.8–3.10
  • pip
  • PyTorch
  • CUDA/cuDNN (obrigatório para GPU)
  • ffmpeg (para manipulação de áudio)

SpeechBrain⌗

  • Python 3.8+
  • pip
  • PyTorch
  • ffmpeg

ESPnet⌗

  • Python 3.8–3.10
  • pip
  • PyTorch
  • CUDA/cuDNN (fortemente recomendado)
  • Kaldi (para alguns pipelines)
  • ffmpeg

Julius⌗

  • Linux ou Windows (via compilação)
  • C compiler (gcc/clang)
  • ALSA ou PortAudio (para entrada de áudio ao vivo)

Aqui está uma lista das principais ferramentas que você pode rodar localmente para fazer transcrição (voz → texto):

Modelos/ferramentas open-source⌗

  • OpenAI Whisper – referência atual em precisão, roda via CLI ou Python.
  • Faster-Whisper – versão otimizada do Whisper (mais rápida e leve).
  • Whisper.cpp – implementação em C++ do Whisper, roda até em máquinas sem GPU.
  • Vosk – leve, roda em tempo real até em hardware mais fraco.
  • DeepSpeech (Mozilla) – engine de reconhecimento de fala, treinável.
  • Kaldi – clássico, muito usado em pesquisa e customização.
  • Nemo (NVIDIA) – framework da NVIDIA com modelos de ASR treinados.
  • SpeechBrain – biblioteca PyTorch para ASR e NLP.
  • ESPnet – toolkit de ponta para ASR, TTS e tradução automática.
  • Julius – engine de reconhecimento de fala em tempo real (mais antiga, ainda usada em embedded).

Pacotes utilitários⌗

  • ffmpeg – para extrair/ajustar áudio.
  • Librosa / torchaudio – pré-processamento de áudio.

STT - Transcrição - Voz para Texto

chatgpt.com ↗

1

Recursos

↑ voltar ao topo · ver no Telegram ↗