Cerramos el módulo 4 con una constatación: en todo lo que llevamos de curso, el conocimiento del problema lo hemos aportado nosotros a mano. Diseñamos las reglas de optimización del módulo 2, medimos los pesos del grafo del módulo 3, justificamos los invariantes y las heurísticas del módulo 4. Pero Rutalia acumula millones de registros históricos de entregas —hora, zona, peso, distancia, retraso, incidencias— que contienen patrones que nadie ha escrito nunca como regla. En esta lección damos el cambio de paradigma: en lugar de programar las reglas, dejaremos que los algoritmos las aprendan de los datos. Veremos qué significa exactamente "aprender", qué tipos de aprendizaje existen, definiremos el dataset canónico de Rutalia que usaremos en todo el módulo, recorreremos el flujo de trabajo completo (entrenar, evaluar, no engañarse) y construiremos nuestro primer modelo de principio a fin: un clasificador k-NN implementado a mano para predecir si una entrega llegará tarde.

1. Reglas escritas vs reglas aprendidas
2. Tipos de aprendizaje automático
3. El dataset canónico de Rutalia
4. El flujo de trabajo: entrenar, evaluar, generalizar
5. Sobreajuste e infraajuste: memorizar no es aprender
6. Validación cruzada y métricas (adelanto)
7. Preparación de datos: variables categóricas y escalado
8. Primer modelo completo: k-NN a mano y con scikit-learn

Comparemos cómo hemos resuelto problemas hasta ahora con cómo los resolveremos en este módulo:

La pregunta "¿cuánto tardará esta entrega?" ilustra el cambio. Con Dijkstra (03-03) obtenemos el tiempo de trayecto según los pesos que medimos. Pero el tiempo real depende de factores que no están en el grafo: la hora punta, el peso del paquete (buscar aparcamiento con 20 kg no es lo mismo que con 200 g), si es viernes, si la zona MER tiene mercado ese día... Nadie en Rutalia sabe escribir esa fórmula. Los datos históricos, en cambio, la contienen.

Formalmente, en aprendizaje supervisado buscamos una función f tal que f(x) ≈ y, donde x es un vector de características (features) de un ejemplo e y es la respuesta conocida. El "algoritmo de aprendizaje" es el procedimiento que, dado un conjunto de pares (x, y), construye esa f. Fíjate: seguimos en un curso de algoritmos. Un algoritmo de aprendizaje es un algoritmo como cualquier otro —con su complejidad, sus estructuras de datos y sus invariantes— cuya salida es otra función.

El aprendizaje por refuerzo —un agente que actúa, recibe recompensas y ajusta su comportamiento— es la base de los sistemas que juegan a Go o controlan robots, pero queda fuera de este curso; nos concentraremos en supervisado (05-01 a 05-04) y no supervisado (05-05).

Igual que el módulo 2 tuvo su instancia canónica del TSP (óptimo 35,22 km) y el módulo 3 su grafo de 9 zonas, este módulo tendrá su dataset canónico de entregas. Cada fila es una entrega histórica:

Unas filas de muestra (clientes identificados solo por un id ficticio):

Como no podemos adjuntar millones de filas a una lección, usaremos un generador sintético con semilla fija: todo el módulo trabajará exactamente con los mismos datos, reproducibles en tu máquina. El generador esconde una "verdad" (la fórmula que produce los minutos) que nuestros modelos intentarán descubrir sin conocerla. Nosotros sí la conocemos porque la escribimos, y eso nos permitirá juzgar si un modelo aprende bien.

Puntos importantes del generador:

• Semilla 42: default_rng(42) garantiza que tú y esta lección veáis los mismos números. La reproducibilidad es una práctica central en ML.
• La verdad oculta es multiplicativa y no lineal (congestión × hora punta × peso): ningún modelo lineal la capturará perfectamente, lo cual dará juego en 05-03 y 05-04.
• El ruido gaussiano representa lo irreducible: dos entregas idénticas nunca tardan exactamente lo mismo. Ningún modelo debería (ni podrá) predecirlo — intentarlo es, precisamente, sobreajustar.
• Los retrasos son minoría (en torno al 15-20%): las clases están desbalanceadas, algo que explotaremos en 05-02 al hablar de métricas.

El error clásico del recién llegado es evaluar el modelo con los mismos datos con los que lo entrenó. Un modelo que memoriza el conjunto de entrenamiento saca un 100% en ese examen... porque ya conocía las respuestas. Lo que importa es cómo se comporta con entregas que nunca ha visto: a eso se le llama generalizar.

El protocolo mínimo:

Barajar es esencial: si los datos vinieran ordenados por fecha o por zona, el test contendría solo un tipo de entregas y la evaluación quedaría sesgada. Y el conjunto de test es sagrado: no se toca hasta el final, ni para elegir parámetros ni para "echar un vistazo". Cada vez que una decisión tuya depende del test, el test deja der ser una estimación honesta.

