Machine & Deep Learning

Lánzate a Python scikit-learn: tu primer paso concreto hoy

Python scikit Learn: lo esencial en un artículo — código real, diagramas y pasos concretos, extractos de un curso de 33 lecciones.

REHOUMA Haythem

12 Jun 2026 • 12 min read

La mejor forma de aprender Python scikit Learn es practicando. Este artículo te ayuda a empezar con extractos prácticos extraídos de un curso de 33 lecciones — para obtener un primer resultado desde hoy mismo.

tl;dr

Introducción e instalación
Bases del Machine Learning
Preprocesamiento de los datos
Regresión supervisada
Clasificación supervisada

~$ cat ./parcours.md # Python scikit Learn — 10 capítulos

Introducción e instalación

→ ¿Qué es el machine learning ?→ Instalar scikit-learn y el ecosistema+ 1 más lecciones

Bases del Machine Learning

→ Vocabulario ML — features, labels, overfitting→ La API uniforme de scikit-learn+ 1 más lecciones

Preprocesamiento de los datos

→ Valores faltantes e imputación→ Codificación de variables categóricas+ 2 más lecciones

Regresión supervisada

→ Regresión lineal y regularización→ Árboles y RandomForest para la regresión+ 1 más lecciones

Clasificación supervisada

→ Regresión logística→ k-NN y SVM+ 2 más lecciones

Aprendizaje no supervisado

→ Agrupamiento — K-Means, DBSCAN, Agglomerative→ Elegir la K óptima+ 1 más lecciones

Reducción de dimensionalidad

→ PCA — componentes principales→ t-SNE y UMAP — visualización no lineal+ 1 más lecciones

Validación e hiperparámetros

→ Validación cruzada→ GridSearchCV y RandomizedSearchCV+ 1 más lecciones

🏁

Proyecto final (+ 2 capítulos en camino)

→ Te vas con un proyecto concreto y demostrable

Primer modelo en 10 líneas (Iris)

NOTEObjetivo — Realizar tu primer modelo de machine learning end-to-end en menos de 10 líneas de código, sobre el dataset histórico iris.

El dataset Iris

150 flores de iris repartidas en 3 especies (setosa, versicolor, virginica). 4 features medidas: longitud y anchura de sépalos y pétalos.

output

from sklearn.datasets import load_iris

iris = load_iris()
print("Features :", iris.feature_names)
print("Classes :", iris.target_names)
print("Shape X :", iris.data.shape)   # (150, 4)
print("Shape y :", iris.target.shape) # (150,)

El código completo (10 líneas)

output

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier

X, y = load_iris(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

model = KNeighborsClassifier(n_neighbors=5)
model.fit(X_train, y_train)
score = model.score(X_test, y_test)
print(f"Accuracy : {score:.2%}")  # ~96.7%

Es todo. Acabas de crear un modelo de clasificación que distingue 3 especies de iris con ~97% de precisión.

Explicación línea por línea

Línea	Rol
`load_iris(return_X_y=True)`	Carga X (features) e y (etiquetas) directamente
`train_test_split(...)`	Divide 80% train / 20% test
`random_state=42`	Reproducibilidad (siempre la misma división)
`KNeighborsClassifier(...)`	Elección del algoritmo: k-NN con k=5
`model.fit(...)`	Entrenamiento: memoriza los ejemplos
`model.score(...)`	Evalúa la accuracy sobre el test

Hacer una predicción sobre una nueva flor

output

import numpy as np

# Una flor: sépalo 5.1 x 3.5, pétalo 1.4 x 0.2
nouvelle_fleur = np.array([[5.1, 3.5, 1.4, 0.2]])
prediction = model.predict(nouvelle_fleur)

print("Predit :", iris.target_names[prediction[0]])
# > 'setosa'

# Probabilidades para cada clase
proba = model.predict_proba(nouvelle_fleur)
print("Probabilites :", proba)
# > [[1.0, 0.0, 0.0]]  -> 100% setosa

Visualizar el resultado

output

import matplotlib.pyplot as plt

fig, axes = plt.subplots(1, 2, figsize=(12, 5))

# Etiquetas reales
axes[0].scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap="viridis")
axes[0].set_title("Vraies classes")
axes[0].set_xlabel("Longueur sepale")
axes[0].set_ylabel("Largeur sepale")

