WhisperLive

Susurros

Una implementación casi viva del susurro de Openai.

Este proyecto es una aplicación de transcripción en tiempo real que utiliza el modelo OperaI Whisper para convertir la entrada del habla en la salida de texto. Se puede usar para transcribir la entrada de audio en vivo de los archivos de audio de micrófono y pregrabado.

Instalación

• Instale Pyaudio y FFMPEG

 bash scripts/setup.sh

• Instalar Whisper-Live desde Pip

 pip install whisper-live

Configuración de Nvidia/Tensorrt-LLM para Tensorrt Backend

• Siga el readme tensorrt_whisper para la configuración de nvidia/tensorrt-llm y para construir un motor susurro.

Empezando

El servidor admite dos backends faster_whisper y tensorrt . Si se ejecuta tensorrt Backend, siga tensorrt_whisper Readme

Ejecutando el servidor

• Backend de susurro más rápido

python3 run_server.py --port 9090 
                      --backend faster_whisper
  
# running with custom model
python3 run_server.py --port 9090 
                      --backend faster_whisper 
                      -fw " /path/to/custom/faster/whisper/model "

• Backend tensor. Actualmente, recomendamos solo usar la configuración de Docker para Tensorrt. Siga el readme tensorrt_whisper que funciona como se esperaba. Asegúrese de construir sus motores Tensorrt antes de ejecutar el servidor con Tensorrt Backend.

 # Run English only model
python3 run_server.py -p 9090 
                      -b tensorrt 
                      -trt /home/TensorRT-LLM/examples/whisper/whisper_small_en

# Run Multilingual model
python3 run_server.py -p 9090 
                      -b tensorrt 
                      -trt /home/TensorRT-LLM/examples/whisper/whisper_small 
                      -m

Control de hilos OpenMP

Para controlar el número de subprocesos utilizados por OpenMP, puede establecer la variable de entorno OMP_NUM_THREADS . Esto es útil para administrar los recursos de la CPU y garantizar un rendimiento constante. Si no se especifica, OMP_NUM_THREADS se establece en 1 por defecto. Puede cambiar esto usando el argumento --omp_num_threads :

python3 run_server.py --port 9090 
                      --backend faster_whisper 
                      --omp_num_threads 4

Modo de modelo único

De manera predeterminada, al ejecutar el servidor sin especificar un modelo, el servidor instanciará un nuevo modelo Whisper para cada conexión de cliente. Esto tiene la ventaja de que el servidor puede usar diferentes tamaños de modelo, según el tamaño del modelo solicitado del cliente. Por otro lado, también significa que debe esperar a que el modelo se cargue en la conexión del cliente y tendrá un uso (v) RAM.

Al servir un modelo Tensorrt personalizado utilizando el -trt o un modelo personalizado más rápido_whisper usando la opción -fw , el servidor solo instanciará el modelo personalizado una vez y luego lo reutilizará para todas las conexiones del cliente.

Si no quieres esto, establezca --no_single_model .

Ejecutando el cliente

• Inicialización del cliente con los siguientes parámetros:
  • lang : lenguaje del audio de entrada, aplicable solo si usa un modelo multilingüe.
  • translate : si se establece en True , traduzca de cualquier idioma a en .
  • model : tamaño del modelo de susurro.
  • use_vad : si se debe usar Voice Activity Detection en el servidor.
  • save_output_recording : Establecer en True para guardar la entrada de micrófono como un archivo .wav durante la transcripción en vivo. Esta opción es útil para grabar sesiones para reproducción o análisis posteriores. El valor predeterminado es False .
  • output_recording_filename : Especifica la ruta del archivo .wav donde se guardará la entrada del micrófono si save_output_recording se establece en True .
  • max_clients : especifica el número máximo de clientes que debe permitir el servidor. Predeterminado a 4.
  • max_connection_time : tiempo de conexión máximo para cada cliente en segundos. El valor predeterminado a 600.

 from whisper_live . client import TranscriptionClient
