Tutorial de PostgresML: haz machine learning con SQL

La tendencia general en machine learning es mover los datos al entorno del modelo para entrenarlo. Pero ¿y si lo hacemos al revés? Dado que las bases de datos actuales son varios órdenes de magnitud más grandes que los modelos de ML, ¿no sería mucho más sencillo llevar los modelos a los conjuntos de datos?

Esa es la idea central de PostgresML: los datos se quedan donde están y tú llevas tu código a la base de datos. Este enfoque de machine learning con la lógica invertida aporta un montón de ventajas prácticas que te harán replantearte el concepto de «base de datos».

¿Qué es PostgresML y por qué elegirlo?

PostgresML es una plataforma integral de machine learning construida sobre la popular base de datos PostgreSQL. Introduce un nuevo paradigma llamado machine learning «en base de datos», que te permite realizar muchas tareas de ML en SQL sin necesitar herramientas separadas en cada paso.

Aunque es relativamente nuevo, PostgresML promete estas ventajas claras:

• ML en base de datos: te permite entrenar, desplegar y ejecutar modelos de ML directamente dentro de tu base de datos PostgreSQL. Así evitas mover datos constantemente entre la base de datos y frameworks externos, mejorando la eficiencia y reduciendo la latencia en cada etapa.
• API SQL: si te encantan SQL y el machine learning, postgresml.org puede convertirse en tu web favorita. La plataforma te permite entrenar, ajustar y desplegar modelos de ML con sentencias SQL SELECT. Para analistas y científicos de datos sin experiencia profunda en media docena de frameworks de ML, esta función puede redefinir por completo su trabajo diario.
• Modelos preentrenados: PostgresML se integra fácilmente con HuggingFace, lo que le da acceso a cientos de modelos preentrenados como Llama, Falcon, Bert, Mistral, etc.
• Personalización y flexibilidad: PostgresML es compatible con más de 50 algoritmos de Scikit-learn, XGBoost, LGBM, PyTorch y TensorFlow. Así podrás entrenar y desplegar modelos de ML para muchas tareas de aprendizaje supervisado directamente desde tu base de datos.
• Integración con ecosistemas existentes: como PostgresML es, en esencia, una base de datos, puedes interactuar con él en cualquier entorno que soporte Postgres (básicamente en cualquier sitio). La plataforma también ofrece SDKs para 16 lenguajes por si hacer ML en SQL te resulta demasiado extraño (JavaScript, Python y Rust son los mejor soportados).

Pondremos a prueba todas estas funciones en este tutorial siguiendo un flujo de trabajo típico de machine learning:

1. Carga de datos
2. Preprocesamiento
3. Entrenamiento de un modelo
4. Ajuste de hiperparámetros
5. Despliegue en producción

…todo dentro de una base de datos Postgres. ¡Vamos allá!

Un flujo de aprendizaje supervisado de extremo a extremo con PostgresML

Antes de empezar: crea una cuenta gratuita en PostgresML

Primero, crea una cuenta gratuita en https://postgresml.org/signup:

Luego, elige el plan gratuito, que ofrece recursos más que generosos:

Tras registrarte, llegarás a tu consola de PostgresML. Aquí es donde gestionas diferentes proyectos de «ML en base de datos» y sus recursos relacionados.

Si vas a la sección «Manage», podrás escalar tu entorno según tus necesidades de cómputo:

1. Instala y configura Postgres

Como su nombre indica, necesitamos tener PostgreSQL instalado en nuestro sistema para usar PostgresML. Si no sabes qué es Postgres, es la base de datos open source más avanzada del mundo (eso dicen en su web).

Aquí tienes guías específicas por plataforma para instalar PostgreSQL:

• Windows
• Mac OS
• Linux

Yo estoy en WSL2, así que puedo hacer:

$ sudo apt update
$ sudo apt install postgresql postgresql-contrib
$ sudo passwd postgres  # Set a new Postgres password
# Close and reopen your terminal and done!

Después, verifica la instalación con:

$ psql --version
psql (PostgreSQL) 12.18 (Ubuntu 12.18-0ubuntu0.20.04.1)

psql es el cliente oficial de Postgres para conectar y administrar bases de datos desde la terminal.

Entiendo que para mucha gente no es ideal ejecutar SQL en terminales «feas», así que también puedes instalar la siguiente extensión de VSCode después de instalar Postgres:

2. Conéctate a una base de datos

¿Recuerdas la página de inicio de tu consola de PostgresML? Déjala abierta en otra pestaña:

Ahora, usando psql, puedes escribir el siguiente comando con tus credenciales para establecer una conexión con el servidor de PostgresML:

$ psql -h "host" \
      -U "username" \
      -p 6432 \
      -d "database_name"

Si usas la extensión de VSCode, sigue estos pasos (tomados de la página de instalación de la extensión) para hacer lo mismo:

1. Abre la paleta de comandos (Ctrl + Shift + P).
2. Busca y selecciona «PostgreSQL: New Query».
3. En la paleta, selecciona «Create Connection Profile». Sigue las instrucciones para introducir el host, la base de datos, el usuario y la contraseña de tu instancia de Postgres.

Y quedarás conectado a tu base de datos de PostgresML.

El siguiente paso es crear la extensión pgml que nos permitirá ejecutar funciones de PostgresML:

CREATE EXTENSION IF NOT EXISTS pgml;

NOTICE:  extension "pgml" already exists, skipping
CREATE EXTENSION
-- Your output may be different.

Comprueba que todo ha ido bien imprimiendo la versión de pgml:

SELECT pgml.version();

2.8.2 (98f114891db58acd472e068c44272b198274b11d)

3. Carga los datos

Ahora, vamos a cargar algunos datos en nuestra base. Para mantenerlo simple, crearemos una única tabla usando el conjunto de datos Diamonds de Kaggle. Puedes descargarlo como CSV desde la web o con el siguiente fragmento en Python:

import seaborn as sns

diamonds = sns.load_dataset("diamonds")
diamonds.to_csv("diamonds.csv", index=False)

Luego, ejecuta el siguiente comando CREATE con el esquema correcto:

CREATE TABLE IF NOT EXISTS diamonds (
   index SERIAL PRIMARY KEY,
   carat FLOAT,
   cut VARCHAR(255),
   color VARCHAR(255),
   clarity VARCHAR(255),
   depth FLOAT,
   table_ FLOAT,
   price INT,
   x FLOAT,
   y FLOAT,
   z FLOAT
)

El comando creará una tabla llamada diamonds que podemos rellenar con las filas del archivo CSV:

INSERT INTO diamonds
   (carat, cut, color, clarity, depth, table_, price, x, y, z)
   FROM '~/full/path/to/diamonds.csv'
   DELIMITER ','
   CSV HEADER;

Por último, imprimimos la cabecera de la tabla para confirmar que el último comando se ejecutó correctamente:

SELECT * FROM diamonds
LIMIT 10;

¡Listo, ya podemos entrenar un modelo!

4. Entrena un modelo

Entrenamiento básico

Entrenar un modelo de machine learning para aprendizaje supervisado se hace con la función pgml.train. Esta es su estructura básica:

SELECT pgml.train(
 project_name => 'Diamond prices prediction',
 task => 'regression',
 relation_name => 'diamonds',
 y_column_name => 'price',
 algorithm => 'xgboost'
);

La sentencia anterior ajusta un regresor XGBoost a la tabla diamonds para predecir precios de diamantes. Verás que el comando es muy rápido (casi instantáneo) a pesar de tener más de 50k filas.

También puedes cambiar de tarea fácilmente. Así es como ajustas un clasificador multiclase (no olvides cambiar el nombre del proyecto):

SELECT pgml.train(
 project_name => 'Diamond cut quality prediction',
 task => 'classification',
 relation_name => 'diamonds',
 y_column_name => 'cut',
 algorithm => 'xgboost',
 test_size => 0.1
);

