¿Cómo implantar un modelo de aprendizaje automático?

En los últimos años, el aprendizaje automático y la inteligencia artificial han ganado mucha popularidad. Es probable que esto se deba a los avances en el procesamiento del lenguaje natural y los sistemas de recomendación.

Este artículo presenta el aprendizaje automático, sus aplicaciones, opciones de despliegue y demuestra cómo desplegar un modelo de aprendizaje automático simple en Back4app Containers.

¿Qué es el aprendizaje automático?

El aprendizaje automático es un subcampo de la inteligencia artificial. En esencia, aprovecha algoritmos estadísticos para aprender de los datos y hacer predicciones sobre datos nuevos y desconocidos.

En otras palabras, da a los ordenadores la capacidad de aprender sin estar explícitamente programados.

Aunque el aprendizaje automático y la inteligencia artificial se utilizan a menudo indistintamente, no son lo mismo.

El aprendizaje automático se centra en algoritmos y estructuras de datos, mientras que la inteligencia artificial es un intento general de crear máquinas capaces de pensar como los humanos.

Las técnicas típicas de aprendizaje automático son la regresión (predicción de un valor continuo, por ejemplo, el precio de una vivienda) y la clasificación (predicción de una clase a partir de un conjunto finito de clases, por ejemplo, el género de una película).

En términos generales, podemos dividir el aprendizaje automático en tres tipos:

• Aprendizaje supervisado: los algoritmos aprenden utilizando un conjunto de datos etiquetados. Cada ejemplo del conjunto de datos contiene una etiqueta (o la llamada variable objetivo). El algoritmo las utiliza para predecir las etiquetas de los ejemplos no etiquetados. Los algoritmos de aprendizaje supervisado incluyen kNN, árboles de decisión, etc.

• Aprendizaje no supervisado: los algoritmos aprenden sin ninguna orientación explícita. Depende del algoritmo encontrar patrones en los datos y hacer predicciones basadas en ellos. Un ejemplo de algoritmo es k-means clustering.

• Aprendizaje por refuerzo: los algoritmos aprenden por ensayo y error. Suelen basarse en recompensas y el objetivo del algoritmo es maximizar la recompensa. Ejemplo: algoritmos genéticos.

En la parte práctica del artículo, recorreremos un proceso típico de construcción de modelos. Resolveremos una tarea de clasificación mediante aprendizaje supervisado.

Aplicaciones de aprendizaje automático

Veamos algunas aplicaciones reales del aprendizaje automático.

Sistemas de recomendación

Los sistemas de recomendación sugieren qué artículos (películas, productos, etc.) debe consumir un usuario. Estos sistemas pueden basarse en el contenido o en la colaboración.

Hoy en día, casi todas las empresas utilizan sistemas recommeder. Permiten a las empresas aumentar el éxito comercial, crear demanda adicional, aumentar el compromiso de los usuarios, aprender sobre los clientes y mucho más.

Netflix, por ejemplo, las utiliza para recomendar películas, Spotify para recomendar canciones y YouTube para sugerirte vídeos que deberías ver en función de tus intereses.

Procesamiento del lenguaje natural (PLN)

El procesamiento del lenguaje natural (PLN) permite a los ordenadores procesar y comprender el lenguaje humano. La generación de lenguaje natural (NLG) permite a los ordenadores generar lenguaje humano.

Esta tecnología la utilizan chatbots, herramientas de traducción de idiomas, herramientas de análisis de sentimientos, etc. ChatGPT es uno de los ejemplos más famosos de NLP y NLG.

¿Quieres saber más sobre ChatGPT? Echa un vistazo a nuestro otro artículo llamado ¿Cómo crear una aplicación utilizando ChatGPT?

Visión por ordenador y reconocimiento de imágenes

La visión por ordenador confiere a los ordenadores la capacidad de “ver” y “entender” imágenes y vídeos. Les permite realizar segmentaciones (en tiempo real), reconocer objetos, rostros e incluso emociones.

