Header Ads Widget

Ticker

6/recent/ticker-posts

Cómo transcribir grabaciones de voz en texto con Python

 Cuando tiene una grabación en la que una o más personas están hablando, es útil tener una forma altamente precisa y automatizada de extraer las palabras habladas en texto. Una vez que tenga el texto, puede usarlo para un análisis más detallado o como una función de accesibilidad.

En este tutorial, usaremos una interfaz de programación de aplicaciones web de voz a texto de alta precisión llamada AssemblyAI para extraer texto de una grabación MP3 (también se admiten muchos otros formatos).

Con el código de este tutorial, podrá tomar un archivo de audio que contenga un discurso como el de este ejemplo que grabé y generar una transcripción de texto altamente precisa como esta:

Un mapeador relacional de objetos es una biblioteca de código que automatiza la transferencia de 
datos almacenados en bases de datos relacionales en objetos que se utilizan con más frecuencia
en el código de aplicación o EMS son útiles porque proporcionan un alto nivel 
abstracción sobre una base de datos relacional que permite a los desarrolladores escribir Python 
código en lugar de secuela para crear lectura, actualización y eliminación, datos y esquemas en 
su base de datos. Los desarrolladores pueden utilizar el lenguaje de programación. Son
cómodo para trabajar con una base de datos en lugar de escribir SQL ...

(el texto continúa desde aquí pero lo abrevié en este punto)

Requisitos del tutorial

A lo largo de este tutorial vamos a utilizar las siguientes dependencias, que instalaremos en un momento. Asegúrese de tener también Python 3, preferiblemente 3.6 o más reciente instalado , en su entorno:

Usaremos las siguientes dependencias para completar este tutorial:

Todo el código de esta publicación de blog está disponible en código abierto bajo la licencia MIT en GitHub en el directorio transcribe-speech-text-script del repositorio de ejemplos de código de blog . Utilice el código fuente como desee para sus propios proyectos.

Configurar el entorno de desarrollo

Cambie al directorio donde guarda sus entornos virtuales de Python Mantengo el mío en un subdirectorio nombrado venvsdentro del directorio de inicio de mi usuario. Cree un nuevo virtualenv para este proyecto usando el siguiente comando.

python3 -m venv ~ / venvs / pytranscribe

Active virtualenv con el activatescript de shell:

fuente ~ / venvs / pytranscribe / bin / enable

Después de que se ejecute el comando anterior, el símbolo del sistema cambiará de modo que el nombre del virtualenv se anteponga al formato original del símbolo del sistema, por lo que si su mensaje es simple $, ahora se verá así:

(pytranscribe) $

Recuerde, debe activar su virtualenv en cada nueva ventana de terminal donde quiera usar dependencias en virtualenv.

Ahora podemos instalar el requestspaquete en el virtualenv activado pero vacío.

solicitudes de instalación de pip == 2.24.0

Busque un resultado similar al siguiente para confirmar que los paquetes adecuados se instalaron correctamente desde PyPI.

(pytranscribe) solicitudes de instalación de $ pip == 2.24.0
Recopilación de solicitudes == 2.24.0
  Utilizando https://files.pythonhosted.org/packages/45/1e/0c169c6a5381e241ba7404532c16a21d86ab872c9bed8bdcd4c423954103/requests-2.24.0-py2.py3-none-any.whl en caché
Recopilación de certifi> = 2017.4.17 (de solicitudes == 2.24.0)
  Usando https://files.pythonhosted.org/packages/5e/c4/6c4fe722df5343c33226f0b4e0bb042e4dc13483228b4718baf286f86d87/certifi-2020.6.20-py2.py3-none-any.whl almacenado en caché
Recopilando urllib3! = 1.25.0,! = 1.25.1, <1.26,> = 1.21.1 (de las solicitudes == 2.24.0)
  Usando https://files.pythonhosted.org/packages/9f/f0/a391d1463ebb1b233795cabfc0ef38d3db4442339de68f847026199e69d7/urllib3-1.25.10-py2.py3-none-any.whl almacenado en caché
Recopilación de chardet <4,> = 3.0.2 (de solicitudes == 2.24.0)
  Usando https://files.pythonhosted.org/packages/bc/a9/01ffebfb562e4274b6487b4bb1ddec7ca55ec7510b22e4c51f14098443b8/chardet-3.0.4-py2.py3-none-any.whl almacenado en caché
Recopilación de idna <3,> = 2.5 (de solicitudes == 2.24.0)
  Usando https://files.pythonhosted.org/packages/a2/38/928ddce2273eaa564f6f50de919327bf3a00f091b5baba8dfa9460f3a8a8/idna-2.10-py2.py3-none-any.whl en caché