Todo modelo tiene una "capacidad": cuánta complejidad puede representar. El equilibrio es delicado:

• Infraajuste (underfitting): el modelo es demasiado simple para el patrón. Ejemplo: predecir los minutos de entrega con la media global (~35 min para todos). Falla en entrenamiento y en test.
• Sobreajuste (overfitting): el modelo es tan flexible que memoriza el ruido del entrenamiento. Ejemplo extremo: una tabla hash (01-04) que guarda cada entrega histórica y devuelve sus minutos exactos. Error cero en entrenamiento, desastre con entregas nuevas.

Podemos visualizarlo con k-NN, el modelo que construiremos al final. k-NN con k=1 responde copiando la entrega histórica más parecida: memoriza, ruido incluido. Con k=n (todas las entregas) responde siempre la mayoría global: infraajusta. El buen k está en medio:

Con k=1 el error de entrenamiento es 0 (tu vecino más cercano eres tú mismo) pero el de test es alto. Al crecer k ambos se acercan hasta que, pasado el punto óptimo, los dos suben: el modelo ya no distingue nada. Esta curva en U del error de test aparece en todos los modelos del módulo; en 05-03 la formalizaremos como el trade-off sesgo-varianza.

Si el test es sagrado, ¿con qué datos elegimos k? Reservar otra partición (validación) funciona, pero desperdicia datos. La solución estándar es la validación cruzada de K pliegues (K-fold): partir el entrenamiento en K trozos, entrenar K veces dejando cada vez un trozo fuera como validación, y promediar los K errores.

Cada ejemplo se usa K−1 veces para entrenar y 1 vez para validar: aprovechamos todos los datos y la estimación es más estable que la de una sola partición. El coste: entrenar K veces — un trade-off tiempo/fiabilidad muy del estilo de este curso.

Sobre métricas, cada problema tiene las suyas y las desarrollaremos donde tocan: matriz de confusión, precisión/recall/F1 y ROC para clasificación (05-02); MSE, RMSE, MAE y R² para regresión (05-03); inercia y silueta para clustering (05-05). Por ahora usaremos la más simple, la exactitud (accuracy): fracción de aciertos. Y adelantamos ya su trampa: si el 85% de las entregas de Rutalia son puntuales, un "modelo" que siempre responde "puntual" acierta el 85% sin haber aprendido nada. En 05-02 la destriparemos.

Los algoritmos de ML operan con vectores numéricos, y nuestro dataset tiene una columna categórica (zona) y columnas numéricas de escalas muy distintas. Dos transformaciones imprescindibles:

zona no es un número. Codificarla como ALM=0, MER=1, ..., PAR=8 inventaría un orden y una distancia falsos (¿MER está "entre" ALM y EST? ¿PAR está "8 veces más lejos" que ALM?). La solución es el one-hot: una columna binaria por categoría.

Así, la distancia entre dos zonas distintas cualesquiera es siempre la misma, sin orden espurio.

Nuestro primer modelo, k-NN, decide por distancia euclídea entre entregas. Observa las escalas: distancia_km va de 0.5 a 8, pero hora_salida va de 8 a 20. Una diferencia de 6 horas (¡mediodía vs noche, crucial para el retraso!) pesa en la distancia lo mismo que 6 km. Y si midiéramos el peso en gramos, esa columna aplastaría a todas las demás. La geometría del espacio dependería de las unidades — una decisión arbitraria que el modelo no debería heredar.

La estandarización lo corrige: a cada columna se le resta su media y se divide por su desviación típica, dejándolas todas con media 0 y desviación 1.

Detalle crucial: la media y la desviación se calculan solo con el entrenamiento. Si usáramos también el test, información del test se "filtraría" al modelo (data leakage) y la evaluación dejaría de ser honesta. Es la versión sutil del pecado de evaluar con datos de entrenamiento.

k vecinos más cercanos (k-NN) es el algoritmo perfecto para empezar porque es pura algoritmia de este curso: distancias + selección de los k menores. La idea: para predecir si una entrega nueva llegará tarde, busca las k entregas históricas más parecidas y vota lo que ellas hicieron.

No hay "entrenamiento" real: el modelo es el dataset. Todo el trabajo ocurre al predecir. Para seleccionar los k menores usamos un heap (01-04): heapq.nsmallest corre en O(n log k), mejor que ordenar todo en O(n log n).

Montemos el pipeline completo — codificar, partir, escalar, evaluar:

Compara siempre con el modelo trivial: si tu k-NN no lo supera con claridad, no ha aprendido nada útil. Con este dataset, k-NN debería superarlo con holgura, porque el retraso depende fuertemente de distancia, zona y hora — y los vecinos cercanos en ese espacio comparten destino.