# Predicciones
predictions = model.predict(X_test)
axes[1].scatter(X_test[:, 0], X_test[:, 1], c=predictions, cmap="viridis")
axes[1].set_title("Predictions du modele")
axes[1].set_xlabel("Longueur sepale")

plt.tight_layout()
plt.show()

El patrón fit / predict / score

TIPAPI uniforme — Esta estructura (fit → predict → score) es la misma para TODOS los modelos scikit-learn. Una vez aprendida, puedes probar 30 algoritmos cambiando solo el import.

output

# Mismo código, modelo diferente:
from sklearn.tree import DecisionTreeClassifier
model = DecisionTreeClassifier(random_state=42)
model.fit(X_train, y_train)
print(model.score(X_test, y_test))

# Mismo código, otro más:
from sklearn.ensemble import RandomForestClassifier
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)
print(model.score(X_test, y_test))

Buenas prácticas desde el principio

WARNINGTrampa — En iris, casi todo funciona muy bien (97%). Es un dataset de juguete. En la realidad, te costará más — ¡y es normal!

Desafío práctico

TIPEjercicio — Retoma el código de 10 líneas y:

Prueba 3 algoritmos diferentes (KNN, DecisionTree, RandomForest)
Varía random_state y observa si el score cambia
Prueba k=1 y luego k=10 en KNeighborsClassifier

Guardar un modelo en producción

NOTEObjetivo — Persistir un modelo entrenado y recargarlo más tarde (API, batch, monitoring).

joblib: el método recomendado

output

import joblib

# Guardar
joblib.dump(pipe, "model.joblib")

# Cargar
loaded_pipe = joblib.load("model.joblib")
preds = loaded_pipe.predict(X_new)

Con compresión

output

# Nivel 0 (rápido) a 9 (máxima compresión)
joblib.dump(pipe, "model.joblib.gz", compress=3)
loaded = joblib.load("model.joblib.gz")

pickle (alternativa)

output

import pickle

with open("model.pkl", "wb") as f:
    pickle.dump(pipe, f)

with open("model.pkl", "rb") as f:
    pipe = pickle.load(f)

WARNINGjoblib vs pickle — joblib es más eficiente para arrays NumPy grandes (lo que caracteriza a sklearn). pickle sigue siendo compatible con todo Python.

Producción: empaquetado completo

output

import joblib
import sklearn
import numpy as np

# Guardar modelo + metadatos
artifact = {
    "model": pipe,
    "feature_names": feature_names,
    "target_names": target_names,
    "sklearn_version": sklearn.__version__,
    "numpy_version": np.__version__,
    "training_date": "2026-05-15",
    "metrics": {"f1": 0.94, "auc": 0.97}
}
joblib.dump(artifact, "model_v1.joblib")

API FastAPI mínima

output

from fastapi import FastAPI
from pydantic import BaseModel
import joblib

app = FastAPI()
artifact = joblib.load("model_v1.joblib")
model = artifact["model"]

class Input(BaseModel):
    features: list[float]

@app.post("/predict")
def predict(data: Input):
    pred = model.predict([data.features])
    proba = model.predict_proba([data.features])[0].tolist()
    return {"prediction": int(pred[0]), "probabilities": proba}

Versionar con MLflow

output

import mlflow
import mlflow.sklearn

with mlflow.start_run():
    pipe.fit(X_tr, y_tr)
    
    # Registrar params, métricas, modelo
    mlflow.log_params({"max_depth": 10, "n_estimators": 200})
    mlflow.log_metric("f1", 0.94)
    mlflow.sklearn.log_model(pipe, "model", registered_model_name="my_model")

¿Qué es el machine learning?

NOTEObjetivo — Comprender qué es el machine learning, distinguir las 3 grandes familias (supervisado / no supervisado / refuerzo), y saber cuándo usar ML frente a una lógica clásica.

Definición pragmática

