Tutorial de OpenAI Whisper: creación de la API OpenAI Whisper en un contenedor Docker

Descubra Whisper: el principal sistema de reconocimiento de voz de OpenAI

Whisper es un innovador sistema de reconocimiento de voz de OpenAI , elaborado por expertos a partir de 680.000 horas de datos multilingües y multitarea obtenidos en la web. Este amplio conjunto de datos dota a Whisper de una resistencia incomparable a los acentos, el ruido de fondo y la jerga técnica. También admite la transcripción en numerosos idiomas, lo que facilita traducciones fluidas al inglés. OpenAI proporciona acceso a los modelos y códigos de Whisper, lo que sirve como una base sólida para que los desarrolladores ingeniosos creen ingeniosas aplicaciones OpenAI Whisper e impulsen el dominio del reconocimiento de voz a nuevas alturas.

Cómo empezar con Docker

1. En primer lugar, si planea ejecutar el contenedor en su máquina local, debe tener instalado Docker. Puede encontrar las instrucciones de instalación aquí .
2. Creando una carpeta para nuestros archivos, llamémoslawhisper-api
3. Cree un archivo llamado requisitos.txt y agréguele un matraz.
4. Crea un archivo llamado Dockerfile

En el Dockerfile agregaremos las siguientes líneas:

FROM python:3.10-slim

WORKDIR /python-docker

COPY requirements.txt requirements.txt
RUN apt-get update && apt-get install git -y
RUN pip3 install -r requirements.txt
RUN pip3 install "git+https://github.com/openai/whisper.git"
RUN apt-get install -y ffmpeg

COPY . .

EXPOSE 5000

CMD [ "python3", "-m" , "flask", "run", "--host=0.0.0.0"]

Entonces, ¿qué está sucediendo exactamente en Dockerfile?

1. Elegir una imagen delgada de Python 3.10 como nuestra imagen base.
2. Creando un directorio de trabajo llamadopython-docker
3. Copiando nuestro archivo require.txt al directorio de trabajo
4. Actualizando el administrador de paquetes apt e instalando git
5. Instalación de los requisitos desde el archivo requisitos.txt
6. instalando el paquete susurro desde github.
7. Instalando ffmpeg
8. Y exponer el puerto 5000 y ejecutar el servidor flask.

Cómo crear nuestra ruta

1. Crea un archivo llamado app.py donde importamos todos los paquetes necesarios e inicializamos la aplicación flask y susurramos.
2. Agregue las siguientes líneas al archivo:

from flask import Flask, abort, request
from tempfile import NamedTemporaryFile
import whisper
import torch

# Check if NVIDIA GPU is available
torch.cuda.is_available()
DEVICE = "cuda" if torch.cuda.is_available() else "cpu"

# Load the Whisper model:
model = whisper.load_model("base", device=DEVICE)

app = Flask(__name__)

3. Ahora necesitamos crear una ruta que acepte una solicitud de publicación con un archivo.
4. Agregue las siguientes líneas al archivo app.py:

@app.route("/")
def hello():
    return "Whisper Hello World!"


@app.route('/whisper', methods=['POST'])
def handler():
    if not request.files:
        # If the user didn't submit any files, return a 400 (Bad Request) error.
        abort(400)

    # For each file, let's store the results in a list of dictionaries.
    results = []

    # Loop over every file that the user submitted.
    for filename, handle in request.files.items():
        # Create a temporary file.
        # The location of the temporary file is available in `temp.name`.
        temp = NamedTemporaryFile()
        # Write the user's uploaded file to the temporary file.
        # The file will get deleted when it drops out of scope.
        handle.save(temp)
        # Let's get the transcript of the temporary file.
        result = model.transcribe(temp.name)
        # Now we can store the result object for this file.
        results.append({
            'filename': filename,
            'transcript': result['text'],
        })

    # This will be automatically converted to JSON.
    return {'results': results}

¿Cómo ejecutar el contenedor?

1. Abra una terminal y navegue hasta la carpeta donde creó los archivos.
2. Ejecute el siguiente comando para construir el contenedor:

docker build -t whisper-api .

3. Ejecute el siguiente comando para ejecutar el contenedor:

docker run -p 5000:5000 whisper-api

¿Cómo probar la API?

1. Puede probar la API enviando una solicitud POST a la ruta http://localhost:5000/whisperque contiene un archivo. El cuerpo debe ser datos de formulario.
2. Puede utilizar el siguiente comando curl para probar la API:

curl -F "file=@/path/to/file" http://localhost:5000/whisper

3. Como resultado, debería obtener un objeto JSON con la transcripción.

¿Cómo implementar la API?

Esta API se puede implementar en cualquier lugar donde se pueda utilizar Docker. Solo tenga en cuenta que esta configuración actualmente usa CPU para procesar los archivos de audio. Si desea utilizar GPU, debe cambiar Dockerfile y compartir la GPU. No profundizaré en esto ya que se trata de una introducción. GPU acoplable

Puedes encontrar el código completo aquí.