Es la tecnología que utilizan las aplicaciones fotográficas para etiquetar automáticamente a tus amigos. Además, la utilizan los sistemas de vigilancia para detectar comportamientos sospechosos.

Detección de fraudes

Las empresas emplean el aprendizaje automático para detectar actividades sospechosas en las transacciones o en el comportamiento de los usuarios. Estos sistemas pueden detectar actos potencialmente fraudulentos mediante el estudio de tendencias y anomalías, protegiendo a empresas y clientes del fraude y la ciberdelincuencia.

Coches autónomos

La conducción autónoma de automóviles es uno de los problemas de aprendizaje automático más complicados. Combina diversas aplicaciones, como la visión por ordenador, la detección de anomalías, la predicción de comportamientos, la planificación de trayectorias, etcétera.

En el momento de escribir estas líneas, no estamos ni cerca de los coches totalmente autónomos. Los actuales coches “autoconducidos” solo funcionan bien en zonas geográficas restringidas.

Opciones de implantación del aprendizaje automático

Para desplegar un modelo de machine learning se suele servir desde una aplicación web. Por lo tanto, las opciones de despliegue de modelos de machine learning son prácticamente las mismas que para desplegar aplicaciones web. Veámoslas.

En las instalaciones

La implantación in situ implica alojar y gestionar equipos informáticos, como servidores y dispositivos de almacenamiento, en las propias instalaciones de una empresa.

Esta estrategia tradicional requiere una inversión inicial considerable en hardware y software y un mantenimiento y asistencia continuos.

Sus ventajas incluyen un mayor nivel de control y seguridad y una personalización más accesible. Por otro lado, las desventajas son el coste, la escalabilidad y el mantenimiento.

Nube

En cambio, el despliegue en la nube emplea servicios de terceros para alojar infraestructuras y aplicaciones a través de Internet.

Este modelo permite a los usuarios pagar sobre la marcha por recursos y servicios escalables, de los que se encargan los proveedores de servicios en nube.

Sus ventajas son la escalabilidad, la facilidad de uso y la ausencia de costes iniciales. Por otro lado, las desventajas son un menor nivel de control, menos flexibilidad y la posible dependencia de un proveedor.

Algunos ejemplos de plataformas basadas en la nube son:

• Back4app
• Amazon Web Services (AWS)
• Google Cloud Platform (GCP)
• Microsoft Azure

Algoritmos populares de aprendizaje automático

Los algoritmos de aprendizaje automático más populares son:

• k-Nearest Neighbours (kNN)
• Decision Trees & Random Forests
• Support Vector Machines (SVM)
• Linear Regression
• Naive Bayes
• K-means

En el ejemplo práctico, utilizaremos k-Nearest Neighbours.

¿Cómo desplegar un modelo de aprendizaje automático?

En esta sección del artículo, construiremos un modelo de aprendizaje automático, lo serviremos con FastAPI, lo dockerizaremos y, por último, lo desplegaremos en Back4app Containers.

Requisitos previos

• Conocimientos básicos de aprendizaje automático
• Experiencia con Python y FastAPI
• Conocimientos básicos de Docker y la tecnología de contenedorización
• Git y Docker Desktop instalados en su máquina local

Resumen del proyecto

Antes de demostrar cómo desplegar un modelo de aprendizaje automático, construiremos uno. Crearemos un sencillo clasificador kNN utilizando el popular conjunto de datos Iris. El objetivo del modelo será predecir si una observación es “setosa”, “versicolor” o “virginica” basándonos en diferentes características.

Luego guardaremos el modelo en un archivo, lo cargaremos en FastAPI y lo serviremos a través de un endpoint. Después de eso, vamos a dockerizar la aplicación, empujarla a GitHub, y desplegarla en Back4app Containers.

Crear modelo

Para crear el modelo, utilizaremos Jupyter Notebooks. Puedes instalar Jupyter en tu máquina local o utilizar Google Colab de forma gratuita.

Primero crea un nuevo cuaderno Jupyter.

Cada bloque de código en esta sección del artículo representa una celda Jupyter. Puede crearlas desde el menú o mediante la combinación de teclas “B” (en modo comando).

