Video: Tu primer modelo de Machine Learning en Python
Los videos y el texto de esta sesión son complementarios. Los videos amplían el contexto histórico y conceptual; el texto va a los mecanismos y te pone a interactuar con ellos. Encontrarás ideas en los videos que el texto no repite exactamente. ¡Disfruta de esta dinámica!
En la sesión 3 describimos cómo funciona un algoritmo árbol de decisión: el modelo hace preguntas binarias [sí/no] sobre los datos hasta llegar a una respuesta.
Ahora vamos a hacer exactamente lo mismo, pero con Python 🐍. No es necesario memorizar el código, la idea es que puedas comprender qué hace cada línea y conectarla con conceptos que ya conoces.
Describimos el árbol de decisión (Random Forest) como el juego de las 20 preguntas: el modelo hace preguntas [sí = 1/no = 0] sobre los datos hasta llegar a una respuesta. Hoy, Python va a construir ese árbol automáticamente a partir de miles de ejemplos etiquetados.
Antes de pasar al código, vamos a familiarizarnos con el flujo de un modelo de machine learning (aprendizaje de máquinas). Cada sección del experimento corresponde a uno de estos pasos.
Estos cinco pasos son universales. Un modelo que detecta tumores en radiografías, uno que predice el precio de una casa o uno que reconoce tu voz siguen exactamente este mismo flujo.
Imagina que estudias para un examen con una guía de estudio: cada pregunta tiene una respuesta. Si el día del examen el profesor usa exactamente las mismas preguntas, sacas diez — pero eso no significa que aprendiste. Solo memorizaste las respuestas.
Con los modelos de machine learning pasa exactamente lo mismo. Si entrenamos con las mismas imágenes que usamos para evaluar, el modelo puede “recordar” las respuestas correctas sin haber aprendido nada útil para imágenes nuevas.
La solución es siempre la misma: separar los datos antes de empezar.
Nunca uses los datos de prueba durante el entrenamiento. La precisión que obtienes al final solo tiene sentido si el modelo no vio esas imágenes antes.
El conjunto de datos que usaremos se llama digits. Contiene 1,797 imágenes en escala de grises de dígitos escritos a mano (del 0 al 9), cada una de 8×8 píxeles. Es pequeño, claro y perfecto para un primer experimento.
Primero observa cómo se ven algunos de estos dígitos:
import os
os.environ["MPLCONFIGDIR"] = "/tmp/mplconfig"
import matplotlib.pyplot as plt
from sklearn.datasets import load_digits
digits = load_digits()
fig, axes = plt.subplots(2, 5, figsize=(8, 4))
for ax, image, label in zip(axes.flat, digits.images[:10], digits.target[:10]):
ax.imshow(image, cmap="gray_r")
ax.set_title(f"Etiqueta: {label}", fontsize=10)
ax.axis("off")
plt.tight_layout()
plt.show()
Cada imagen es una cuadrícula de 8×8 = 64 valores numéricos entre 0 (blanco) y 16 (negro). Eso es lo que el árbol de decisión va a analizar para decidir qué dígito es cada imagen.
Para escribir y ejecutar Python no necesitas instalar nada. Google Colab es un cuaderno de código que corre directo en el navegador.
mi_modelo.ipynb
● Conectado
Sesión 12: vamos a construir un árbol de decisión que reconoce dígitos escritos a mano.
# Cargar datos y entrenar el árbol from sklearn.datasets import load_digits from sklearn.tree import DecisionTreeClassifier print("Listo para reconocer números")
colab.research.google.com → Necesitas una cuenta de Google. Crea un cuaderno nuevo desde “Archivo → Nuevo notebook” y copia el código de esta sesión.
No necesitas conocer todo el lenguage de Python para entender este experimento. Estas cuatro piezas son suficientes.
Una 'variable' guarda un valor para reutilizarlo después. digits, modelo y score son todas variables.
modelo = DecisionTreeClassifier()
Los paréntesis () indican que se ejecuta una acción. load_digits() carga datos. modelo.fit() entrena el árbol.
modelo.fit(X_train, y_train)
X_test[12] significa: dame el ejemplo número 12 del grupo de prueba. Los corchetes [ ] sirven para elegir elementos.
imagen = X_test[12]
Todo lo que quieras ver pasa por print(). Úsalo para inspeccionar la precisión, la predicción o cualquier variable.
print(score)
Con los cinco pasos del flujo de ML en mente y el Python mínimo claro, ya puedes leer el experimento completo. Haz clic en cualquier línea para ver qué hace exactamente.
Tres ventanas para ver el modelo funcionar: primero una predicción concreta, luego la estructura interna del árbol, y finalmente el rendimiento global.
1 · Una predicción
import os
os.environ["MPLCONFIGDIR"] = "/tmp/mplconfig"
import matplotlib.pyplot as plt
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
digits = load_digits()
X_train, X_test, y_train, y_test = train_test_split(
digits.data,
digits.target,
test_size=0.25,
random_state=42,
stratify=digits.target,
)
modelo = DecisionTreeClassifier(max_depth=10, random_state=42)
modelo.fit(X_train, y_train)
score = modelo.score(X_test, y_test)
indice = 12
real = y_test[indice]
prediccion = modelo.predict([X_test[indice]])[0]
resultado = "✓ Acertó" if prediccion == real else f"✗ Se equivocó (predijo {prediccion})"
fig, ax = plt.subplots(figsize=(3.5, 3.5))
ax.imshow(X_test[indice].reshape(8, 8), cmap="gray_r")
ax.set_title(f"Dígito real: {real}\n{resultado}", fontsize=11, pad=10)
ax.axis("off")
plt.tight_layout()
plt.show()
print(f"Precisión global: {score:.3f} ({int(score * 450)}/450 imágenes de prueba)")
Precisión global: 0.836 (376/450 imágenes de prueba)Una sola predicción dice poco: el árbol acierta el ~85% de las veces y se equivoca en el resto. Lo importante es entender el patrón de errores, que veremos a continuación con una matriz de confusión. Pero primero, visualicemos árbol.
2 · El árbol de decisión: las preguntas que hace el modelo
Aquí está lo que construyó Python. Cada nodo hace una pregunta sobre el valor de un píxel: si la respuesta es sí (≤ umbral), el árbol va a la izquierda; si no, va a la derecha. El árbol completo tiene 10 niveles — aquí mostramos los primeros 3 para que sean legibles.
import matplotlib.pyplot as plt
import matplotlib.patches as mpatches
import numpy as np
# ── Estructura del árbol ─────────────────────────────────────────────────
tree_ = modelo.tree_
def node_info(nid):
feat = int(tree_.feature[nid])
thr = tree_.threshold[nid]
cl = int(np.argmax(tree_.value[nid][0]))
return cl, f"pix[{feat//8},{feat%8}] ≤ {thr:.0f}?", f"clase: {cl}"
n0 = 0
n1L = tree_.children_left[n0]; n1R = tree_.children_right[n0]
n2LL = tree_.children_left[n1L]; n2LR = tree_.children_right[n1L]
n2RL = tree_.children_left[n1R]; n2RR = tree_.children_right[n1R]
_, q0, _ = node_info(n0)
_, q1L, _ = node_info(n1L)
_, q1R, _ = node_info(n1R)
_, _, c2LL = node_info(n2LL)
_, _, c2LR = node_info(n2LR)
_, _, c2RL = node_info(n2RL)
_, _, c2RR = node_info(n2RR)
# ── Colores ──────────────────────────────────────────────────────────────
CB = "#6495ED" # cornflower blue — bordes y texto
GRN = "#228B22" # forest green — ✓ Sí
AMB = "#F59E0B" # amber — ✗ No
# ── Posiciones ───────────────────────────────────────────────────────────
L0X, L0Y = 0.50, 0.86
L1X, L1Y = [0.25, 0.75], 0.52
L2X, L2Y = [0.12, 0.38, 0.62, 0.88], 0.13
DW, DH = 0.27, 0.17 # nodo decisión
LW, LH = 0.21, 0.16 # nodo hoja
# ── Figura — tamaño controlado por fig-width / fig-height del chunk ──────
fig, ax = plt.subplots()
ax.set_xlim(0, 1); ax.set_ylim(0, 1); ax.axis("off")
def box(cx, cy, w, h, text, fs=9.5):
ax.add_patch(mpatches.FancyBboxPatch(
(cx-w/2, cy-h/2), w, h, boxstyle="round,pad=0.02",
facecolor="white", edgecolor=CB, linewidth=2,
transform=ax.transAxes, zorder=3))
ax.text(cx, cy, text, ha="center", va="center", fontsize=fs,
color=CB, transform=ax.transAxes, zorder=4, fontweight="bold")
def arrow(x1, y1, x2, y2, col):
ax.annotate("", xy=(x2, y2), xytext=(x1, y1),
xycoords="axes fraction", textcoords="axes fraction",
arrowprops=dict(arrowstyle="-|>", color=col, lw=1.8))
# ── Nodos ────────────────────────────────────────────────────────────────
box(L0X, L0Y, DW, DH, q0, fs=10.5)
box(L1X[0], L1Y, DW, DH, q1L, fs=9.5)
box(L1X[1], L1Y, DW, DH, q1R, fs=9.5)
for xi, lbl in zip(L2X, [c2LL, c2LR, c2RL, c2RR]):
box(xi, L2Y, LW, LH, lbl, fs=11)
# ── Flechas ──────────────────────────────────────────────────────────────
arrow(L0X, L0Y-DH/2, L1X[0], L1Y+DH/2+0.01, GRN)
arrow(L0X, L0Y-DH/2, L1X[1], L1Y+DH/2+0.01, AMB)
arrow(L1X[0], L1Y-DH/2, L2X[0], L2Y+LH/2+0.01, GRN)
arrow(L1X[0], L1Y-DH/2, L2X[1], L2Y+LH/2+0.01, AMB)
arrow(L1X[1], L1Y-DH/2, L2X[2], L2Y+LH/2+0.01, GRN)
arrow(L1X[1], L1Y-DH/2, L2X[3], L2Y+LH/2+0.01, AMB)
# ── Etiquetas Sí / No ────────────────────────────────────────────────────
kw = dict(transform=ax.transAxes, ha="center", fontsize=9, fontweight="bold")
mid01 = (L0Y + L1Y) / 2 + 0.02
ax.text(L0X - 0.15, mid01, "✓ Sí", color=GRN, **kw)
ax.text(L0X + 0.15, mid01, "✗ No", color=AMB, **kw)
mid12 = (L1Y + L2Y) / 2 + 0.02
ax.text((L1X[0]+L2X[0])/2 - 0.02, mid12, "✓ Sí", color=GRN, **kw)
ax.text((L1X[0]+L2X[1])/2 + 0.02, mid12, "✗ No", color=AMB, **kw)
ax.text((L1X[1]+L2X[2])/2 - 0.02, mid12, "✓ Sí", color=GRN, **kw)
ax.text((L1X[1]+L2X[3])/2 + 0.02, mid12, "✗ No", color=AMB, **kw)
ax.set_title("Árbol de decisión: niveles 0–2 de 10", fontsize=11, pad=12)
plt.tight_layout()
plt.show()
Cada recuadro azul es un punto de decisión. El árbol revisa el valor de un píxel específico de la imagen (en una cuadrícula de 8×8) y hace una pregunta binaria:
Los nodos del fondo son el resultado de seguir esas dos ramas dos veces: muestran el dígito (clase 0–9) que el modelo predice si una imagen llega hasta ese punto.
Este diagrama solo muestra los primeros 3 niveles. El árbol real tiene 10 en total — después de esas 10 preguntas, el modelo da su predicción final.
Esto es el árbol de decisión que describimos en la sesión 3, construido automáticamente por Python a partir de 1,347 ejemplos. Cada umbral (el número después de ≤) fue elegido por el algoritmo para separar mejor los dígitos durante el entrenamiento.
3 · ¿Dónde acierta y dónde se confunde? La matriz de confusión
import matplotlib.pyplot as plt
from sklearn.metrics import ConfusionMatrixDisplay
fig, ax = plt.subplots()
ConfusionMatrixDisplay.from_estimator(
modelo,
X_test,
y_test,
ax=ax,
colorbar=False,
cmap="Blues",
)
ax.set_title("Matriz de confusión")
plt.tight_layout()
plt.show()
La matriz tiene 10 filas y 10 columnas (una por cada dígito, del 0 al 9). Para leer cualquier celda usa esta regla:
Fila = el dígito que realmente era la imagen escrita a mano.
Columna = lo que el modelo predijo que era.
Número en la celda = cuántas veces ocurrió esa combinación exacta.
Los aciertos: la diagonal
Todas las celdas donde fila = columna son aciertos. El modelo predijo el dígito correcto.
Los errores: todo lo que está fuera de la diagonal
Cada celda fuera de la diagonal es un tipo de error específico.
Cómo encontrar el error más común del modelo:
Vamos a intentar mejorar nuestro modelo. Queremos que acierte más del ~84% de las veces. Lo que intentaremos hacer es cambiar los parámetros del modelo. A cada modificación le denominaremos experimento. Cada experimento tiene un objetivo claro — no hace falta dominar todo el código completo para aprender algo valioso.
Experimento A · ¿Cuántas preguntas necesita el árbol?
El parámetro max_depth controla el número máximo de preguntas que puede hacer el árbol antes de dar una respuesta. Busca la línea DecisionTreeClassifier(max_depth=10, ...) y prueba estos valores uno por uno, corriendo el código completo cada vez:
| Valor | Qué significa | Precisión esperada |
|---|---|---|
max_depth=2 |
Solo 2 preguntas — árbol muy simple | ~50–65 % |
max_depth=5 |
5 preguntas — árbol moderado | ~75–80 % |
max_depth=10 |
El original | ~85 % |
max_depth=None |
Sin límite — el árbol crece todo lo que pueda | ¿sube o baja? |
Un árbol sin max_depth puede memorizar cada imagen de entrenamiento en vez de aprender reglas generales — como estudiar copiando las respuestas de la guía sin entender nada. En entrenamiento funciona perfectamente; con imágenes nuevas, falla. Eso se llama sobreajuste.
Pregunta: ¿Por qué un árbol con solo 2 preguntas acierta tan poco? ¿Y por qué quitarle el límite del todo tampoco mejora mucho?
Experimento B · Dale nombre a un error de la matriz
La matriz de confusión te dice qué pares de dígitos confunde el modelo. Ahora vas a encontrar ese error en una imagen :
indice = 12 y cámbiala por números entre 0 y 449 hasta que el modelo cometa ese error exacto — que prediga el dígito incorrecto que encontraste en el paso 1.Pregunta: ¿Esos dos dígitos se parecen visualmente cuando alguien los escribe a mano? ¿Crees que un humano también los confundiría?
Experimento C · ¿Qué pasa si el árbol aprende con menos datos?
Busca la línea test_size=0.25 y cámbiala por test_size=0.5. Esto mueve el 50 % de las imágenes al grupo de prueba — el árbol aprende solo con las 898 imágenes restantes en vez de las 1,347 originales.
Pregunta: ¿Sube o baja la precisión? ¿Por qué crees que tener menos imágenes de entrenamiento cambia el resultado?
Pega unas pocas líneas y pide que te las traduzca a lenguaje natural. Más útil que buscar en Google.
Pega el mensaje exacto del error y tu código. La IA puede identificar qué salió mal mucho más rápido que intentarlo a ciegas.
Cuando ya entiendes el experimento, puedes preguntarle a la IA qué efecto tendrá cambiar un parámetro antes de correrlo.
De machine learning
De Python
max_depth, test_size) puede cambiar el resultado por completo.Cuadernos de Python en el navegador, sin instalar nada. El lugar más fácil para empezar a experimentar.
Kaggle
Lecciones cortas con ejercicios interactivos en el navegador. El mejor punto de partida para aprender Python desde cero.
Kaggle
Aprende más sobre modelos de ML. Extiende exactamente lo que hicimos hoy en esta sesión.
Harvard / edX
Curso completo de Python para principiantes, estructurado y riguroso. Para cuando quieras ir más allá de los experimentos.
Tu primer modelo en Python no aprendió porque alguien le escribió reglas a mano, sino porque encontró patrones en ejemplos etiquetados. Lo importante de esta sesión no fue memorizar código, sino entender que entrenar, probar y ajustar un modelo también es una forma de pensar.