client = TranscriptionClient (
  "localhost" ,
  9090 ,
  lang = "en" ,
  translate = False ,
  model = "small" ,                                      # also support hf_model => `Systran/faster-whisper-small`
  use_vad = False ,
  save_output_recording = True ,                         # Only used for microphone input, False by Default
  output_recording_filename = "./output_recording.wav" , # Only used for microphone input
  max_clients = 4 ,
  max_connection_time = 600
)

Se conecta al servidor que se ejecuta en Localhost en el puerto 9090. Usando un modelo multilingüe, el lenguaje para la transcripción se detectará automáticamente. También puede usar la opción de idioma para especificar el idioma de destino para la transcripción, en este caso, inglés ("EN"). La opción Traducir debe establecerse en True si queremos traducir del idioma de origen al inglés y False si queremos transcribir en el idioma de origen.

• Transcribir un archivo de audio:

 client ( "tests/jfk.wav" )

• Para transcribir del micrófono:

 client ()

• Para transcribir desde una transmisión RTSP:

 client ( rtsp_url = "rtsp://admin:[email protected]/rtsp" )

• Para transcribir desde una transmisión HLS:

 client ( hls_url = "http://as-hls-ww-live.akamaized.net/pool_904/live/ww/bbc_1xtra/bbc_1xtra.isml/bbc_1xtra-audio%3d96000.norewind.m3u8" )

Extensiones del navegador

• Ejecute el servidor con el backend deseado como se muestra aquí.
• Transcribe el audio directamente desde su navegador utilizando nuestras extensiones Chrome o Firefox. Consulte Audio-Transcription-Chrome y Audio-Transcription-FireFox para obtener instrucciones de configuración.

Whisper Live Server en Docker

• GPU

  • Más rápido

  docker run -it --gpus all -p 9090:9090 ghcr.io/collabora/whisperlive-gpu:latest

  • Tensorrt.

  docker run -p 9090:9090 --runtime=nvidia --gpus all --entrypoint /bin/bash -it ghcr.io/collabora/whisperlive-tensorrt
  
  # Build small.en engine
  bash build_whisper_tensorrt.sh /app/TensorRT-LLM-examples small.en
  
  # Run server with small.en
  python3 run_server.py --port 9090 
                        --backend tensorrt 
                        --trt_model_path " /app/TensorRT-LLM-examples/whisper/whisper_small_en "

• UPC

docker run -it -p 9090:9090 ghcr.io/collabora/whisperlive-cpu:latest

Nota : Por defecto, usamos el tamaño del modelo "pequeño". Para construir una imagen Docker para un tamaño de modelo diferente, cambie el tamaño en server.py y luego cree la imagen de Docker.

Trabajo futuro

• Agregue la traducción a otros idiomas además de la transcripción.
• Tensorrt Backend para Whisper.

Contacto

Estamos disponibles para ayudarlo tanto con los proyectos de AI y de código abierto. Puede comunicarse con nosotros a través del sitio web de Collabora o [email protected] y [email protected].

Citas

 @article { Whisper
  title = { Robust Speech Recognition via Large-Scale Weak Supervision } ,
  url = { https://arxiv.org/abs/2212.04356 } ,
  author = { Radford, Alec and Kim, Jong Wook and Xu, Tao and Brockman, Greg and McLeavey, Christine and Sutskever, Ilya } ,
  publisher = { arXiv } ,
  year = { 2022 } ,
}

 @misc { Silero VAD,
  author = { Silero Team } ,
  title = { Silero VAD: pre-trained enterprise-grade Voice Activity Detector (VAD), Number Detector and Language Classifier } ,
  year = { 2021 } ,
  publisher = { GitHub } ,
  journal = { GitHub repository } ,
  howpublished = { url{https://github.com/snakers4/silero-vad} } ,
  email = { hello @ silero.ai }
}