4.4Machine learning e IA : scikit-learn, TensorFlow
Lo esencial en 30 segundos
- ML = aprender desde ejemplos :
fit(X, y)aprende,predictpredice, y se evalúa sobre datos nunca vistos (train_test_split). - Flujo en 5 líneas : split →
LogisticRegressionoRandomForest→fit→score→ matriz de confusión ; baseline simple primero. - Reflejo de Nabil : 100 % en el train y 60 % en producción = evaluado sobre el train — el split no es opcional, y el modelo también aprende los sesgos.
Mini-caso hilado — Nabil predice los impagos
La dirección pide a Nabil, en Argel : « ¿podemos detectar los clientes con riesgo de impago? » En lugar de reglas artesanales, Nabil entrena un RandomForest con scikit-learn sobre el historial : split 80/20 con random_state para la reproducibilidad, fit sobre el train, score sobre el test nunca visto. Primera evaluación sobre el train : 100 % — ilusoria ; sobre el test : 82 % — honesta. Entrega una baseline útil y documentada, con una auditoría de sesgos antes de toda decisión. Cuarto hito del hilo : del analista que describe al modelo que predice — con prudencia.
Continuación de los casos 4.1-4.3 — Nabil predice desde sus datos históricos.
1. Aprender desde ejemplos + el split sagrado
El machine learning sustituye las reglas programadas a mano por una regla aprendida desde ejemplos etiquetados : fit(X, y) entrena, predict predice sobre lo nuevo. La regla de oro : evaluar sobre datos nunca vistos con train_test_split — si no, medimos la memoria, no el aprendizaje. Nabil lo aprende por las malas : 100 % sobre el train, 82 % sobre el test — solo la segunda cifra cuenta. random_state fijado = resultado reproducible.
2. scikit-learn primero, deep learning después
scikit-learn cubre el 80 % de las necesidades de negocio tabulares sin GPU : LogisticRegression, RandomForestClassifier, misma API fit/predict/score, matriz de confusión para leer los errores. Baseline simple primero, complicar solo si lo simple falla. El deep learning (TensorFlow, PyTorch, redes neuronales, GPU) entra en juego para imágenes, texto y audio — con la regla de oro : partir de modelos preentrenados (Hugging Face) y ajustarlos, nunca desde cero. Y la ética : el modelo aprende los prejuicios de los datos — Nabil audita los sesgos antes de toda decisión automatizada.
🔎 Ejemplo concreto — 🔎 Ejemplo concreto — La baseline de Nabil
El flujo completo, con las API reales de scikit-learn :
Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.2, random_state=0)
modele = RandomForestClassifier().fit(Xtr, ytr) # aprende
print(modele.score(Xte, yte)) # ~0.96 : evaluado sobre nunca vistos
Regla → 100 % en el train + 60 % en producción = fuga del splitLectura : split, fit, score — tres líneas, cero magia.
Lección : random_state = resultado reproducible y discutible.
Vocabulario de la sección
- Machine learning
- Aprender una regla desde ejemplos etiquetados (fit) y luego predecir sobre lo nuevo (predict), en lugar de programar reglas a mano.
Ejemplo sencillo: Nabil predice los impagos desde el historial en lugar de umbrales artesanales.
Lo que no es: reglas si/entonces programadas una por una.
Reflejo: ¿datos etiquetados en cantidad? considerar el ML.
- Train/test split
- Separar los datos : aprender sobre el train, evaluar sobre el test nunca visto — si no, medimos la memoria, no el aprendizaje.
Ejemplo sencillo: Nabil : 100 % en el train (memoria), 82 % en el test (realidad).
Lo que no es: evaluar el modelo sobre sus propios ejemplos de entrenamiento.
Reflejo: split sistemático, random_state fijado.
- scikit-learn (fit/predict)
- Biblioteca ML tabular ideal para empezar : API única fit/predict/score, sin GPU, baseline en 5 líneas.
Ejemplo sencillo: El RandomForest de Nabil en tres líneas : split, fit, score.
Lo que no es: una red neuronal GPU para una tabla de clientes.
Reflejo: baseline simple primero, complicar si hace falta.
- Deep learning / preentrenados
- Redes neuronales (TensorFlow, PyTorch, GPU) para imágenes/texto/audio ; se parte de modelos preentrenados que se ajustan, nunca desde cero.
Ejemplo sencillo: Nabil añadirá un modelo preentrenado para leer opiniones de clientes, no una red casera.
Lo que no es: entrenar un gigante desde cero en su portátil.
Reflejo: ¿imagen/texto/audio? preentrenado + ajuste.
En la práctica — En práctica — Entrenar una baseline
- Cargad un juego tabular etiquetado (p. ej. load_iris o vuestros propios datos históricos limpiados).
- Separad con train_test_split (test_size=0.2, random_state fijado) : el test queda intacto hasta la evaluación.
- Entrenad una baseline (LogisticRegression o RandomForestClassifier) : fit solo sobre el train.
- Evaluad sobre el test (score + matriz de confusión), comparad con la puntuación del train y anotad sesgos y límites antes de toda decisión.
Guion listo para decir — presentar su modelo (30 s)
« Soy Nabil : baseline RandomForest, 82 % sobre datos nunca vistos — no 100 % en el train, eso es memoria. Matriz de confusión leída, sesgos auditados : el modelo ayuda a la decisión, no la sustituye. »
Para decir en comité ; mostrad la matriz, no solo la puntuación.
Modelo copiar-pegar — baseline scikit-learn (código probado)
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import confusion_matrix
X, y = load_iris(return_X_y=True)
Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.2, random_state=0)
modele = RandomForestClassifier(random_state=0)
modele.fit(Xtr, ytr) # aprende solo sobre el train
print("train :", modele.score(Xtr, ytr)) # memoria (referencia)
print("test :", modele.score(Xte, yte)) # aprendizaje (cifra real)
print(confusion_matrix(yte, modele.predict(Xte)))
Primer modelo
Un juego simple (iris), una baseline, un split : comprended fit/predict antes de tocar vuestros datos.
Datos tabulares
Como Nabil : scikit-learn basta en el 80 % de los casos de negocio — sin GPU ni deep learning.
Imagen o texto
Pasad a TensorFlow/PyTorch vía modelos preentrenados por ajustar, nunca entrenados desde cero.
Decisión sensible
Crédito, contratación, salud : auditad los sesgos, mantened al humano como decisor, documentad los límites.
✓ Buenas prácticas
- Split siempre : evaluar sobre nunca vistos.
- Baseline simple primero, complicar si hace falta.
- Auditar sesgos y límites antes de decidir.
✗ Errores frecuentes
- Evaluar sobre el train (100 % ilusorio).
- Sacar el deep learning para una tabla.
- Ignorar los sesgos aprendidos de los datos.
Puntos clave
- ML = PATRONES aprendidos desde ejemplos (fit → predict), no reglas programadas.
- API SKLEARN : fit()/predict()/score() ; SPLIT train/test OBLIGATORIO.
- BASELINE simple primero (Logit, RandomForest) : 80 % del negocio sin GPU.
- DEEP = redes neuronales (imágenes/texto) vía PREENTRENADOS ; sesgos por auditar.
Reto 48h — aplica mañana
Entrenad 1 baseline sobre un juego tabular : split 80/20, fit, puntuación en test + matriz de confusión leída y comentada.
- Puedo citar fit/predict y el split train/test.
- Sé explicar la trampa del 100 % en el train.
- Tengo 1 baseline evaluada sobre nunca vistos.
Preguntas frecuentes
¿Hacen falta matemáticas antes de hacer ML?
No para una primera baseline scikit-learn : el flujo (split, fit, score) se aprende en la práctica. Sí después : estadística y álgebra para elegir un modelo, ajustar sus parámetros y entender sus errores. Nabil avanza por etapas : baseline útil primero, teoría al hilo de los límites encontrados.
¿scikit-learn o TensorFlow para empezar?
scikit-learn sin dudar : tabular, CPU, API única, resultados en 5 líneas — 80 % de las necesidades de negocio. TensorFlow o PyTorch después, para imágenes, texto y audio vía modelos preentrenados por ajustar. El deep learning para una tabla de clientes es un camión para entregar una carta.
¿Qué biblioteca para empezar en machine learning?