Insanely Fast Whisper: proyecto de código abierto para la transcripción rápida y eficaz de voz a texto

Últimos recursos sobre IAActualizado hace 7 meses Círculo de intercambio de inteligencia artificial

2.2K 00

Introducción general

insanely-fast-whisper es una herramienta de transcripción de audio que combina el modelo Whisper de OpenAI con varias técnicas de optimización (por ejemplo, Transformers, Optimum, Flash Attention) para proporcionar una interfaz de línea de comandos (CLI) diseñada para transcribir grandes cantidades de audio de forma rápida y eficiente. Utiliza el modelo Whisper Large v3 y es capaz de transcribir 150 minutos de contenido de audio en menos de 98 segundos. Los usuarios pueden conocer más detalles, guías de instalación y ayuda de uso a través del repositorio de GitHub.

reconocimiento de varios altavoces
pyannote.audio es un conjunto de herramientas de código abierto para la diarización de hablantes escrito en Python. Basado en el marco de aprendizaje automático PyTorch, cuenta con modelos preentrenados de última generación y canalizaciones para afinar aún más sus propios datos para un mejor rendimiento.
faster-whisper + pyannote.audio implementa el reconocimiento de locutor, de hecho, simplemente combinando los resultados de los dos
Almacén oficial: https://github.com/pyannote/pyannote-audio

Lista de funciones

Transcripción de audio con el modelo Whisper Large v3
Adopción de Transformers, Optimum, Flash Attention y otras tecnologías
Proporciona una interfaz CLI
Admite distintos tipos de optimización y muestra valores de referencia

Utilizar la ayuda

Instalación: Instalación y configuración con pip
Uso: Pase parámetros y ejecute tareas de transcripción directamente desde la línea de comandos
Obtén ayuda: Visita el repositorio de GitHub para leer la documentación y hablar con la comunidad.

https://github.com/SYSTRAN/faster-whisper项目编写的código google colab

# Instalación de las bibliotecas necesarias
get_ipython().system('pip install faster-whisper')
# Importar las bibliotecas necesarias
from faster_whisper import modelos_disponibles
antorcha de importación
importar ipywidgets como widgets
from IPython.display import display, clear_output
import os # Importar librerías del sistema operativo para el manejo de operaciones con ficheros
import gc # import biblioteca de recogida de basuras
# Detecta automáticamente el tipo de dispositivo y selecciona GPU o CPU.
device = "cuda" if torch.cuda.is_available() else "cpu"
model_size = "large-v2" # Selección por defecto del tamaño del modelo
compute_type = "float16" if device == "cuda" else "float32" # Cambiar a float32 si se usa CPU
# Obtener una lista de modelos disponibles
models_list = modelos_disponibles()
# Lista de idiomas por defecto
supported_languages = ['en', 'fr', 'de', 'zh', '...'] # utiliza la lista de idiomas por defecto
default_language = 'zh' if 'zh' in supported_languages else supported_languages[0] # Si 'zh' está en la lista, utilícelo por defecto; en caso contrario, utilice el primer valor de la lista.

# Creación de una interfaz GUI
model_label = widgets.Label('Seleccionar modelo:')
model_dropdown = widgets.Dropdown(options=lista_modelos, value=tamaño_modelo)
language_label = widgets.Label('Idioma:')
language_dropdown = widgets.Dropdown(options=idiomas_soportados, value=idioma_por_defecto)
beam_size_label = widgets.Label('Tamaño del haz:')
beam_size_slider = widgets.IntSlider(value=5, min=1, max=10, step=1)
compute_type_label = widgets.Label('Tipo de cálculo:')
si dispositivo == "cuda".
compute_type_options = ['float16', 'int8']
si no.
compute_type_options = ['float32'] # Si CPU, bloquear a float32
compute_type_dropdown = widgets.Dropdown(options=opciones_tipo_computadora, value=tipo_computadora)
mode_label = widgets.Label('Modo de formato:')
mode_dropdown = widgets.Dropdown(options=['normal', 'timeline', 'subtitle'], value='normal')
initial_prompt_label = widgets.Label('Mensaje inicial:') # Nueva etiqueta de mensaje inicial añadida
initial_prompt_text = widgets.Text(value='') # Cuadro de entrada inicial añadido
nombre_archivo_text = widgets.Text(description='Nombre_archivo:', value='/contenido/') # Permitir al usuario introducir el nombre del archivo
transcribe_button = widgets.Button(description='Transcribir')
área_de_salida = widgets.Salida()

