Estás leyendo la publicación: Cree e implemente imágenes Docker personalizadas para el reconocimiento de objetos: hacia la IA
Motivación
Varios componentes están involucrados en la construcción y el despliegue. Por ejemplo, tiene marcos de ML como para construir su modelo, para hacer puntos finales de API y para una interfaz de usuario (UI) de front-end. No es sorprendente que, a menudo, el uso de todas estas herramientas juntas trabajar localmente en su máquina (¯\_(ツ)_/¯), pero no es reproducible en otros. Esto se debe en gran medida a las diferentes versiones de las bibliotecas, la falta de coincidencia de versiones de otras dependencias y los diferentes sistemas operativos (SO) en esas máquinas.
Para abordar este problema y garantizar replicabilidad y reproducibilidad a través de diferentes máquinas, Docker viene al rescate. Se puede utilizar para crear y ejecutar aplicaciones específicas de forma aislada y también para conectar diferentes aplicaciones/servicios. Esto está directamente relacionado con MLOps ya que avanza hacia la entrega de modelos ML a los usuarios finales.
El artículo está organizado de la siguiente manera:
- Objetivos
- Conceptos básicos
- Construyendo backend con PyTorch y API rápida
- Creación de frontend con Gradio
- Inicie la aplicación en dos líneas
Objetivos
Este artículo le muestra cómo construir y desplegar ¡una aplicación de reconocimiento de imágenes de aprendizaje automático de pila completa desde cero que puede reconocer diferentes objetos de sus propias imágenes!
Una vez que su aplicación esté configurada y ejecutándose localmente, verá cómo colocarla en contenedores y finalmente implementar las imágenes de la ventana acoplable (es decir, ejecutar contenedores). Se crea una imagen acoplable personalizada para el modelo de aprendizaje automático y la API RESTful que sirve como back-end. y otro para el Interfaz con una interfaz de usuario web que acepta imágenes de entrada, llama al extremo de la API para hacer una predicción y muestra los resultados.
Conceptos básicos
Reconocimiento de imagen
Reconocimiento de imagen es la tarea fundamental en visión artificial de reconocer qué objeto(s) está(n) presente(s) en una imagen. Esto también se conoce como clasificación de imágenes, que tiene aplicaciones que van desde vehículos autónomos hasta imágenes médicas.
API rápida
API rápida es un marco web moderno que se utiliza para crear API RESTful con Python. Es rápido, fácil de entender y requiere un código mínimo y potencialmente menos errores. Si bien FastAPI se puede usar para el desarrollo web, verá cómo usarlo específicamente para crear API.
Gradio
Gradio se utiliza para crear y compartir aplicaciones ML. Es una forma rápida de crear aplicaciones ML de prueba de concepto (POC) con una interfaz web fácil de usar para que cualquiera pueda usarla.
Estibador
Estibador es para construir aplicaciones aisladas. La idea central detrás de Docker es crear una aplicación que contenga el código fuente escrito, así como las especificaciones (p. ej., bibliotecas, versiones y sistema operativo) para ejecutarla. Estos se utilizan para crear una imagen acoplable, que luego se puede almacenar en Docker Hub para compartir con otros. Desde la imagen de la ventana acoplable, puede ejecutar la aplicación en un contenedor de la ventana acoplable donde el entorno de este contenedor está definido por las especificaciones al crear la imagen de la ventana acoplable.
¡Vamos al edificio ahora!
Construyendo backend con PyTorch y FastAPI
El backend consta de dos componentes: un modelo de aprendizaje automático PyTorch y una API RESTful.
Modelo de aprendizaje automático: El modelo preentrenado puede predecir 1000 objetos diferentes. Puede encontrar la lista de 1000 objetos aquí. Específicamente, el modelo es una red neuronal convolucional (CNN) conocida como ResNet-18 [1] que está capacitado en ImageNet [2] conjunto de datos Puede cargar fácilmente este modelo usando:
importar modelo de antorcha = torch.hub.load(‘pytorch/vision:v0.10.0’, ‘resnet18’, preentrenado=True)
Para hacer predicciones sobre sus propias imágenes de entrada, necesitaría preprocesar la imagen al tamaño deseado y normalizar la entrada de acuerdo con la forma en que se entrenó el modelo ResNet-18. Esto se hace por:
def preprocesamiento(input_image): preprocesamiento = transforma.Componer([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406]estándar=[0.229, 0.224, 0.225]), ]) input_tensor = preprocess(input_image) input_batch = input_tensor.unsqueeze(0) # crea un mini lote como lo espera el modelo return input_batch
Una vez que la imagen de entrada se procesa previamente, está lista para que el modelo haga una predicción. La función de predicción definida a continuación toma una imagen y el modelo ResNet-18 como entrada. Luego, el modelo hace una predicción y devuelve las cinco etiquetas principales (es decir, nombres de objetos/clases), así como las puntuaciones de probabilidad.
def predict(input_image, model): # Mueva la entrada y el modelo a la GPU para velocidad si está disponible if torch.cuda.is_available(): input_image = input_image.to(‘cuda’) model.to(‘cuda’)
con antorcha.no_grad():
salida = modelo (imagen de entrada)
# La salida tiene puntajes no normalizados. Para obtener probabilidades, puede ejecutar un softmax en él.
probabilidades = antorcha.nn.funcional.softmax(salida[0]tenue=0)
resultados = {“éxito”: Falso}
resultados[“predictions”] = []
# Lee las categorías
con open(“imagenet_classes.txt”, “r”) como f:
categorías = [s.strip() for s in f.readlines()]
# Mostrar categorías principales por imagen
top5_prob, top5_catid = antorcha.topk(probabilidades, 5)
para i en el rango (top5_prob.size (0)):
r = {“etiqueta”: categorías[top5_catid[i]], “probabilidad”: float(top5_prob[i].artículo())}
resultados[“predictions”].agregar(r)
resultados[“success”] = Verdadero
devolver resultados
Ahora, tienes la configuración del modelo. El siguiente componente en el backend consiste en crear un punto final de API en torno a esta función de predicción.
API RESTful: para crear un punto final de API, la función de predicción se realiza mediante . Esto implica cargar el modelo (es decir, descargar e instanciar el archivo del modelo) y finalmente crear una función que acepte solicitudes POST. Esto es tan simple como:
@app.post(“/api/predict”) asíncrono def predecir_imagen(imagen: bytes = Archivo(…)): # Leer imagen imagen = leer_imagen(imagen) # Preprocesar imagen imagen = preprocesar(imagen) # Predecir predicciones = predecir (imagen, modelo) predicciones de retorno
Cuando el servidor se está ejecutando, puede enviar solicitudes POST con una imagen al extremo de la API, y devolverá las cinco etiquetas principales y las puntuaciones de probabilidad. También puede encontrar la página de documentación en `http://127.0.0.1:8000/docs` que se ve así:
Tiene el backend en ejecución, que acepta imágenes como entradas y genera las etiquetas/objetos predichos. Es hora de dockerizar todo el backend.
Dockerizar el backend: para ejecutar este punto final de la API dentro de un contenedor acoplable, se debe crear una imagen acoplable. Esto requiere require.txt y un Dockerfile. Primero, require.txt está configurado para definir todos los módulos necesarios para que la aplicación funcione.
antorcha torchvision Almohada gunicorn fastapi==0.61.1 uvicorn==0.11.8 python-multipart Requests==2.24.0
En segundo lugar, se crea un Dockerfile para configurar las dependencias necesarias. Esto es lo que parece:
# Use un tiempo de ejecución oficial de Python como imagen principal DESDE python: 3.6-slim
# Copie el archivo de requisitos en la imagen
COPIAR ./requirements.txt /app/requirements.txt
# Establecer el directorio de trabajo en /app
WORKDIR /aplicación
# Instale los paquetes necesarios especificados en requirements.txt
EJECUTAR pip install -r requisitos.txt
# Copie todo el contenido de la carpeta local a la imagen
COPIAR . .
# Ejecutar servidor
CMD [“uvicorn”, “main:app”, “–host=0.0.0.0”, “–port=80”]
Ahora que el archivo require.txt y Dockerfile están configurados, puede crear una imagen usando esta especificación. Luego, puede ejecutar una instancia de esta imagen en un contenedor acoplable usando:
# build docker build -t class_model_serving . # ejecutar ventana acoplable ejecutar -p 8000: 80 –name cls-servir clasificación_modelo_servicio
El modelo se implementa como punto final de la API a través de un contenedor docker en su máquina local. Para hacer una solicitud, ejecute:
enrollamiento -X POST -F [email protected] “http://0.0.0.0:8000/api/predecir”
Si todo funciona correctamente, verá un resultado como:
{ “éxito”: verdadero, “predicciones”:
[
{
“label”: “king penguin”,
“probability”: 0.999931812286377
},
{
“label”: “guenon”,
“probability”: 9.768833479029126e-06
},
{
“label”: “megalith”,
“probability”: 8.01052556198556e-06
},
{
“label”: “cliff”,
“probability”: 7.119778274500277e-06
},
{
“label”: “toucan”,
“probability”: 6.5011186052288394e-06
}
]
}
El backend ahora está dockerizado. Puede enviar una solicitud al extremo de la API con una imagen, y devuelve las etiquetas y las puntuaciones de probabilidad. Veamos ahora cómo puedes construir la parte delantera.
Asegúrese de que el contenedor de la ventana acoplable de back-end se esté ejecutando cuando ejecute por primera vez el contenedor de la ventana acoplable de front-end en la siguiente sección.
Creación de frontend con Gradio
La tarea de la interfaz es aceptar las imágenes de entrada del usuario, realizar una llamada al extremo de la API (que es nuestro backend que ya se está ejecutando) con la imagen que devuelve las predicciones y, finalmente, mostrar los resultados al usuario. La función de inferencia i) carga la imagen (ya sea que la cargue el usuario o un ejemplo) ii) realiza una solicitud POST al extremo de la API iii) formatea los resultados para su visualización, y se ve así:
def inference(image_path): # Cargue la imagen de entrada y construya la carga útil para la solicitud image = open(image_path, “rb”).read() payload = {“image”: image}
# Enviar la solicitud
r = solicitudes.post(REST_API_URL, archivos=carga útil).json()
# Asegúrese de que la solicitud fue exitosa, formato de salida para visualización
salida = {}
si r[“success”]:
# Recorre las predicciones y muéstralas
para (i, resultado) en enumerar (r[“predictions”]):
producción[result[“label”]]= resultado[“probability”]
imprimir(“{}. {}: {:.4f}”.formato(i + 1, resultado[“label”],
resultado[“probability”]))
demás:
imprimir (“Solicitud fallida”)
salida de retorno
Y el diseño de la interfaz de usuario web está definido por:
title = “Demostración de reconocimiento de imágenes” description = “Esta es una aplicación prototipo que demuestra cómo los sistemas basados en inteligencia artificial pueden reconocer qué objeto(s) está(n) presente(s) en una imagen. Esta tarea fundamental en la visión por computadora conocida como `Clasificación de imágenes` tiene aplicaciones que se extienden desde vehículos autónomos hasta imágenes médicas. Para usarlo, simplemente cargue su imagen o haga clic en una de las imágenes de ejemplo para cargarlas, que tomé en Montréal Biodôme! Lea más en los enlaces a continuación”. article = “
Aprendizaje residual profundo para el reconocimiento de imágenes | < a href="https://github.com/pytorch/vision/blob/main/torchvision/models/resnet.py" target="_blank">Github Repo
”
# Ejecutar inferencia
frontend = gr.Interface(inferencia,
entradas,
salidas,
ejemplos=[“test1.jpeg”, “test2.jpeg”],
titulo=titulo,
descripción=descripción,
artículo=artículo,
analytics_enabled=Falso)
# Inicie la aplicación y configure PUERTO
frontend.launch(nombre_servidor=”0.0.0.0″, puerto_servidor=7860)
Cuando la interfaz de usuario web se esté ejecutando, se verá así:
Dockerizar la interfaz: Ahora, también querrá ejecutar la aplicación frontend dentro de otro contenedor docker.
Esto se debe a que supongamos que desea utilizar el extremo de la API para diferentes casos de uso, como en un teléfono móvil o una aplicación de escritorio, etc. backend no fallará con él y viceversa. Tenga en cuenta que habrá escenarios en los que querrá que se ejecuten en el mismo contenedor.
De manera similar al backend, deberá crear otro requisito.txt que tenga los módulos necesarios para que funcione el frontend.
solicitudes de gradio
Y, otro Dockerfile para configurar las dependencias necesarias.
# Use un tiempo de ejecución oficial de Python como imagen principal DESDE python: 3.9-slim
# Copie el archivo de requisitos en la imagen
COPIAR ./requirements.txt /app/requirements.txt
# Establecer el directorio de trabajo en /app
WORKDIR /aplicación
# Instale los paquetes necesarios especificados en requisitos.txt
EJECUTAR pip install -r requisitos.txt
# Copie todo el contenido de la carpeta local a la imagen
COPIAR . .
# Ejecutar servidor, la URL de grado predeterminada es http://127.0.0.1:7860
CMD [ “python3”, “-u”, “/app/main.py” ]
A continuación, puede compilar y ejecutar el contenedor usando:
# build docker build -t frontend_serving. # ejecutar contenedor docker ejecutar -p 7860:7860 –add-host host.docker.internal:host-gateway –name frnt-serve frontend_serving
La aplicación frontend está activa http://0.0.0.0:7860/ en su máquina local. Eso es todo. Ahora puedes jugar con la aplicación y darle tus propias imágenes y ver lo que dice.
Inicie la aplicación en dos líneas.
Si simplemente quiere jugar con la aplicación, he hecho públicas las imágenes de Docker en Docker Hub y puede ejecutar la aplicación con 2 líneas de código. Primero, para copiar el comando. En segundo lugar, presione enter!
git clone https://github.com/hasibzunair/imagercg-waiter cd imagercg-waiter/backend # ¡esta línea no cuenta! sh desplegar.sh
La aplicación está activa http://0.0.0.0:7860/ en su máquina local. O, si simplemente quieres jugar con la aplicación desde tu navegador, ve aquí.
Conclusión
En esta publicación, aprendió cómo crear y ejecutar una aplicación de ML de pila completa usando PyTorch, API rápiday Gradio garantizando al mismo tiempo la replicabilidad y la reproducibilidad utilizando Estibador. Construyó imágenes de ventana acoplable personalizadas para el front-end y el back-end, y creó un enlace de comunicación entre ellos utilizando un punto final de API. Finalmente, como usuario, carga sus imágenes en la aplicación que llama al extremo de la API para hacer una predicción y luego mostrar los resultados.