Instalación de paquetes recopilados: certifi, urllib3, chardet, idna, solicitudes
Se instaló correctamente certifi-2020.6.20 chardet-3.0.4 idna-2.10 solicitudes-2.24.0 urllib3-1.25.10

Tenemos todas nuestras dependencias requeridas instaladas para que podamos comenzar a codificar la aplicación.

Subir, iniciar y transcribir audio

Tenemos todo lo que necesitamos para comenzar a construir nuestra aplicación que transcribirá audio a texto. Vamos a construir esta aplicación en tres archivos:

  1. upload_audio_file.py : carga su archivo de audio a un lugar seguro en el servicio de AssemblyAI para que se pueda acceder a él para su procesamiento. Si ya se puede acceder a su archivo de audio con una URL pública, no es necesario que realice este paso, solo puede seguir esta guía de inicio rápido
  2. initiate_transcription.py : le dice a la API qué archivo transcribir y comenzar inmediatamente
  3. get_transcription.py : imprime el estado de la transcripción si aún se está procesando, o muestra los resultados de la transcripción cuando el proceso está completo

Cree un nuevo directorio llamado pytranscribepara almacenar estos archivos a medida que los escribimos. Luego cambie al directorio del nuevo proyecto.

mkdir pytranscibe
cd pytranscribe

También necesitamos exportar nuestra clave API de AssemblyAI como una variable de entorno. Regístrese para obtener una cuenta de AssemblyAI e inicie sesión en el panel de control de AssemblyAI , luego copie "Su token de API" como se muestra en esta captura de pantalla:

Panel de instrumentos de AssemblyAI.

exportar ASSEMBLYAI_KEY = your-api-key-here

Tenga en cuenta que debe usar el exportcomando en cada ventana de línea de comando en la que desee que esta tecla sea accesible. Los scripts que estamos escribiendo no podrán acceder a la API si no tiene el token exportado como ASSEMBLYAI_KEYen el entorno en el que está ejecutando el script.

Ahora que tenemos nuestro directorio de proyecto creado y la clave API establecida como una variable de entorno, pasemos a escribir el código para el primer archivo que cargará archivos de audio en el servicio AssemblyAI.

Subiendo el archivo de audio para transcripción

Cree un nuevo archivo con el nombre upload_audio_file.pyy coloque el siguiente código en él:

importar argparse
importar sistema operativo
solicitudes de importación


API_URL = "https://api.assemblyai.com/v2/"


def upload_file_to_api (nombre de archivo):
    "" "Busca un archivo válido y luego lo carga en AssemblyAI
    para que se pueda guardar en una URL segura a la que solo ese servicio pueda acceder.
    Cuando se complete la carga, podemos iniciar la transcripción
    Llamada API.
    Devuelve la API JSON si tiene éxito, o None si el archivo no existe.
    "" "
    si no es os.path.exists (nombre de archivo):
        regresar Ninguno

    def read_file (nombre de archivo, chunk_size = 5242880):
        con open (nombre de archivo, 'rb') como _file:
            mientras es cierto:
                data = _file.read (tamaño_del_ fragmento)
                si no son datos:
                    rotura
                datos de rendimiento

    encabezados = {'autorización': os.getenv ("ASSEMBLYAI_KEY")}
    respuesta = solicitudes.post ("". unirse ([API_URL, "subir"]), encabezados = encabezados,
                             data = read_file (nombre de archivo))
    devolver respuesta.json ()

El código anterior importa los paquetes argparseosrequestspara que podamos usarlos en este script. El API_URLes una constante que tiene la URL base del servicio AssemblyAI. Definimos la upload_file_to_apifunción con un solo argumento, filename que debería ser una cadena con la ruta absoluta a un archivo y su nombre de archivo.

Dentro de la función, verificamos que el archivo exista, luego usamos la codificación de transferencia fragmentada de Request para transmitir archivos grandes a la API AssemblyAI.

La función osdel módulo getenvlee la API que se estableció en la línea de comando usando el exportcomando con getenvAsegúrese de usar ese exportcomando en la terminal donde está ejecutando este script, de lo contrario, ese ASSEMBLYAI_KEYvalor estará en blanco. En caso de duda, utilice echo $ASSEMBLY_AIpara ver si el valor coincide con su clave API.

Para usar la upload_file_to_apifunción, agregue las siguientes líneas de código en el upload_audio_file.pyarchivo para que podamos ejecutar correctamente este código como un script llamado con el pythoncomando:

