Tiempo realSTT
0.3.7
Biblioteca de conversión de voz a texto de baja latencia y fácil de usar para aplicaciones en tiempo real
RealtimeSTT escucha el micrófono y transcribe la voz en texto.
Sugerencia: consulte Linguflex , el proyecto original del que se deriva RealtimeSTT. Le permite controlar su entorno hablando y es uno de los asistentes de código abierto más capaces y sofisticados disponibles actualmente.
Es ideal para:
Última versión: v0.3.7
Ver historial de lanzamientos.
Sugerencia: dado que ahora utilizamos el módulo
multiprocessing, asegúrese de incluir la protecciónif __name__ == '__main__':en su código para evitar comportamientos inesperados, especialmente en plataformas como Windows. Para obtener una explicación detallada de por qué esto es importante, visite la documentación oficial de 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 )Escribirá todo lo que se diga en el cuadro de texto seleccionado
Sugerencia : consulte RealtimeTTS, la contraparte de salida de esta biblioteca, para conocer las capacidades de texto a voz. Juntos, forman un poderoso contenedor de audio en tiempo real alrededor de grandes modelos de lenguaje.
Esta biblioteca utiliza:
Estos componentes representan el "estándar de la industria" para aplicaciones de vanguardia y proporcionan la base más moderna y eficaz para crear soluciones de alta gama.
pip install RealtimeSTTEsto instalará todas las dependencias necesarias, incluida una versión de PyTorch que solo admite CPU .
Aunque es posible ejecutar RealtimeSTT solo con una instalación de CPU (use un modelo pequeño como "tiny" o "base" en este caso), obtendrá una experiencia mucho mejor usando:
Para actualizar su instalación de PyTorch para habilitar la compatibilidad con GPU con CUDA, siga estas instrucciones según su versión de CUDA específica. Esto es útil si desea mejorar el rendimiento de RealtimeSTT con capacidades CUDA.
Para actualizar PyTorch y Torchaudio para que sean compatibles con CUDA 11.8, utilice los siguientes comandos:
pip install torch==2.3.1+cu118 torchaudio==2.3.1 --index-url https://download.pytorch.org/whl/cu118Para actualizar PyTorch y Torchaudio para que sean compatibles con CUDA 12.X, ejecute lo siguiente:
pip install torch==2.3.1+cu121 torchaudio==2.3.1 --index-url https://download.pytorch.org/whl/cu121 Reemplace 2.3.1 con la versión de PyTorch que coincida con su sistema y sus requisitos.
Nota : Para comprobar si su GPU NVIDIA es compatible con CUDA, visite la lista oficial de GPU CUDA.
Si no usó modelos CUDA antes, es posible que necesite algunos pasos adicionales antes de la instalación. Estos pasos preparan el sistema para la compatibilidad con CUDA y la instalación de la instalación optimizada para GPU . Esto se recomienda para aquellos que requieren un mejor rendimiento y tienen una GPU NVIDIA compatible. Para utilizar RealtimeSTT con soporte de GPU a través de CUDA, siga también estos pasos:
Instale el kit de herramientas NVIDIA CUDA :
Instale NVIDIA cuDNN :
Instalar ffmpeg :
Nota : Es posible que en realidad no sea necesaria la instalación de ffmpeg para operar RealtimeSTT *gracias a jgilbert2017 por señalar esto
Puede descargar un instalador para su sistema operativo desde el sitio web de ffmpeg.
O utilice un administrador de paquetes:
En Ubuntu o Debian :
sudo apt update && sudo apt install ffmpegEn ArchLinux :
sudo pacman -S ffmpegEn MacOS usando Homebrew (https://brew.sh/):
brew install ffmpegEn Windows usando la documentación oficial de Winget :
winget install Gyan.FFmpegEn Windows usando Chocolatey (https://chocolatey.org/):
choco install ffmpegEn Windows usando Scoop (https://scoop.sh/):
scoop install ffmpegUso básico:
El inicio y la parada de la grabación se activan 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 ())Grabación basada en detección de actividad de voz.
with AudioToTextRecorder () as recorder :
print ( recorder . text ()) from RealtimeSTT import AudioToTextRecorder
if __name__ == '__main__' :
with AudioToTextRecorder () as recorder :
print ( "Transcription: " , recorder . text ())Al ejecutar recorder.text en un bucle, se recomienda utilizar una devolución de llamada, lo que permite que la transcripción se ejecute de forma asincrónica:
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 )Activación de palabras clave antes de detectar voz. Escriba la lista separada por comas de las palabras clave de activación que desee en el parámetro wake_words. Puede elegir palabras de activación de esta lista: alexa, americano, arándano, abejorro, computadora, pomelos, saltamontes, hey google, hey siri, jarvis, ok google, picovoice, puercoespín, terminator.
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 ())Puede configurar funciones de devolución de llamada para que se ejecuten en diferentes eventos (consulte Configuración):
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 )Si no desea utilizar el micrófono local, configure el parámetro use_microphone en falso y proporcione fragmentos de audio PCM sin procesar en mono de 16 bits (muestra 16000) con 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 ())Puede apagar la grabadora de forma segura utilizando el protocolo del administrador de contexto:
with AudioToTextRecorder () as recorder :
[...]O puede llamar al método de apagado manualmente (si usar "con" no es factible):
recorder . shutdown () from RealtimeSTT import AudioToTextRecorder
if __name__ == '__main__' :
with AudioToTextRecorder () as recorder :
[...]
# or manually shutdown if "with" is not used
recorder . shutdown ()El subdirectorio de prueba contiene un conjunto de scripts para ayudarlo a evaluar y comprender las capacidades de la biblioteca RealtimeTTS.
Los scripts de prueba que dependen de la biblioteca RealtimeTTS pueden requerir que ingrese su región de servicio Azure dentro del script. Cuando se utilizan scripts de demostración relacionados con OpenAI, Azure o Elevenlabs, las claves API deben proporcionarse en las variables de entorno OPENAI_API_KEY, AZURE_SPEECH_KEY y ELEVENLABS_API_KEY (consulte RealtimeTTS).
prueba_simple.py
realtimestt_test.py
wakeword_test.py
traductor.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 .El subdirectorio example_app contiene una aplicación de interfaz de usuario pulida para la API OpenAI basada en PyQt5.
AudioToTextRecorder Cuando inicializas la clase AudioToTextRecorder , tienes varias opciones para personalizar su comportamiento.
model (str, default="tiny"): Tamaño del modelo o ruta para la transcripción.
idioma (str, default=""): código de idioma para la transcripción. Si se deja vacío, el modelo intentará detectar automáticamente el idioma. Los códigos de idioma admitidos se enumeran en la biblioteca de Whisper Tokenizer.
Compute_type (str, default="default"): especifica el tipo de cálculo que se utilizará para la transcripción. Ver Cuantización de susurros
input_device_index (int, predeterminado = 0): índice del dispositivo de entrada de audio que se utilizará.
gpu_device_index (int, predeterminado = 0): índice de dispositivo GPU a utilizar. El modelo también se puede cargar en varias GPU pasando una lista de ID (por ejemplo, [0, 1, 2, 3]).
dispositivo (str, default="cuda"): Dispositivo que el modelo utilizará. Puede ser "cuda" o "cpu".
on_recording_start : una función invocable que se activa cuando comienza la grabación.
on_recording_stop : una función invocable que se activa cuando finaliza la grabación.
on_transcription_start : una función invocable que se activa cuando comienza la transcripción.
sure_sentence_starting_uppercase (bool, default=True): garantiza que cada oración detectada por el algoritmo comience con una letra mayúscula.
sure_sentence_ends_with_period (bool, default=True): garantiza que cada oración que no termine con signos de puntuación como "?", "!" termina con un punto
use_microphone (bool, predeterminado=True): uso del micrófono local para la transcripción. Configúrelo en False si desea proporcionar fragmentos con el método feed_audio.
spinner (bool, predeterminado=True): proporciona un texto de animación giratoria con información sobre el estado actual de la grabadora.
nivel (int, default=logging.WARNING): nivel de registro.
handle_buffer_overflow (bool, predeterminado=True): si se establece, el sistema registrará una advertencia cuando se produzca un desbordamiento de entrada durante la grabación y eliminará los datos del búfer.
beam_size (int, predeterminado = 5): el tamaño del haz que se utilizará para la decodificación de búsqueda de haces.
inicial_prompt (cadena o iterable de int, predeterminado = Ninguno): mensaje inicial que se enviará a los modelos de transcripción.
suprimir_tokens (lista de int, predeterminado = [-1]): tokens que se suprimirán de la salida de la transcripción.
on_recorded_chunk : una función de devolución de llamada que se activa cuando se graba un fragmento de audio. Envía los datos del fragmento como parámetro.
debug_mode (bool, predeterminado = Falso): si se establece, el sistema imprime información de depuración adicional en la consola.
print_transcription_time (bool, default=False): registra el tiempo de procesamiento de la transcripción del modelo principal. Esto puede resultar útil para la supervisión y depuración del rendimiento.
early_transcription_on_silence (int, default=0): si se configura, el sistema transcribirá el audio más rápido cuando se detecte silencio. La transcripción comenzará después de los milisegundos especificados. Mantenga este valor por debajo de post_speech_silence_duration , idealmente alrededor de post_speech_silence_duration menos el tiempo de transcripción estimado con el modelo principal. Si el silencio dura más que post_speech_silence_duration , la grabación se detiene y se envía la transcripción. Si la actividad de voz se reanuda dentro de este período, la transcripción se descarta. Esto da como resultado transcripciones finales más rápidas a costa de una carga adicional de GPU debido a algunas transcripciones finales innecesarias.
permitido_latency_limit (int, predeterminado = 100): especifica el número máximo de fragmentos sin procesar en la cola antes de descartarlos. Esto ayuda a evitar que el sistema se sobrecargue y pierda capacidad de respuesta en aplicaciones en tiempo real.
no_log_file (bool, predeterminado=False): si se establece, el sistema omitirá la escritura del archivo de registro de depuración, lo que reducirá la E/S del disco. Útil si no es necesario iniciar sesión en un archivo y el rendimiento es una prioridad.
Nota : Al habilitar la descripción en tiempo real, se recomienda encarecidamente la instalación de una GPU. El uso de la transcripción en tiempo real puede generar cargas elevadas en la GPU.
enable_realtime_transcription (bool, default=False): habilita o deshabilita la transcripción de audio en tiempo real. Cuando se establece en Verdadero, el audio se transcribirá continuamente mientras se graba.
use_main_model_for_realtime (bool, default=False): si se establece en True, el modelo de transcripción principal se utilizará para la transcripción regular y en tiempo real. Si es False, se utilizará un modelo separado especificado por realtime_model_type para la transcripción en tiempo real. El uso de un solo modelo puede ahorrar memoria y potencialmente mejorar el rendimiento, pero es posible que no esté optimizado para el procesamiento en tiempo real. El uso de modelos separados permite crear un modelo más pequeño y más rápido para la transcripción en tiempo real y, al mismo tiempo, mantener un modelo más preciso para la transcripción final.
realtime_model_type (str, default="tiny"): especifica el tamaño o la ruta del modelo de aprendizaje automático que se utilizará para la transcripción en tiempo real.
realtime_processing_pause (flotante, predeterminado = 0,2): especifica el intervalo de tiempo en segundos después de que se transcribe un fragmento de audio. Los valores más bajos darán como resultado más actualizaciones de transcripción "en tiempo real" (frecuentes), pero pueden aumentar la carga computacional.
on_realtime_transcription_update : una función de devolución de llamada que se activa cada vez que hay una actualización en la transcripción en tiempo real. La función se llama con el texto recién transcrito como argumento.
on_realtime_transcription_stabilized : una función de devolución de llamada que se activa cada vez que hay una actualización en la transcripción en tiempo real y devuelve un texto estabilizado de mayor calidad como argumento.
beam_size_realtime (int, predeterminado = 3): el tamaño del haz que se utilizará para la decodificación de búsqueda del haz de transcripción en tiempo real.
silero_sensitivity (flotante, predeterminado=0.6): Sensibilidad para la detección de actividad de voz de Silero que varía de 0 (menos sensible) a 1 (más sensible). El valor predeterminado es 0,6.
silero_use_onnx (bool, default=False): habilita el uso del modelo previamente entrenado de Silero en el formato ONNX (Open Neural Network Exchange) en lugar del formato PyTorch. El valor predeterminado es Falso. Recomendado para un rendimiento más rápido.
silero_deactivity_detection (bool, default=False): habilita el modelo Silero para la detección de final de discurso. Más robusto frente al ruido de fondo. Utiliza recursos de GPU adicionales pero mejora la precisión en entornos ruidosos. Cuando es False, utiliza el VAD WebRTC predeterminado, que es más sensible pero puede continuar grabando por más tiempo debido a los sonidos de fondo.
webrtc_sensitivity (int, predeterminado=3): sensibilidad para el motor de detección de actividad de voz WebRTC que va de 0 (menos agresivo/más sensible) a 3 (más agresivo, menos sensible). El valor predeterminado es 3.
post_speech_silence_duration (flotante, predeterminado = 0,2): duración en segundos del silencio que debe seguir al discurso antes de que se considere completa la grabación. Esto garantiza que cualquier breve pausa durante el discurso no finalice prematuramente la grabación.
min_gap_between_recordings (float, default=1.0): especifica el intervalo de tiempo mínimo en segundos que debe existir entre el final de una sesión de grabación y el comienzo de otra para evitar grabaciones consecutivas rápidas.
min_length_of_recording (float, default=1.0): especifica la duración mínima en segundos que debe durar una sesión de grabación para garantizar una captura de audio significativa, evitando grabaciones excesivamente cortas o fragmentadas.
pre_recording_buffer_duration (flotante, predeterminado = 0,2): el lapso de tiempo, en segundos, durante el cual el audio se almacena en el búfer antes de la grabación formal. Esto ayuda a contrarrestar la latencia inherente a la detección de la actividad del habla, garantizando que no se pierda ningún audio inicial.
on_vad_detect_start : una función invocable que se activa cuando el sistema comienza a escuchar la actividad de voz.
on_vad_detect_stop : una función invocable que se activa cuando el sistema se detiene para escuchar la actividad de voz.
wakeword_backend (str, default="pvporcupine"): especifica la biblioteca de backend que se utilizará para la detección de palabras de activación. Las opciones admitidas incluyen 'pvporcupine' para usar el motor de palabras de activación Porcupine o 'oww' para usar el motor OpenWakeWord.
openwakeword_model_paths (cadena, predeterminado = Ninguno): rutas separadas por comas a archivos de modelo para la biblioteca openwakeword. Estas rutas apuntan a modelos personalizados que se pueden usar para la detección de palabras de activación cuando se selecciona la biblioteca openwakeword como wakeword_backend.
openwakeword_inference_framework (str, default="onnx"): especifica el marco de inferencia que se utilizará con la biblioteca openwakeword. Puede ser 'onnx' para el formato Open Neural Network Exchange o 'tflite' para TensorFlow Lite.
wake_words (str, default=""): inicia la grabación cuando se utiliza el backend de wakeword 'pvporcupine'. Se pueden proporcionar varias palabras de activación como una cadena separada por comas. Las palabras de activación admitidas son: alexa, americano, arándano, abejorro, computadora, pomelos, saltamontes, hey google, hey siri, jarvis, ok google, picovoice, puercoespín, terminator. Para el backend 'openwakeword', las palabras de activación se extraen automáticamente de los archivos de modelo proporcionados, por lo que no es necesario especificarlas aquí.
wake_words_sensitivity (flotante, predeterminado = 0,6): nivel de sensibilidad para la detección de palabras de activación (0 para el menos sensible, 1 para el más sensible).
wake_word_activation_delay (flotante, predeterminado = 0): duración en segundos después del inicio del monitoreo antes de que el sistema cambie a la activación de la palabra de activación si inicialmente no se detecta ninguna voz. Si se establece en cero, el sistema utiliza la activación de la palabra de activación inmediatamente.
wake_word_timeout (flotante, predeterminado = 5): duración en segundos después de que se reconoce una palabra de activación. Si no se detecta actividad de voz posterior dentro de esta ventana, el sistema vuelve a un estado inactivo, esperando la siguiente palabra de activación o activación de voz.
wake_word_buffer_duration (flotante, predeterminado = 0,1): duración en segundos para almacenar en el buffer los datos de audio durante la detección de la palabra de activación. Esto ayuda a eliminar la palabra de activación del búfer de grabación para que no se detecte falsamente junto con el siguiente texto hablado, lo que garantiza activadores de inicio de transcripción más limpios y precisos. Aumente esto si partes de la palabra de activación se detectan como texto.
on_wakeword_detected : una función invocable que se activa cuando se detecta una palabra de activación.
on_wakeword_timeout : una función invocable que se activa cuando el sistema vuelve a un estado inactivo después de que no se detectó voz después de la activación de la palabra de activación.
on_wakeword_detection_start : una función invocable que se activa cuando el sistema comienza a escuchar las palabras de activación.
on_wakeword_detection_end : una función invocable que se activa cuando se detiene para escuchar las palabras de activación (por ejemplo, debido a un tiempo de espera o a una palabra de activación detectada).
Busque aquí para obtener información sobre cómo entrenar sus propios modelos OpenWakeWord. Puede utilizar un cuaderno simple de Google Colab para empezar o utilizar un cuaderno más detallado que permita una mayor personalización (puede producir modelos de alta calidad, pero requiere más experiencia en desarrollo).
Es posible que necesites usar tf2onnx para convertir los modelos tflite de tensorflow al formato onnx:
pip install -U tf2onnx
python -m tf2onnx.convert --tflite my_model_filename.tflite --output my_model_filename.onnxParámetros iniciales sugeridos para el uso de 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: Este problema surge de una falta de coincidencia entre la versión de ctranslate2 y cuDNN. La biblioteca ctranslate2 se actualizó a la versión 4.5.0, que usa cuDNN 9.2. Hay dos formas de resolver este problema:
ctranslate2 a la versión 4.4.0 : pip install ctranslate2==4.4.0¡Las contribuciones siempre son bienvenidas!
Un agradecimiento a Steven Linn por brindar soporte para Docker.
MIT
Kolja Beigel
Correo electrónico: [email protected]
GitHub
