Tempo RealSTT
0.3.7
Biblioteca de voz para texto fácil de usar e de baixa latência para aplicações em tempo real
O RealtimeSTT escuta o microfone e transcreve a voz em texto.
Dica: Confira o Linguflex , o projeto original do qual o RealtimeSTT foi desmembrado. Ele permite que você controle seu ambiente falando e é um dos assistentes de código aberto mais capazes e sofisticados disponíveis atualmente.
É ideal para:
Versão mais recente: v0.3.7
Veja o histórico de lançamentos.
Dica: como agora usamos o módulo
multiprocessing, certifique-se de incluir a proteçãoif __name__ == '__main__':em seu código para evitar comportamento inesperado, especialmente em plataformas como Windows. Para uma explicação detalhada sobre por que isso é importante, visite a documentação oficial do Python sobremultiprocessing.
from RealtimeSTT import AudioToTextRecorder
import pyautogui
def process_text ( text ):
print ( text )
if __name__ == '__main__' :
print ( "Wait until it says 'speak now'" )
recorder = AudioToTextRecorder ()
while True :
recorder . text ( process_text ) from RealtimeSTT import AudioToTextRecorder
import pyautogui
def process_text ( text ):
pyautogui . typewrite ( text + " " )
if __name__ == '__main__' :
print ( "Wait until it says 'speak now'" )
recorder = AudioToTextRecorder ()
while True :
recorder . text ( process_text )Digitará tudo o que está sendo dito na caixa de texto selecionada
Dica : confira RealtimeTTS, a contraparte de saída desta biblioteca, para recursos de texto para voz. Juntos, eles formam um poderoso wrapper de áudio em tempo real em torno de grandes modelos de linguagem.
Esta biblioteca usa:
Esses componentes representam o “padrão da indústria” para aplicações de ponta, fornecendo a base mais moderna e eficaz para a construção de soluções de ponta.
pip install RealtimeSTTIsso instalará todas as dependências necessárias, incluindo uma versão do PyTorch apenas com suporte de CPU .
Embora seja possível executar o RealtimeSTT apenas com uma instalação de CPU (use um modelo pequeno como "minúsculo" ou "base" neste caso), você obterá uma experiência muito melhor usando:
Para atualizar a instalação do PyTorch para habilitar o suporte de GPU com CUDA, siga estas instruções com base na sua versão específica do CUDA. Isto é útil se você deseja melhorar o desempenho do RealtimeSTT com recursos CUDA.
Para atualizar PyTorch e Torchaudio para oferecer suporte a CUDA 11.8, use os seguintes comandos:
pip install torch==2.3.1+cu118 torchaudio==2.3.1 --index-url https://download.pytorch.org/whl/cu118Para atualizar PyTorch e Torchaudio para suportar CUDA 12.X, execute o seguinte:
pip install torch==2.3.1+cu121 torchaudio==2.3.1 --index-url https://download.pytorch.org/whl/cu121 Substitua 2.3.1 pela versão do PyTorch que corresponda ao seu sistema e requisitos.
Nota : Para verificar se sua GPU NVIDIA suporta CUDA, visite a lista oficial de GPUs CUDA.
Se você não usou modelos CUDA antes, algumas etapas adicionais poderão ser necessárias uma vez antes da instalação. Estas etapas preparam o sistema para suporte CUDA e instalação otimizada para GPU . Isso é recomendado para quem precisa de melhor desempenho e possui uma GPU NVIDIA compatível. Para usar o RealtimeSTT com suporte de GPU via CUDA, siga também estas etapas:
Instale o kit de ferramentas NVIDIA CUDA :
Instale NVIDIA cuDNN :
Instale o ffmpeg :
Nota : A instalação do ffmpeg pode não ser realmente necessária para operar o RealtimeSTT *obrigado a jgilbert2017 por apontar isso
Você pode baixar um instalador para o seu sistema operacional no site do ffmpeg.
Ou use um gerenciador de pacotes:
No Ubuntu ou Debian :
sudo apt update && sudo apt install ffmpegNo Arch Linux :
sudo pacman -S ffmpegNo MacOS usando Homebrew (https://brew.sh/):
brew install ffmpegNo Windows usando a documentação oficial do Winget :
winget install Gyan.FFmpegNo Windows usando Chocolatey (https://chocolatey.org/):
choco install ffmpegNo Windows usando Scoop (https://scoop.sh/):
scoop install ffmpegUso básico:
O início e a parada da gravação são acionados manualmente.
recorder . start ()
recorder . stop ()
print ( recorder . text ()) from RealtimeSTT import AudioToTextRecorder
if __name__ == '__main__' :
recorder = AudioToTextRecorder ()
recorder . start ()
input ( "Press Enter to stop recording..." )
recorder . stop ()
print ( "Transcription: " , recorder . text ())Gravação baseada na detecção de atividade de voz.
with AudioToTextRecorder () as recorder :
print ( recorder . text ()) from RealtimeSTT import AudioToTextRecorder
if __name__ == '__main__' :
with AudioToTextRecorder () as recorder :
print ( "Transcription: " , recorder . text ())Ao executar recorder.text em loop é recomendado usar um callback, permitindo que a transcrição seja executada de forma assíncrona:
def process_text ( text ):
print ( text )
while True :
recorder . text ( process_text ) from RealtimeSTT import AudioToTextRecorder
def process_text ( text ):
print ( text )
if __name__ == '__main__' :
recorder = AudioToTextRecorder ()
while True :
recorder . text ( process_text )Ativação por palavra-chave antes de detectar voz. Escreva a lista separada por vírgulas das palavras-chave de ativação desejadas no parâmetro wake_words. Você pode escolher palavras de ativação nesta lista: alexa, americano, mirtilo, abelha, computador, toranjas, gafanhoto, ei google, ei siri, jarvis, ok google, picovoice, porco-espinho, terminador.
recorder = AudioToTextRecorder ( wake_words = "jarvis" )
print ( 'Say "Jarvis" then speak.' )
print ( recorder . text ()) from RealtimeSTT import AudioToTextRecorder
if __name__ == '__main__' :
recorder = AudioToTextRecorder ( wake_words = "jarvis" )
print ( 'Say "Jarvis" to start recording.' )
print ( recorder . text ())Você pode definir funções de retorno de chamada para serem executadas em eventos diferentes (consulte Configuração):
def my_start_callback ():
print ( "Recording started!" )
def my_stop_callback ():
print ( "Recording stopped!" )
recorder = AudioToTextRecorder ( on_recording_start = my_start_callback ,
on_recording_stop = my_stop_callback ) from RealtimeSTT import AudioToTextRecorder
def start_callback ():
print ( "Recording started!" )
def stop_callback ():
print ( "Recording stopped!" )
if __name__ == '__main__' :
recorder = AudioToTextRecorder ( on_recording_start = start_callback ,
on_recording_stop = stop_callback )Se você não quiser usar o microfone local, defina o parâmetro use_microphone como false e forneça pedaços de áudio PCM brutos em mono de 16 bits (amostragem de 16.000) com este método:
recorder . feed_audio ( audio_chunk ) from RealtimeSTT import AudioToTextRecorder
if __name__ == '__main__' :
recorder = AudioToTextRecorder ( use_microphone = False )
with open ( "audio_chunk.pcm" , "rb" ) as f :
audio_chunk = f . read ()
recorder . feed_audio ( audio_chunk )
print ( "Transcription: " , recorder . text ())Você pode desligar o gravador com segurança usando o protocolo do gerenciador de contexto:
with AudioToTextRecorder () as recorder :
[...]Ou você pode chamar o método shutdown manualmente (se usar "with" não for viável):
recorder . shutdown () from RealtimeSTT import AudioToTextRecorder
if __name__ == '__main__' :
with AudioToTextRecorder () as recorder :
[...]
# or manually shutdown if "with" is not used
recorder . shutdown ()O subdiretório test contém um conjunto de scripts para ajudá-lo a avaliar e compreender os recursos da biblioteca RealtimeTTS.
Os scripts de teste dependendo da biblioteca RealtimeTTS podem exigir que você insira sua região de serviço do Azure no script. Ao usar scripts de demonstração relacionados ao OpenAI, Azure ou Elevenlabs, as chaves de API devem ser fornecidas nas variáveis de ambiente OPENAI_API_KEY, AZURE_SPEECH_KEY e ELEVENLABS_API_KEY (consulte RealtimeTTS)
teste_simples.py
realtimestt_test.py
wakeword_test.py
tradutor.py
pip install openai realtimetts .openai_voice_interface.py
pip install openai realtimetts .advanced_talk.py
pip install openai keyboard realtimetts .minimalista_talkbot.py
pip install openai realtimetts .O subdiretório example_app contém um aplicativo de interface de usuário sofisticado para a API OpenAI baseado em PyQt5.
AudioToTextRecorder Ao inicializar a classe AudioToTextRecorder , você tem várias opções para personalizar seu comportamento.
model (str, default="tiny"): Tamanho do modelo ou caminho para transcrição.
idioma (str, default=""): Código do idioma para transcrição. Se deixado em branco, o modelo tentará detectar automaticamente o idioma. Os códigos de idioma suportados estão listados na biblioteca Whisper Tokenizer.
computar_type (str, default="default"): Especifica o tipo de cálculo a ser usado para transcrição. Veja Quantização de Sussurro
input_device_index (int, padrão = 0): Índice do dispositivo de entrada de áudio a ser usado.
gpu_device_index (int, padrão = 0): Índice de dispositivo GPU a ser usado. O modelo também pode ser carregado em múltiplas GPUs passando uma lista de IDs (por exemplo, [0, 1, 2, 3]).
device (str, default="cuda"): Dispositivo a ser usado pelo modelo. Pode ser "cuda" ou "cpu".
on_recording_start : uma função que pode ser chamada acionada quando a gravação é iniciada.
on_recording_stop : Uma função que pode ser chamada acionada quando a gravação termina.
on_transcription_start : uma função que pode ser chamada acionada quando a transcrição é iniciada.
garantir_sentence_starting_uppercase (bool, padrão=True): Garante que cada frase detectada pelo algoritmo comece com uma letra maiúscula.
garantir_sentence_ends_with_period (bool, padrão = True): Garante que cada frase que não termine com pontuação como "?", "!" termina com um período
use_microphone (bool, default=True): Uso do microfone local para transcrição. Defina como False se desejar fornecer pedaços com o método feed_audio.
spinner (bool, default=True): Fornece um texto de animação de spinner com informações sobre o estado atual do gravador.
nível (int, padrão = logging.WARNING): nível de registro.
handle_buffer_overflow (bool, padrão = True): Se definido, o sistema registrará um aviso quando ocorrer um estouro de entrada durante a gravação e removerá os dados do buffer.
beam_size (int, padrão = 5): O tamanho do feixe a ser usado para decodificação de pesquisa de feixe.
inicial_prompt (str ou iterável de int, padrão=None): prompt inicial a ser alimentado nos modelos de transcrição.
suprimir_tokens (lista de int, padrão=[-1]): Tokens a serem suprimidos da saída da transcrição.
on_recorded_chunk : uma função de retorno de chamada que é acionada quando um pedaço de áudio é gravado. Envia os dados do bloco como parâmetro.
debug_mode (bool, default=False): Se definido, o sistema imprime informações adicionais de depuração no console.
print_transcription_time (bool, padrão=False): Registra o tempo de processamento da transcrição do modelo principal. Isso pode ser útil para monitoramento e depuração de desempenho.
early_transcription_on_silence (int, padrão = 0): Se definido, o sistema transcreverá o áudio mais rapidamente quando o silêncio for detectado. A transcrição começará após os milissegundos especificados. Mantenha esse valor menor que post_speech_silence_duration , de preferência em torno de post_speech_silence_duration menos o tempo estimado de transcrição com o modelo principal. Se o silêncio durar mais que post_speech_silence_duration , a gravação será interrompida e a transcrição será enviada. Se a atividade de voz for retomada nesse período, a transcrição será descartada. Isso resulta em transcrições finais mais rápidas ao custo de carga adicional da GPU devido a algumas transcrições finais desnecessárias.
permitido_latency_limit (int, padrão=100): especifica o número máximo de pedaços não processados na fila antes de descartar pedaços. Isso ajuda a evitar que o sistema fique sobrecarregado e perca capacidade de resposta em aplicativos em tempo real.
no_log_file (bool, padrão=False): Se definido, o sistema irá ignorar a gravação do arquivo de log de depuração, reduzindo a E/S do disco. Útil se o registro em um arquivo não for necessário e o desempenho for uma prioridade.
Nota : Ao ativar a descrição em tempo real, é altamente recomendável instalar uma GPU. O uso da transcrição em tempo real pode criar altas cargas de GPU.
enable_realtime_transcription (bool, padrão=False): ativa ou desativa a transcrição de áudio em tempo real. Quando definido como True, o áudio será transcrito continuamente à medida que é gravado.
use_main_model_for_realtime (bool, default=False): Se definido como True, o modelo de transcrição principal será usado para transcrição regular e em tempo real. Se for falso, um modelo separado especificado por realtime_model_type será usado para transcrição em tempo real. Usar um único modelo pode economizar memória e potencialmente melhorar o desempenho, mas pode não ser otimizado para processamento em tempo real. O uso de modelos separados permite um modelo menor e mais rápido para transcrição em tempo real, mantendo um modelo mais preciso para a transcrição final.
realtime_model_type (str, default="tiny"): especifica o tamanho ou caminho do modelo de aprendizado de máquina a ser usado para transcrição em tempo real.
realtime_processing_pause (float, padrão = 0,2): especifica o intervalo de tempo em segundos após a transcrição de um trecho de áudio. Valores mais baixos resultarão em mais atualizações de transcrição em "tempo real" (frequentes), mas podem aumentar a carga computacional.
on_realtime_transcription_update : uma função de retorno de chamada que é acionada sempre que há uma atualização na transcrição em tempo real. A função é chamada com o texto recém-transcrito como argumento.
on_realtime_transcription_stabilized : uma função de retorno de chamada que é acionada sempre que há uma atualização na transcrição em tempo real e retorna um texto estabilizado de maior qualidade como argumento.
beam_size_realtime (int, padrão = 3): O tamanho do feixe a ser usado para decodificação de pesquisa de feixe de transcrição em tempo real.
silero_sensitivity (float, padrão=0,6): Sensibilidade para detecção de atividade de voz do Silero variando de 0 (menos sensível) a 1 (mais sensível). O padrão é 0,6.
silero_use_onnx (bool, padrão=False): permite o uso do modelo pré-treinado do Silero no formato ONNX (Open Neural Network Exchange) em vez do formato PyTorch. O padrão é falso. Recomendado para desempenho mais rápido.
silero_deactivity_detection (bool, default=False): habilita o modelo Silero para detecção de fim de fala. Mais robusto contra ruído de fundo. Utiliza recursos adicionais de GPU, mas melhora a precisão em ambientes barulhentos. Quando False, usa o WebRTC VAD padrão, que é mais sensível, mas pode continuar gravando por mais tempo devido a sons de fundo.
webrtc_sensitivity (int, padrão = 3): Sensibilidade para o mecanismo de detecção de atividade de voz WebRTC variando de 0 (menos agressivo/mais sensível) a 3 (mais agressivo, menos sensível). O padrão é 3.
post_speech_silence_duration (float, padrão = 0,2): Duração em segundos de silêncio que deve seguir a fala antes que a gravação seja considerada concluída. Isso garante que quaisquer breves pausas durante a fala não terminem prematuramente a gravação.
min_gap_between_recordings (float, padrão=1.0): Especifica o intervalo de tempo mínimo em segundos que deve existir entre o final de uma sessão de gravação e o início de outra para evitar gravações consecutivas rápidas.
min_length_of_recording (float, padrão=1.0): Especifica a duração mínima em segundos que uma sessão de gravação deve durar para garantir uma captura de áudio significativa, evitando gravações excessivamente curtas ou fragmentadas.
pre_recording_buffer_duration (float, padrão=0,2): O intervalo de tempo, em segundos, durante o qual o áudio é armazenado em buffer antes da gravação formal. Isto ajuda a contrabalançar a latência inerente à detecção de atividade de fala, garantindo que nenhum áudio inicial seja perdido.
on_vad_detect_start : uma função que pode ser chamada acionada quando o sistema começa a escutar atividade de voz.
on_vad_detect_stop : uma função que pode ser chamada acionada quando o sistema para para ouvir atividade de voz.
wakeword_backend (str, default="pvporcupine"): Especifica a biblioteca de back-end a ser usada para detecção de wake word. As opções suportadas incluem 'pvporcupine' para usar o mecanismo de wake word Porcupine ou 'oww' para usar o mecanismo OpenWakeWord.
openwakeword_model_paths (str, padrão=Nenhum): Caminhos separados por vírgula para arquivos de modelo para a biblioteca openwakeword. Esses caminhos apontam para modelos customizados que podem ser usados para detecção de wake word quando a biblioteca openwakeword é selecionada como wakeword_backend.
openwakeword_inference_framework (str, default="onnx"): Especifica a estrutura de inferência a ser usada com a biblioteca openwakeword. Pode ser 'onnx' para formato Open Neural Network Exchange ou 'tflite' para TensorFlow Lite.
wake_words (str, default=""): inicia a gravação ao usar o backend do wakeword 'pvporcupine'. Várias palavras de ativação podem ser fornecidas como uma sequência separada por vírgula. As palavras de ativação suportadas são: alexa, americano, mirtilo, abelha, computador, toranjas, gafanhoto, ei google, ei siri, jarvis, ok google, picovoice, porco-espinho, terminador. Para o backend 'openwakeword', as palavras de ativação são extraídas automaticamente dos arquivos de modelo fornecidos, portanto, não é necessário especificá-las aqui.
wake_words_sensitivity (float, padrão=0,6): Nível de sensibilidade para detecção de wake word (0 para menos sensível, 1 para mais sensível).
wake_word_activation_delay (float, padrão = 0): Duração em segundos após o início do monitoramento antes que o sistema mude para ativação de wake word se nenhuma voz for detectada inicialmente. Se definido como zero, o sistema usa a ativação da palavra de ativação imediatamente.
wake_word_timeout (float, padrão=5): Duração em segundos após uma palavra de ativação ser reconhecida. Se nenhuma atividade de voz subsequente for detectada nesta janela, o sistema retornará para um estado inativo, aguardando a próxima palavra de ativação ou ativação por voz.
wake_word_buffer_duration (float, padrão = 0,1): duração em segundos para armazenar dados de áudio em buffer durante a detecção de wake word. Isso ajuda a cortar a palavra de ativação do buffer de gravação para que ela não seja detectada falsamente junto com o texto falado a seguir, garantindo gatilhos de início de transcrição mais limpos e precisos. Aumente se partes da palavra de ativação forem detectadas como texto.
on_wakeword_detected : uma função que pode ser chamada acionada quando uma palavra de ativação é detectada.
on_wakeword_timeout : uma função que pode ser chamada acionada quando o sistema volta para um estado inativo após nenhuma fala ter sido detectada após a ativação da palavra de ativação.
on_wakeword_detection_start : uma função que pode ser chamada acionada quando o sistema começa a escutar palavras de ativação
on_wakeword_detection_end : uma função que pode ser chamada acionada ao parar para ouvir palavras de ativação (por exemplo, devido ao tempo limite ou palavra de ativação detectada)
Procure aqui informações sobre como treinar seus próprios modelos OpenWakeWord. Você pode usar um notebook simples do Google Colab para começar ou usar um notebook mais detalhado que permite mais personalização (pode produzir modelos de alta qualidade, mas requer mais experiência em desenvolvimento).
Pode ser necessário usar tf2onnx para converter modelos tensorflow tflite para o formato onnx:
pip install -U tf2onnx
python -m tf2onnx.convert --tflite my_model_filename.tflite --output my_model_filename.onnxParâmetros iniciais sugeridos para uso do OpenWakeWord:
with AudioToTextRecorder (
wakeword_backend = "oww" ,
wake_words_sensitivity = 0.35 ,
openwakeword_model_paths = "word1.onnx,word2.onnx" ,
wake_word_buffer_duration = 1 ,
) as recorder : R: Esse problema surge de uma incompatibilidade entre a versão do ctranslate2 e do cuDNN. A biblioteca ctranslate2 foi atualizada para a versão 4.5.0, que utiliza cuDNN 9.2. Existem duas maneiras de resolver esse problema:
ctranslate2 para a versão 4.4.0 : pip install ctranslate2==4.4.0Contribuições são sempre bem-vindas!
Parabéns a Steven Linn por fornecer suporte ao docker.
MIT
Kolja Beigel
E-mail: [email protected]
GitHub