Además, no olvides ejecutarlas (desde el menú o utilizando “ALT + ENTER”).

Añade las siguientes importaciones en la primera celda:

import numpy as np
import pandas as pd

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.model_selection import cross_val_score
from sklearn.metrics import accuracy_score

from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline

from joblib import dump

Cargar conjunto de datos

El conjunto de datos Iris está incluido por defecto en Scikit-learn. Todo lo que tiene que hacer es llamar a la función load_iris() y transformar el objeto en un fotograma.

Crea una nueva celda:

df = load_iris(as_frame=True)["data"]
df["target"] = load_iris(as_frame=True)["target"]

Al cargar el conjunto de datos Iris, se ordena por la variable objetivo. Esto no es bueno porque nuestro modelo de aprendizaje automático podría ver sólo algunos tipos de ejemplos en la fase de entrenamiento. Por ejemplo, sólo “setosa” y “versicolor”.

Para evitar este problema, podemos barajarlo:

df = df.sample(frac=1, random_state=42)

El atributo random_state se utiliza para la reproducibilidad. Puede utilizar cualquier número que desee.

Explorar el conjunto de datos

Antes de crear un modelo, es una buena idea explorar con qué datos estamos tratando. Para ello, puede utilizar las funciones integradas de Pandas, como head(), describe(), etc.

# Displays the first five rows of the dataset
df.head(5)

# Generates descriptive statistics
df.describe()

Además, debe visualizar el conjunto de datos para averiguar qué características separan mejor los ejemplos y qué algoritmo de aprendizaje automático podría ser útil para su problema.

La imagen de arriba ha sido tomada del artículo Guide to Data Visualization with Python. Asegúrate de echarle un vistazo para aprender más sobre visualización de datos.

La imagen muestra que los puntos “rojos” se pueden separar linealmente de los otros dos. En cambio, los puntos “azul” y “verde” no son linealmente separables.

Dividir el conjunto de datos

A continuación, definamos las características (predictores) y la variable objetivo:

features = [
    "sepal length (cm)", "sepal width (cm)", "petal length (cm)", "petal width (cm)"
]
target = "target"

A continuación, extráigalos en X (datos de características) e y (datos de la variable objetivo) y divídalos en tren de prueba:

X = df[features].values
y = df[target].values

dev_X, test_X, dev_y, test_y = train_test_split(X, y, test_size=0.25, random_state=42)

Al utilizar test_size=0,25, el 25% del conjunto de datos se utiliza para las pruebas, mientras que el 75% se utiliza para el entrenamiento.

Modelo de construcción

A continuación, cree una canalización que primero escale los datos y luego utilice el clasificador kNN:

knn = Pipeline(steps=[
    ("scaler", StandardScaler()),
    ("predictor", KNeighborsClassifier()),
])
knn.fit(dev_X, dev_y)

Para saber por qué es esencial escalar, consulte este artículo.

A continuación, utilice la validación cruzada de 10 veces y compruebe el error de validación:

cross_val_score(knn, dev_X, dev_y, cv=10, scoring="accuracy").mean()

# 0.9363636363636362

Evalúe el modelo en el conjunto de pruebas:

accuracy_score(test_y, knn.predict(test_X))

# 0.9736842105263158

La precisión de la validación y de la prueba son prácticamente iguales. Esto indica que nuestro modelo no se ajusta por defecto ni por exceso.

Guardar modelo

Por último, vuelva a entrenar el modelo utilizando todos los datos y guárdelo en el archivo model.pkl:

knn.fit(X, y)
dump(knn, "model.pkl")

Si estabas utilizando Google Colab, descarga el archivo model.pk ya que lo necesitaremos en el siguiente paso.

Modelo de servicio

Como hemos mencionado antes, utilizaremos FastAPI para servir el modelo.

Sigue adelante y crea un nuevo proyecto FastAPI y reemplaza main.py así:

# main.py

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def root():
    return {
        "name": "back4app-deploy-ml-model",
        "description": "A FastAPI app serving an ML model",
        "version": "1.0.0",
    }