# Definición de la función de traducción
def transcribir_audio(b).
con área_de_salida.
clear_output()
print("Iniciando transcripción...")
from faster_whisper import WhisperModel # Importación dinámica de WhisperModel: importar cuando sea necesario para ahorrar RAM
Inténtalo.
nombre_archivo = nombre_archivo_texto.valor # Utilizar el nombre de archivo introducido por el usuario
initial_prompt = initial_prompt_text.value # Pregunta inicial utilizando la entrada del usuario
# Garantizar la existencia del documento
if not os.path.exists(nombre_archivo):: if not os.path.exists(nombre_archivo).
print(f "El archivo {nombre_archivo} no existe, por favor compruebe que el nombre y la ruta del archivo son correctos.")
devolver
# Adquisición de modelos seleccionados
modelo_seleccionado = valor_desplegable_modelo
tipo_computación_seleccionado = valor_desplegable_tipo_computación
idioma_seleccionado = idioma_desplegable.valor
# Crea una nueva instancia del modelo y realiza la traducción
model = WhisperModel(selected_model, device=dispositivo, compute_type=tipo_de_computación_seleccionado)
Inténtalo.
# Audio traducido
segments, info = model.transcribe(file_name, beam_size=valor_beam_size_slider.value, language=idioma_seleccionado, initial_prompt=prompta_inicial ) Parámetros del aviso inicial añadidos a #
# Resultados de impresión
print("Detectado idioma '%s' con probabilidad %f" % (info.idioma, info.idioma_probabilidad))
para segmento en segmentos:
si mode_dropdown.value == 'normal'.
print("%s " % (segmento.texto))
elif mode_dropdown.value == 'timeline'.
print("[%.2fs -> %.2fs] %s" % (segmento.inicio, segmento.fin, segmento.texto))
si no: subtítulo #
start_time = "{:02d}:{:02d}:{:02d},{:03d}".format(int(segmento.inicio // 3600), int((segmento.inicio % 3600) // 60), int(segmento.inicio % 60), int((segmento.inicio % 1) * 1000))
end_time = "{:02d}:{:02d}:{:02d},{:03d}".format(int(segmento.end // 3600), int((segmento.end % 3600) // 60), int(segmento.end % 60), int((segmento. segmento.end % 1) * 1000))
print("%d\n%s --> %s\n%s\n" % (segment.id, start_time, end_time, segment.text))
finalmente.
# Borrar instancia de modelo para liberar RAM
del modelo
excepto Excepción como e.
print("Se ha producido un error durante la transcripción:")
print(str(e))
finalmente.
# Llamada a la recogida de basura
gc.collect()
print("Transcripción completa.")

Interfaz GUI del conjunto #
display(model_label, model_dropdown, language_label, language_dropdown, beam_size_label, beam_size_slider, compute_type_label, compute_ type_dropdown, mode_label, mode_dropdown, initial_prompt_label, initial_prompt_text, file_name_text, transcribe_button, output_area)
transcribe_button.on_click(transcribe_audio)

Ejemplo de reconocimiento del código multihablante

from pyannote.core import Segmento
def get_text_with_timestamp(transcribe_res).
timestamp_texts = []for item in transcribe_res.
inicio = item.inicio
end = item.end
text = item.text.strip()
timestamp_texts.append((Segmento(inicio, fin), texto))
return timestamp_texts
def add_speaker_info_to_text(timestamp_texts, ann)::
spk_text = []for seg, text in timestamp_texts:
spk = ann.crop(seg).argmax()
spk_text.append((seg, spk, text))
return spk_text
def fusion_cache(text_cache).
sentence = ''.join([item[-1] for item in text_cache])
spk = text_cache[0][1]start = round(text_cache[0][0].start, 1)
end = round(text_cache[-1][0].end, 1)
return Segmento(inicio, fin), spk, frase
PUNC_SENT_END = [',', '.' , '? , '!' , ",", "." , "?" , "!"]
def fusionar_sentencia(texto_esp).
merged_spk_text = []pre_spk = None
text_cache = []for seg, spk, text in spk_text:
¡si spk ! = pre_spk y pre_spk no es None y len(text_cache) > 0:.
merged_spk_text.append(merge_cache(text_cache))
text_cache = [(seg, spk, text)]pre_spk = spk
elif texto y len(texto) > 0 y texto[-1] en PUNC_SENT_END:
text_cache.append((seg, spk, text))
merged_spk_text.append(merge_cache(text_cache))
text_cache = []pre_spk = spk
si no.
text_cache.append((seg, spk, text))
pre_spk = spk
si len(text_cache) > 0.
merged_spk_text.append(merge_cache(text_cache))
return texto_spk_fusionado
def diarizar_texto(transcribir_res, diarizar_resultado)::
timestamp_texts = get_text_with_timestamp(transcribe_res)
spk_text = add_speaker_info_to_text(timestamp_texts, diarisation_result)
res_processed = fusionar_sentencia(spk_texto)
return res_processed
def write_to_txt(spk_sent, file).
con open(file, 'w') como fp.
para seg, spk, frase en spk_sent.
line = f'{seg.inicio:.2f} {seg.fin:.2f} {spk} {sentencia}\n'
fp.write(línea)

antorcha de importación
importar susurro
importar numpy como np
from pydub import AudioSegment
from loguru import logger
from faster_whisper import WhisperModel
from pyannote.audio import Pipeline
from pyannote.audio import Audio
from common.error.import ErrorCode
model_path = config["asr"]["faster-whisper-large-v3"]
# Audio de prueba: https://isv-data.oss-cn-hangzhou.aliyuncs.com/ics/MaaS/ASR/test_audio/asr_speaker_demo.wav
audio = ". /test/asr/data/asr_speaker_demo.wav"
asr_model = WhisperModel(model_path, device="cuda", compute_type="float16")
spk_rec_pipeline = Pipeline.from_pretrained("pyannote/speaker-diarisation-3.1", use_auth_token="su cara de abrazo ficha")
spk_rec_pipeline.to(torch.device("cuda"))
asr_result, info = asr_model.transcribe(audio, language="zh", beam_size=5)
diarización_resultado = spk_rec_pipeline(audio)
resultado_final = diarizar_texto(resultado_asr, resultado_diarización)
para segmento, spk, enviado en resultado_final:
print("[%.2fs -> %.2fs] %s %s" % (segment.start, segment.end, sent, spk))