Fíjate en que esta vez especificamos el argumento test_size; también se admiten particiones personalizadas.

Además, hemos cambiado el algoritmo por defecto (linear) a xgboost, pero podría haber sido cualquier otro modelo de Scikit-learn u otro framework compatible.

Preprocesamiento

Vamos a probar a ajustar ahora un modelo de random forest:

…

¡Un momento! El conjunto diamonds tiene variables de texto que hay que codificar. Como XGBoost codifica categóricas de forma nativa, no recibimos errores en las consultas anteriores. Puede que no sea el caso con random forests. Así que añadamos algunos pasos de preprocesado a nuestra consulta:

SELECT pgml.train(
   project_name => 'Diamond prices prediction',
   task => 'regression',
   relation_name => 'diamonds',
   y_column_name => 'price',
   algorithm => 'random_forest',
   preprocess => '{
       "carat": {"scale": "standard"},
       "depth": {"scale": "standard"},
       "table_": {"scale": "standard"},
       "cut": {"encode": "target", "scale": "standard"},
       "color": {"encode": "target", "scale": "standard"},
       "clarity": {"encode": "target", "scale": "standard"}
   }'::JSONB
);

La lógica de preprocesamiento se define dentro de un objeto JSONB que mapea columnas con pasos de transformación. Para las numéricas, usamos estandarización (aunque no sea imprescindible para RF). Para las categóricas, usamos target encoding y luego estandarización.

PostgresML ofrece otras funciones de preprocesamiento alternativas. Aquí tienes la lista completa de opciones de codificación disponibles:

pgml también admite técnicas estándar de imputación:

Y esta es la lista de escalados disponibles:

Aunque no tienes un abanico tan amplio como en Scikit-learn, esto será suficiente para la mayoría de tareas de aprendizaje supervisado.

Especificar hiperparámetros

Hasta ahora hemos usado los parámetros por defecto. Sin embargo, casi nunca son la mejor opción en problemas reales. Para definir valores personalizados, podemos usar el argumento hyperparams de pgml.train:

SELECT pgml.train(
   project_name => 'Diamond prices prediction',
   task => 'regression',
   relation_name => 'diamonds',
   y_column_name => 'price',
   algorithm => 'xgboost',
   hyperparams => '{
       "n_estimators": 1000, "max_depth": 5, "eta": 0.01, "subsample": 0.7
   }'::JSONB
);

Esta vez ajustamos un regresor XGBoost con 1000 árboles, una profundidad máxima de 5 y una tasa de aprendizaje de 0.01. Ahora mismo estamos «disparando a ciegas», así que estos hiperparámetros pueden no dar los mejores resultados.

Ajuste de hiperparámetros

Para exprimir el modelo al máximo, siempre necesitamos ajustar hiperparámetros en tareas supervisadas. Este proceso también está soportado en pgml dentro de la función train. Así haces una búsqueda en cuadrícula sobre una pequeña selección de combinaciones:

SELECT pgml.train(
   'Diamond prices prediction',
   algorithm => 'xgboost',
   search => 'grid',
   search_params => '{
       "max_depth": [5, 7],
       "n_estimators": [1000, 1500],
       "eta": [0.1, 0.01, 0.001]
   }'::JSONB
);

Llegados a este punto, quiero que valores lo que estamos haciendo. ¡Estamos ajustando los hiperparámetros de un regresor XGBoost usando SQL! Jamás pensé que escribiría esa frase.

5. Evalúa el modelo

En el momento de escribir este tutorial, PostgresML aún no dispone de herramientas de evaluación lo bastante maduras. Solo tenemos disponible la función predict. Así la usas para predecir sobre una muestra individual nueva:

SELECT pgml.predict(
   project_name => 'Diamond prices prediction',
   features => ARRAY[0.7, "Ideal", "A", "IF", 67.9, 56.9, 7024, 5.85, 5.87, 3.71]
);

predict utiliza automáticamente el mejor modelo de tus experimentos. En regresión, será el modelo con mayor R-cuadrado; en clasificación, el de mayor F1.