Y la versión con scikit-learn, la biblioteca estándar, que hace lo mismo con validaciones y optimizaciones industriales:

Fíjate en el patrón fit/transform/predict: fit aprende de los datos (los parámetros del escalador, o el modelo), transform/predict aplican lo aprendido. Toda la API de scikit-learn sigue este contrato, lo que ayuda a evitar fugas de información.

En este módulo mantendremos siempre la doble vía: implementar a mano la mecánica esencial (esto es un curso de algoritmos) y luego usar scikit-learn como herramienta de trabajo, verificando que ambos coinciden.

• Evaluar con los datos de entrenamiento. Es el error número uno. Un 99% de exactitud "en train" no dice nada; solo cuenta el rendimiento sobre datos nunca vistos.
• Escalar antes de partir. Si calculas media y desviación con todo el dataset, filtras información del test al modelo. Orden correcto: partir → ajustar transformaciones con train → aplicar a ambos.
• Codificar categorías como enteros ordenados. ALM=0...PAR=8 inventa distancias inexistentes y confunde a cualquier algoritmo basado en distancia. Usa one-hot.
• Olvidar el modelo trivial de referencia. Con clases desbalanceadas, una exactitud del 85% puede significar exactamente cero aprendizaje. Calcula siempre qué saca el "siempre mayoría".
• No fijar semillas. Sin random_state/semilla, cada ejecución da resultados distintos y es imposible depurar o comparar. Fija semillas en particiones y generadores.
• Consejo: desconfía de los resultados demasiado buenos. Una exactitud del 100% casi siempre delata una fuga de datos (una feature que "contiene" la respuesta, o un test contaminado), no un modelo genial.

1. La curva en U de k. Con el dataset canónico (semilla 42), evalúa el k-NN manual para k ∈ {1, 3, 7, 15, 31, 61, 121, 501} sobre el conjunto de test. Imprime la exactitud de cada k y localiza la zona buena. ¿Qué pasa con k=1? ¿Y con k=501? Explica ambos extremos en términos de sobreajuste/infraajuste.

2. El desastre de las unidades. Repite la evaluación de k-NN (k=15) con dos variantes: (a) sin estandarizar nada, y (b) sin estandarizar y con peso_kg convertido a gramos (multiplica esa columna por 1000). Compara las tres exactitudes (estandarizado, crudo, gramos) y explica por qué la versión en gramos se hunde hacia el modelo trivial.

3. Validación cruzada manual. Implementa cv_5fold(X, y, k) que parta el conjunto de entrenamiento en 5 pliegues, entrene/evalúe 5 veces el k-NN manual y devuelva la exactitud media. Úsala para elegir el mejor k de {5, 15, 45} sin tocar el test, y solo al final evalúa el k elegido sobre el test.

Ejercicio 1:

Con k=1 la exactitud de test baja respecto a la zona buena: cada predicción copia a un único vecino, ruido incluido (sobreajuste; sobre el propio train sacaría 1.0). Con k=501 se promedia sobre un tercio del dataset y el modelo tiende al voto de la mayoría global (infraajuste). Los valores intermedios (≈7-61) forman el valle de la U.

Ejercicio 2:

En crudo, hora_salida (rango ~12) domina sobre las columnas one-hot (rango 1) y el resultado ya se degrada. En gramos, la columna de peso presenta diferencias de miles mientras las demás varían en unidades: la distancia euclídea se convierte, en la práctica, en "diferencia de peso"; y como el peso apenas determina el retraso, k-NN cae hacia el modelo trivial. Moral: las unidades son arbitrarias y no deben decidir la geometría — por eso se estandariza.

Ejercicio 3:

Nota el detalle: la estandarización se ajusta dentro de cada pliegue con su parte de entrenamiento — el mismo principio anti-fugas de siempre, aplicado recursivamente. El test se usa una sola vez, con el k ya decidido.

Hemos cruzado la frontera del curso: de escribir reglas a aprenderlas. Ahora sabes qué es un modelo (una función aprendida de ejemplos), qué tipos de aprendizaje existen, y sobre todo conoces el protocolo que lo sostiene todo: separar train y test, escalar sin fugas, validar en cruz y desconfiar de la exactitud sin contexto. Definimos el dataset canónico de Rutalia —2000 entregas sintéticas con semilla 42— que nos acompañará todo el módulo, y construimos un primer clasificador completo, k-NN, que en el fondo es algoritmia pura: distancias euclídeas y un heap para los k menores. Pero k-NN tiene límites serios (paga O(n·d) por cada predicción y sufre en alta dimensión), y la clasificación da para mucho más. En la siguiente lección, 05-02, exploraremos el catálogo de clasificadores —árboles de decisión, random forest, Naive Bayes, regresión logística— y aprenderemos a medirlos en serio, porque con un 85% de entregas puntuales, la exactitud es una métrica que engaña.