Inicie el servidor de desarrollo:

$ uvicorn app.main:app --reload

Navegue a http://localhost:8000/, y debería obtener la siguiente respuesta:

{
    "name": "back4app-deploy-ml-model",
    "description": "A FastAPI app serving an ML model",
    "version": "1.0.0"
}

Modelo de carga

A continuación, carguemos el modelo y definamos las model_classes.

Primero copia model.pkl del paso anterior en la raíz de tu proyecto. A continuación, cargue el modelo y defina las clases justo debajo de la inicialización de la aplicación FastAPI de esta manera:

# ...

model = load("model.pkl")
model_classes = {
    0: "setosa",
    1: "versicolor",
    2: "virginica",
}

# ...

Utilizaremos model_classes para traducir la variable de destino de numérica a texto.

Modelo de carga

A continuación, crea el endpoint /predict, que toma las características y utiliza el modelo cargado para hacer una predicción:

# main.py

# ...

class Observation(BaseModel):
    """
    A Pydantic model for the observation data.
    This is our ML model's input data.
    """
    sepal_length: float
    sepal_width: float
    petal_length: float
    petal_width: float


@app.post("/predict")
async def predict(observation: Observation):
    predictions = model.predict([[
        observation.sepal_length,
        observation.sepal_width,
        observation.petal_length,
        observation.petal_width,
    ]])
    prediction = predictions[0]
    prediction_class = model_classes[prediction]
    return {
        "prediction": int(prediction),
        "prediction_class": prediction_class,
    }

El punto final devuelve la predicción numérica, así como la predicción de prueba fácil de usar.

No te olvides de las importaciones en la parte superior del archivo:

from joblib import load
from pydantic import BaseModel

Tu main.py final debería tener este aspecto.

Reinicie el servidor de desarrollo y navegue a http://localhost:8000/docs en su navegador web favorito. FastAPI genera automáticamente documentación interactiva para todos sus puntos finales.

Pruebe el modelo enviando una solicitud como ésta:

Genial, ¡nuestra aplicación web ya funciona a pleno rendimiento!

Aplicación Dockerize

En esta sección del artículo, vamos a dockerizar la aplicación web. Crearemos un Dockerfile y configuraremos el archivo .dockerignore.

Dockerfile

Un Dockerfile es un archivo que contiene instrucciones que Docker Engine debe seguir para construir la imagen.

Suelen incluir la transferencia de archivos, la definición de la imagen base, la configuración del directorio de trabajo, la ejecución de comandos personalizados, etc.

Los comandos de Dockerfile suelen escribirse en mayúsculas y van seguidos directamente de sus argumentos correspondientes.

<COMMAND> <arg1> <arg2> ... <arg_n>

# Example
WORKDIR /app

Visite la referencia Dockerfile para obtener más información sobre todas las instrucciones.

En la raíz del proyecto, crea un Dockerfile:

# Dockerfile

# Set the base image
FROM python:3.12.2-alpine3.19

# Install the required dependencies (gcc)
RUN apk add build-base

# Set the working directory
WORKDIR /app

# Confingure Python using environmental variables
ENV PYTHONDONTWRITEBYTECODE 1
ENV PYTHONUNBUFFERED 1

# Copy the requirements file into the image and install them
COPY ./requirements.txt .
RUN pip install --no-cache-dir --upgrade pip
RUN pip install --no-cache-dir --upgrade -r ./requirements.txt

# Copy the source code into the image
COPY . .

# Expose the port
EXPOSE 8000

# Start the Uvicorn server
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

.dockerignore

Cuando trabajes con Docker, querrás crear imágenes lo más pequeñas posible.

Una forma de reducir el tamaño de la imagen es utilizar un archivo .dockerignore. Este archivo funciona de forma similar a un archivo .gitignore. Permite omitir archivos que no es necesario incluir en la imagen.

En la raíz del proyecto, cree un .dockerignore:

.git/
.idea/

__pycache__/
venv/

create_model.ipynb