if __name__ == "__main__":
    analizador = argparse.ArgumentParser ()
    parser.add_argument ("nombre de archivo")
    args = parser.parse_args ()
    upload_filename = args.filename
    response_json = upload_file_to_api (upload_filename)
    si no respuesta_json:
        imprimir ("el archivo no existe")
    más:
        print ("Archivo subido a URL: {}". formato (response_json ['upload_url']))

El código anterior crea un ArgumentParserobjeto que permite a la aplicación obtener un único argumento de la línea de comando para especificar el archivo al que queremos acceder, leer y subir al servicio AssmeblyAI.

Si el archivo no existe, el script imprimirá un mensaje de que no se pudo encontrar el archivo. En la ruta feliz donde encontramos el archivo correcto en esa ruta, entonces el archivo se carga usando el código en upload_file_to_apifunción.

Ejecute el upload_audio_file.pyscript completo ejecutándolo en la línea de comando con el pythoncomando. Reemplace FULL_PATH_TO_FILE con una ruta absoluta al archivo que desea cargar, como /Users/matt/devel/audio.mp3.

python upload_audio_file.py FULL_PATH_TO_FILE

Suponiendo que el archivo se encuentre en la ubicación que especificó, cuando el script termine de cargar el archivo, imprimirá un mensaje como este con una URL única:

Archivo subido a URL: https://cdn.assemblyai.com/upload/463ce27f-0922-4ea9-9ce4-3353d84b5638

Esta URL no es pública, solo puede ser utilizada por el servicio AssemblyAI, por lo que nadie más podrá acceder a su archivo y su contenido, excepto usted y su API de transcripción.

La parte que es importante es la última sección de la URL, en este ejemplo lo es 463ce27f-0922-4ea9-9ce4-3353d84b5638Guarde ese identificador único porque necesitamos pasarlo al siguiente script que inicia el servicio de transcripción.

Iniciar la transcripción

A continuación, escribiremos un código para iniciar la transcripción. Cree un nuevo archivo llamado initiate_transcription.pyAgregue el siguiente código al nuevo archivo.

importar argparse
importar sistema operativo
solicitudes de importación


API_URL = "https://api.assemblyai.com/v2/"
CDN_URL = "https://cdn.assemblyai.com/"


def initiate_transcription (file_id):
    "" "Envía una solicitud a la API para transcribir un
    archivo que se subió previamente a la API. Esta voluntad
    no devolver inmediatamente la transcripción porque se necesita
    un momento para que el servicio analice y realice la
    transcripción, por lo que hay una función diferente para recuperar
    Los resultados.
    "" "
    endpoint = "" .join ([API_URL, "transcripción"])
    json = {"audio_url": "" .join ([CDN_URL, "upload / {}". formato (file_id)])}
    encabezados = {
        "autorización": os.getenv ("ASSEMBLYAI_KEY"),
        "tipo de contenido": "aplicación / json"
    }
    respuesta = solicitudes.post (punto final, json = json, encabezados = encabezados)
    devolver respuesta.json ()

Tenemos las mismas importaciones que el script anterior y hemos agregado una nueva constante, CDN_URLque coincide con la URL separada donde AssemblyAI almacena los archivos de audio cargados.

La initiate_transcriptionfunción esencialmente sólo establece una única solicitud HTTP a la API AssemblyAI para iniciar el proceso de transcripción en el archivo de audio en la URL específica aprobada en Esta es la razón por que pasa en el. file_idEs importante: que completa la URL del archivo de audio que somos decirle a AssemblyAI que recupere.

Termine el archivo agregando este código para que se pueda invocar fácilmente desde la línea de comandos con argumentos.

if __name__ == "__main__":
    analizador = argparse.ArgumentParser ()
    parser.add_argument ("file_id")
    args = parser.parse_args ()
    file_id = args.file_id
    response_json = initiate_transcription (file_id)
    imprimir (response_json)

Inicie el script ejecutando el pythoncomando en el initiate_transcriptionarchivo y pase el identificador de archivo único que guardó en el paso anterior.

# el FILE_IDENTIFIER se devuelve en el paso anterior y se
# parece algo como esto: 463ce27f-0922-4ea9-9ce4-3353d84b5638
python initiate_transcription.py FILE_IDENTIFIER

La API enviará una respuesta JSON que este script imprime en la línea de comandos.

