WhisperLive

Sussurro

Uma implementação quase ao vivo do sussurro de Openai.

Este projeto é um aplicativo de transcrição em tempo real que usa o modelo Whisper OpenAI para converter a entrada de fala em saída de texto. Ele pode ser usado para transcrever a entrada de áudio ao vivo a partir do microfone e arquivos de áudio pré-gravados.

Instalação

• Instale Pyaudio e FFMPEG

 bash scripts/setup.sh

• Instale o Whisper-Live de Pip

 pip install whisper-live

Configurando NVIDIA/TENSORRT-LLM para o back-end Tensorrt

• Siga tensorrt_whisper ReadMe para a configuração do NVIDIA/TENSORRT-LLM e para a construção do mecanismo Whisper-Tensorrt.

Começando

O servidor suporta dois backends faster_whisper e tensorrt . Se executar o back -end tensorrt , siga o tensorrt_whisper readme

Executando o servidor

• Back -end mais rápido do sussurro

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 "

• Back -end tensorrt. Atualmente, recomendamos usar apenas a configuração do Docker para Tensorrt. Siga Tensorrt_whisper ReadMe, que funciona conforme o esperado. Certifique -se de criar seus motores Tensorrt antes de executar o servidor com back -end Tensorrt.

 # 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

Controlando os threads OpenMP

Para controlar o número de threads usados ​​pelo OpenMP, você pode definir a variável de ambiente OMP_NUM_THREADS . Isso é útil para gerenciar os recursos da CPU e garantir um desempenho consistente. Se não for especificado, OMP_NUM_THREADS está definido como 1 por padrão. Você pode mudar isso usando o argumento --omp_num_threads :

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

Modo de modelo único

Por padrão, ao executar o servidor sem especificar um modelo, o servidor instanciará um novo modelo de sussurro para cada conexão do cliente. Isso tem a vantagem de que o servidor pode usar tamanhos de modelo diferentes, com base no tamanho do modelo solicitado pelo cliente. Por outro lado, isso também significa que você deve esperar que o modelo seja carregado na conexão do cliente e você aumentará (v) o uso da RAM.

Ao servir um modelo Tensorrt personalizado usando o -trt ou um modelo personalizado mais rápido, usando a opção -fw , o servidor apenas instanciará o modelo personalizado uma vez e reutiliza -o para todas as conexões do cliente.

Se você não quiser isso, defina --no_single_model .

Executando o cliente

• Inicializando o cliente com parâmetros abaixo:
  • lang : Linguagem do áudio de entrada, aplicável apenas se estiver usando um modelo multilíngue.
  • translate : se definido como True , traduza de qualquer idioma para en .
  • model : Tamanho do modelo sussurro.
  • use_vad : se deve usar Voice Activity Detection no servidor.
  • save_output_recording : defina como true para salvar a entrada do microfone como um arquivo .wav durante a transcrição ao vivo. Esta opção é útil para sessões de gravação para reprodução ou análise posterior. Padrões para False .
  • output_recording_filename : Especifica o caminho do arquivo .wav , onde a entrada do microfone será salva se save_output_recording for definido como True .
  • max_clients : Especifica o número máximo de clientes que o servidor deve permitir. Padrões para 4.
  • max_connection_time : tempo máximo de conexão para cada cliente em segundos. Padrões para 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
)

Ele se conecta ao servidor em execução no localHost na porta 9090. Usando um modelo multilíngue, o idioma para a transcrição será detectado automaticamente. Você também pode usar a opção de idioma para especificar o idioma de destino para a transcrição, neste caso, o inglês ("EN"). A opção TRANKSTE deve ser definida como True se quisermos traduzir do idioma de origem para o inglês e False se quisermos transcrever no idioma de origem.

• Transcrever um arquivo de áudio:

 client ( "tests/jfk.wav" )

• Para transcrever do microfone:

 client ()

• Para transcrever a partir de um fluxo RTSP:

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

• Para transcrever a partir de um fluxo 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" )

Extensões do navegador

• Execute o servidor com o back -end desejado, como mostrado aqui.
• Transcreva o áudio diretamente do seu navegador usando nossas extensões Chrome ou Firefox. Consulte o Audio-Transcription-Chrome e o Audio-Transcription-FIROFOX para obter instruções de configuração.

Servidor Live Whisper no Docker

• GPU

  • Mais 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 "

• CPU

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

Nota : Por padrão, usamos o tamanho do modelo "pequeno". Para criar a imagem do Docker para um tamanho de modelo diferente, altere o tamanho no servidor.py e depois crie a imagem do Docker.

Trabalho futuro

• Adicione a tradução a outros idiomas em cima da transcrição.
• Back -end Tensorrt para Whisper.

Contato

Estamos disponíveis para ajudá -lo com projetos de IA de código aberto e proprietários. Você pode entrar em contato conosco no site da Collabora ou [email protected] e [email protected].

Citações

 @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 }
}