Asegúrese de adaptar el archivo .dockerignore según los requisitos de su proyecto (por ejemplo, si utiliza un IDE diferente).

Construir, ejecutar, probar

Antes de enviar la imagen a la nube, conviene probarla localmente.

Para seguir adelante necesitarás tener instalado Docker Desktop en tu máquina.

Abra el terminal y compruebe las imágenes instaladas actualmente:

$ docker images

A continuación, cree la imagen utilizando el archivo Dockerfile:

$ docker build -t iris-webapp:1.0 .

Docker tardará bastante en construir la imagen. Esto se debe principalmente a que Scikit-learn no está optimizado para contenedores Docker. Siéntase libre de tomar un café rápido.

Una vez finalizado el comando, vuelva a comprobar las imágenes. La imagen recién creada debería estar allí.

Por último, utiliza la imagen para crear un nuevo contenedor:

 $ docker run -p 8000:8000 --name iris-webapp iris-webapp:1.0

¡Ya está!

Tu aplicación web está ahora en un contenedor. Debería ser accesible en http://localhost:8000/ y funcionar igual que antes.

Empujar a GitHub

Primero, navega a GitHub y crea un nuevo repositorio. Toma nota de la URL remota, ya que la necesitaremos en un paso posterior.

A continuación, vuelve a la raíz de tu proyecto.

Antes de subir el código fuente a la nube, crea un archivo .gitignore. Un archivo . gitignore te permite especificar qué archivos y directorios deben omitirse del control de versiones.

Este tipo de archivo funciona de la misma manera que los archivos .dockerignore.

En la raíz del proyecto, cree un archivo .gitignore:

#.dockerignore

.idea/
__pycache__/
venv/

Abre el terminal y ejecuta el siguiente comando para inicializar Git:

$ git init

Añade todos los archivos al VCS y envíalos:

$ git add .
$ git commit -m "first commit"

Por último, añade el origen remoto de GitHub utilizando la URL de antes y empuja el código fuente:

$ git remote add origin <remote_url>
$ git push origin master

Asegúrese de que la URL remota del paso anterior se utiliza en lugar de .

Ya está. Si ahora visitas la página del repositorio de GitHub, deberías ver que se han añadido todos los archivos.

Despliegue de la aplicación

Para desplegar una aplicación en Back4app Containers, primero debes registrarte o iniciar sesión (si ya tienes una cuenta).

Cuando te autentiques con tu cuenta de Back4app, accederás al panel de control de tu aplicación. Para crear una nueva aplicación, haz clic en “Crear nueva aplicación”.

Back4app permite el despliegue de Backend as a Service y Containers as a Service. Dado que vamos a desplegar una aplicación en contenedores, optaremos por esta última opción.

A continuación, tendrás que conectar tu cuenta de GitHub a Back4app. Esto permitirá a Back4app extraer el código fuente de tus repositorios. Puedes conceder acceso a todos los repositorios o elegir algunos específicos.

Una vez importados los repositorios, haga clic en “Seleccionar”.

No es necesario configurar el entorno, aparte de proporcionar un nombre de aplicación descriptivo.

A continuación, haga clic en “Crear”.

Back4app necesitará unos minutos para crear la imagen, enviarla al registro de contenedores y poner en marcha un contenedor. Una vez completado el despliegue, el estado de tu aplicación debería cambiar a “Listo”.

Para visitar su aplicación, haga clic en la URL que se indica en la imagen siguiente.

Genial, has desplegado con éxito un modelo de aprendizaje automático en Back4app Containers. La aplicación web debería funcionar de la misma manera que lo hizo localmente. Asegúrese de probar la aplicación una vez más.

Resumen

En este artículo, ha aprendido los conceptos básicos del aprendizaje automático, sus aplicaciones y cómo implementar un modelo de aprendizaje automático.

Ahora deberías ser capaz de crear tus propios modelos simples, servirlos con FastAPI y desplegarlos en Back4app Containers.

Obtenga el código fuente final de back4app-deploy-ml-model GitHub repo.