El machine learning (o aprendizaje automático) consiste en construir un programa que aprende a realizar una tarea a partir de ejemplos en lugar de reglas escritas a mano.

TIPAnalogía — Enseñar a un niño a reconocer un gato: no le das una regla ("el gato tiene 4 patas, bigotes..."), le muestras fotos de gatos hasta que pueda generalizar.

¿Cuándo usar ML?

Problema	Enfoque
Convertir Celsius a Fahrenheit	Fórmula clásica (sin ML)
Predecir el precio de una casa	ML supervisado (regresión)
Detectar spam	ML supervisado (clasificación)
Agrupar clientes similares	ML no supervisado (clustering)
Reconocer un rostro	Deep learning (variante de ML)
Derrotar a un humano en ajedrez	ML por refuerzo

Las 3 familias de ML

1. Supervisado

Se tienen datos con etiquetas (X, y).

Objetivo: predecir y a partir de X.

2. No supervisado

Se tienen datos sin etiquetas (solo X).

Objetivo: descubrir estructuras ocultas.

3. Refuerzo

Un agente aprende por ensayo y error en un entorno.

Objetivo: maximizar una recompensa.

Ejemplos concretos por familia

Supervisado — Regresión

output

# X: superficie de la vivienda, n.º de habitaciones, barrio...
# y: precio de venta (número)
# Objetivo: predecir el precio de una casa nueva

Supervisado — Clasificación

output

# X: contenido del email
# y: "spam" o "no-spam" (categoría)
# Objetivo: clasificar un email nuevo

No supervisado — Clustering

output

# X: compras de los clientes (importe, frecuencia...)
# Sin y
# Objetivo: agrupar en 3-5 segmentos de clientela

El flujo de trabajo típico de un proyecto ML

WARNINGError común — El 80% del tiempo real de un proyecto ML se dedica a los pasos 2-4 (datos), no al entrenamiento. Esa es la realidad frente a la imagen de Hollywood.

¿Por qué scikit-learn?

va-plus-loin

Este artículo cubre los extractos más útiles — el curso completo Python scikit Learn (10 capítulos, 33 lecciones, ejercicios corregidos y proyecto final) te lleva hasta el final.

./acceder-au-cours-complet cours gratuit : Maîtriser Claude Code

FAQ

¿Cuánto tiempo se necesita para aprender Python scikit Learn?

Con una progresión estructurada (10 capítulos, 33 lecciones cortas y prácticas), se alcanza un nivel operativo en unas semanas dedicando 30 a 60 minutos al día. Lo importante es practicar cada concepto de inmediato.

¿Se necesitan requisitos previos?

Con nociones básicas de informática basta. Si sabes usar un terminal y leer código sencillo, estás listo.

¿Por dónde empezar concretamente?

Reproduce los comandos de este artículo y sigue el curso completo Python scikit Learn: encadena las 33 lecciones en orden, con ejercicios y proyecto final.

./a-lire-aussi

→ Lance-toi en Machine Learning Débutants : ton premier pas concret aujourd'hui → Machine Learning Simplifié en pratique : le code et les commandes qui comptent vraiment → Apprentissage Automatique Python : les 9 étapes clés pour passer de zéro à opérationnel

📬 ¿Quieres recibir este tipo de guía cada semana? Suscríbete gratis — código real, cero palabrería.

Primer modelo en 10 líneas (Iris)

El dataset Iris

El código completo (10 líneas)

Explicación línea por línea

Hacer una predicción sobre una nueva flor

Visualizar el resultado

El patrón fit / predict / score

Buenas prácticas desde el principio

Desafío práctico

Guardar un modelo en producción

joblib: el método recomendado

Con compresión

pickle (alternativa)

Producción: empaquetado completo

API FastAPI mínima

Versionar con MLflow

¿Qué es el machine learning?

Definición pragmática

¿Cuándo usar ML?

Las 3 familias de ML

1. Supervisado

2. No supervisado

3. Refuerzo

Ejemplos concretos por familia

Supervisado — Regresión

Supervisado — Clasificación

No supervisado — Clustering

El flujo de trabajo típico de un proyecto ML

¿Por qué scikit-learn?

FAQ

Stay up to date