Para usar un modelo concreto en la predicción, puedes indicar su ID:

SELECT pgml.predict(
  2' -- Use model with ID of 2,
   features => ARRAY[0.7, "Ideal", "A", "IF", 67.9, 56.9, 7024, 5.85, 5.87, 3.71]
)

¿Y cómo encuentras los IDs de los modelos? Aquí tienes un snippet que imprime una tabla con exactamente esa información:

SELECT models.id, models.algorithm, models.metrics
FROM pgml.models
JOIN pgml.projects
 ON projects.id = models.project_id
WHERE projects.name = 'Diamond prices prediction';

Con esta sentencia puedes descubrir muchas variables y métricas de pgml como models.id, pgml.models, pgml.projects, etc. Prueba sentencias SELECT sobre ellas para hacerte una idea de lo que ofrecen.

6. Despliega el modelo

A diferencia del MLOps tradicional, este paso es el más fácil en PostgresML. La extensión pgml expone automáticamente el mejor modelo de tus experimentos como predeterminado. Así, cualquier sentencia SELECT pgml.predict que los usuarios envíen al servidor usará ese modelo para inferencia.

Si quieres un control más fino sobre qué modelo pasa a producción, puedes gestionarlo con la función pgml.deploy. Esta es su estructura:

SELECT * FROM pgml.deploy(
   project_name TEXT,
   strategy TEXT DEFAULT 'best_score',
   algorithm TEXT DEFAULT NULL
)

Además de best_score, también existen las estrategias de despliegue most_recent y rollback:

Combinando los parámetros strategy y algorithm, puedes acotar aún más el despliegue. Por ejemplo, la sentencia siguiente despliega el mejor modelo de XGBoost, no el mejor de todo el proyecto.

SELECT * FROM pgml.deploy(
   project_name => 'Diamond prices prediction',
   strategy => 'best_score',
   algorithm => 'xgboost'
)

¿Qué más puedes hacer con PostgresML?

El aprendizaje supervisado es solo una parte de PostgresML. De hecho, toda su propuesta de valor es «construir aplicaciones de IA en Postgres». Para demostrarlo, incluso han puesto un pequeño editor SQL en la página de inicio:

¡Puedes ejecutar esos ejemplos directamente en el entorno que has usado en este tutorial!

Entonces, si quisieras crear un servicio de machine learning para usuarios finales con PostgresML, ¿cómo lo harías? Aquí tienes algunos pasos posibles (una vez tengas el modelo listo):

1. Construye una interfaz de usuario, probablemente una web. Hoy en día puedes montarla en pocas horas con herramientas como Streamlit y Taipy, diseñadas específicamente para aplicaciones de ML.
2. Implementa un componente de backend en un lenguaje del lado del servidor como Python o Node.js (según cómo construyas tu interfaz).
3. Usa librerías como psycopg2 (Python) o pg-promise (JavaScript) para conectar con tu base de datos PostgresML.
4. Recupera con SQL los datos necesarios para las predicciones desde tus tablas.
5. Realiza en tu backend el preprocesamiento que necesites antes de alimentar el modelo de ML.
6. Cuando el usuario interactúe con la interfaz y dispare una predicción, el servidor de backend recibe la información y se llama a pgml.predict.

Es un esquema general que puede variar bastante según el caso de uso.

Conclusión

PostgresML introduce un paradigma completamente nuevo en machine learning, así que dominarlo requiere algo más que un solo tutorial. Para afianzar lo aprendido y explorar otros usos, lee la sección de casos de uso de la documentación de PostgresML.

Si tienes el SQL un poco oxidado, puedes hacer el curso corto de DataCamp sobre creación de bases de datos PostgreSQL o incluso todo el itinerario profesional de Data Analyst in SQL.

Como PostgresML se centra mucho en IA, también puedes aprender algunos fundamentos de IA:

• Large Language Models Concepts
• How to Build LLM Applications with LangChain
• Fine-tuning LLM Applications