{'audio_end_at': Ninguno, 'acoustic_model': 'assemblyai_default', 'text': Ninguno, 
 'audio_url': 'https://cdn.assemblyai.com/upload/463ce27f-0922-4ea9-9ce4-3353d84b5638', 
 'speed_boost': False, 'language_model': 'assemblyai_default', 'redact_pii': False, 
 'confianza': Ninguna, 'webhook_status_code': Ninguna, 
 'id': 'gkuu2krb1-8c7f-4fe3-bb69-6b14a2cac067', 'status': 'en cola', 'boost_param': Ninguno, 
 'palabras': Ninguna, 'format_text': Verdadero, 'webhook_url': Ninguna, 'puntuar': Verdadero, 
 'utterances': None, 'audio_duration': None, 'auto_highlights': False, 
 'word_boost': [] , 'dual_channel': Ninguno, 'audio_start_from': Ninguno}

Tome nota del valor de la idclave en la respuesta JSON. Este es el identificador de transcripción que debemos usar para recuperar el resultado de la transcripción. En este ejemplo, lo es gkuu2krb1-8c7f-4fe3-bb69-6b14a2cac067Copie el identificador de transcripción en su propia respuesta porque lo necesitaremos para verificar cuándo se ha completado el proceso de transcripción en el siguiente paso.

Recuperando el resultado de la transcripción

Hemos subido y comenzado el proceso de transcripción, así que obtengamos el resultado tan pronto como esté listo.

El tiempo que se tarda en recuperar los resultados puede depender del tamaño del archivo, por lo que este siguiente script enviará una solicitud HTTP a la API e informará el estado de la transcripción, o imprimirá la salida si está completa.

Cree un tercer archivo de Python llamado get_transcription.pyy coloque el siguiente código en él.

importar argparse
importar sistema operativo
solicitudes de importación


API_URL = "https://api.assemblyai.com/v2/"


def get_transcription (transcription_id):
    "" "Solicita la transcripción de la API y devuelve el JSON
    respuesta."""
    endpoint = "" .join ([API_URL, "transcripción / {}". formato (transcription_id)])
    encabezados = {"autorización": os.getenv ('ASSEMBLYAI_KEY')}
    respuesta = solicitudes.get (punto final, encabezados = encabezados)
    devolver respuesta.json ()


if __name__ == "__main__":
    analizador = argparse.ArgumentParser ()
    parser.add_argument ("transcription_id")
    args = parser.parse_args ()
    transcription_id = args.transcription_id
    response_json = get_transcription (transcription_id)
    si response_json ['estado'] == "completado":
        por palabra en response_json ['palabras']:
            imprimir (palabra ['texto'], fin = "")
    más:
        print ("estado actual de la solicitud de transcripción: {}". formato (
              response_json ['estado']))

El código anterior tiene las mismas importaciones que los otros scripts. En esta nueva get_transcriptionfunción, simplemente llamamos a la API de AssemblyAI con nuestra clave de API y el identificador de transcripción del paso anterior (no el identificador de archivo). Recuperamos la respuesta JSON y la devolvemos.

En la función principal manejamos el identificador de transcripción que se pasa como un argumento de línea de comando y lo pasamos a la get_transcriptionfunción. Si la respuesta JSON de la get_transcriptionfunción contiene un completedestado, imprimimos los resultados de la transcripción. De lo contrario, imprima el estado actual que es queuedprocessinganterior completed.

Llame al script usando la línea de comando y el identificador de transcripción de la sección anterior:

python get_transcription.py TRANSCRIPTION_ID

Si el servicio aún no ha comenzado a trabajar en la transcripción, volverá queuedasí:

estado actual de la solicitud de transcripción: en cola

Cuando el servicio esté trabajando actualmente en el archivo de audio, devolverá processing:

estado actual de la solicitud de transcripción: procesamiento

Cuando se complete el proceso, nuestro script devolverá el texto de la transcripción, como puede ver aquí:

Un mapeador relacional de objetos es una biblioteca de código que automatiza la transferencia de 
datos almacenados en bases de datos relacionales en objetos que se utilizan con más frecuencia
en el código de aplicación o EMS son útiles porque proporcionan un alto nivel 

... (salida abreviada)

Eso es todo, ¡tenemos nuestra transcripción!

Es posible que se pregunte qué hacer si la precisión no es la que necesita para su situación. Ahí es donde entra en juego aumentar la precisión de las palabras clave o frases y seleccionar un modelo que se adapte mejor a sus datos . Puede utilizar cualquiera de esos dos métodos para aumentar la precisión de sus grabaciones a un nivel aceptable para su situación.

Publicar un comentario

0 Comentarios