Primeros pasos

Primeros pasos con Machine Learning en Python

Este capítulo presenta el machine learning con Python. Aprenderás qué es el machine learning, por qué Python es el lenguaje dominante para ello, cómo configurar un entorno de trabajo y cómo encaja el flujo de trabajo de ML de principio a fin — desde los datos en bruto hasta un modelo entrenado y evaluado.

Al terminar, habrás ejecutado un ejemplo completo de clasificación usando las tres bibliotecas principales: NumPy, pandas y scikit-learn.

¿Qué es el Machine Learning?

El machine learning (ML) es una rama de la inteligencia artificial en la que un programa aprende patrones a partir de datos en lugar de seguir reglas escritas a mano. Proporcionas ejemplos (datos), especificas lo que quieres predecir o descubrir, y un algoritmo de ML determina el mapeo correspondiente.

Existen tres categorías amplias:

Esta serie se centra en el aprendizaje supervisado porque es la categoría más utilizada en la práctica.

¿Por qué Python para Machine Learning?

Python se ha convertido en el lenguaje predeterminado para ML por varias razones:

• Sintaxis legible — los algoritmos se pueden prototipar rápidamente sin código repetitivo.
• Ecosistema rico — scikit-learn, TensorFlow, PyTorch y Keras tienen APIs de primera clase en Python.
• Herramientas de datos — NumPy y pandas hacen que la manipulación de datos sea sencilla.
• Comunidad — la mayor comunidad de ML, lo que significa abundancia de tutoriales, respuestas en Stack Overflow y modelos preentrenados.

Configurar tu entorno

Instalar Python

Descarga Python 3.10 o una versión más reciente desde python.org. Verifica la instalación:

python3 --version

Deberías ver una salida como Python 3.10.15 (o más reciente).

Crear un entorno virtual

Un entorno virtual aísla los paquetes de tu proyecto de la instalación de Python del sistema. Esto evita conflictos de versiones entre proyectos.

python3 -m venv ml-env

Actívalo:

# macOS / Linux
source ml-env/bin/activate

# Windows (Command Prompt)
ml-env\Scripts\activate.bat

Tu prompt mostrará ahora (ml-env) para confirmar que el entorno está activo.

Instalar las bibliotecas principales

Con el entorno virtual activo, instala las tres bibliotecas que usarás a lo largo de esta serie:

pip install numpy pandas scikit-learn

Guarda las versiones exactas para reproducibilidad:

pip freeze > requirements.txt

Cualquiera que clone tu proyecto puede reproducir tu entorno con pip install -r requirements.txt.

El flujo de trabajo de Machine Learning

Todo proyecto supervisado de ML sigue el mismo pipeline de cinco pasos:

Raw data → Clean & prepare → Split → Train model → Evaluate

Entender este pipeline es más importante que memorizar cualquier algoritmo individual. Las secciones siguientes recorren cada paso con código.

Paso 1 — Comprende tus datos con NumPy y pandas

Antes de entrenar cualquier cosa necesitas saber cómo son tus datos. NumPy proporciona aritmética rápida sobre arrays; pandas añade tablas con etiquetas (DataFrames) que facilitan la exploración.

NumPy: inspeccionar un array numérico

import numpy as np

data = np.array([2.1, 3.4, 1.8, 5.0, 2.7])
print('Mean:', data.mean())   # 3.0
print('Std: ', round(data.std(), 4))  # 1.1402
print('Max: ', data.max())    # 5.0

pandas: construir un pequeño conjunto de datos

import pandas as pd

df = pd.DataFrame({
    'age':    [25, 30, 22, 35, 28],
    'income': [40000, 55000, 32000, 70000, 48000],
    'bought': [0,     1,     0,     1,     0],
})

print(df.shape)             # (5, 3)
print(df['income'].mean())  # 49000.0
print(df.isnull().sum())    # 0 missing values in each column

df.shape te indica el número de filas y columnas. isnull().sum() cuenta los valores faltantes por columna — comprueba esto siempre antes de modelar.

Paso 2 — Limpiar y preparar los datos

Los conjuntos de datos reales casi siempre tienen valores faltantes, formatos inconsistentes o características en escalas muy diferentes. Es necesario abordar esto antes del entrenamiento.

Manejar valores faltantes

Reemplaza los números faltantes con la mediana de la columna (robusta ante valores atípicos) o la media:

import pandas as pd

df = pd.DataFrame({
    'age':    [25, None, 22, 35, 28],
    'income': [40000, 55000, None, 70000, 48000],
})

df['age']    = df['age'].fillna(df['age'].median())
df['income'] = df['income'].fillna(df['income'].mean())

print(df.isnull().sum())
# age       0
# income    0

Escalar características

Muchos algoritmos (k-vecinos más cercanos, SVMs, redes neuronales) son sensibles a la escala de las características. Una columna con valores en miles dominará a una columna con valores de un solo dígito a menos que las normalices. StandardScaler resta la media y divide por la desviación estándar, de modo que cada característica tiene media 0 y desviación estándar 1:

from sklearn.preprocessing import StandardScaler
import numpy as np

X = np.array([[1.0, 200.0], [2.0, 400.0], [3.0, 300.0]])
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
print(X_scaled.round(2))
# [[-1.22 -1.22]
#  [ 0.    1.22]
#  [ 1.22  0.  ]]

Consulta Escalado de características para más detalles.

Paso 3 — Dividir en conjuntos de entrenamiento y prueba

Nunca evalúes un modelo con los datos con los que fue entrenado — sería como corregir tu propio examen con el solucionario abierto. Divide los datos para que el modelo entrene con una parte y se evalúe con una parte reservada que nunca haya visto.

from sklearn.model_selection import train_test_split

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

test_size=0.2 reserva el 20 % de los datos para pruebas. random_state=42 hace que la división sea reproducible. Consulta el capítulo División en entrenamiento/prueba para estrategias como la división estratificada y la validación cruzada.

Paso 4 — Entrenar un modelo

Con datos limpios y divididos puedes entrenar tu primer modelo. El ejemplo a continuación usa el conjunto de datos Iris — un benchmark clásico con 150 muestras, 4 características numéricas y 3 especies de flores para clasificar.

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score

# 1. Load
iris = load_iris()

# 2. Split
X_train, X_test, y_train, y_test = train_test_split(
    iris.data, iris.target, test_size=0.2, random_state=42
)

# 3. Train
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

# 4. Predict & evaluate
predictions = model.predict(X_test)
print(f'Test samples: {len(X_test)}')   # 30
print(f'Accuracy: {accuracy_score(y_test, predictions):.2f}')  # 1.00

Un RandomForestClassifier entrena muchos árboles de decisión sobre subconjuntos aleatorios de los datos y combina sus votos. Maneja bien las relaciones no lineales y es una buena línea base para tareas de clasificación. n_estimators=100 especifica el número de árboles.

Paso 5 — Evaluar el modelo

La exactitud (la proporción de predicciones correctas) es fácil de entender, pero puede ser engañosa cuando una clase es mucho más rara que las demás. scikit-learn proporciona una suite completa de métricas:

Para un análisis más detallado de la evaluación, consulta el capítulo Matriz de confusión.

Elegir el algoritmo adecuado

Diferentes problemas requieren diferentes algoritmos. Aquí tienes una orientación rápida:

Explorarás la mayoría de estos en el resto de esta serie. Buenos puntos de partida son K-Vecinos más cercanos, Árbol de decisión y Regresión lineal.

Errores comunes para principiantes

• Fuga de datos — ajustar el escalador sobre el conjunto de datos completo (antes de dividir) filtra las estadísticas del conjunto de prueba al entrenamiento. Ajusta siempre los transformadores solo sobre el conjunto de entrenamiento y luego aplícalos al conjunto de prueba.
• Sobreajuste — un modelo que memoriza los datos de entrenamiento tiene un rendimiento deficiente con datos nuevos. Usa Validación cruzada para detectarlo a tiempo.
• Ignorar el desequilibrio de clases — si el 95 % de tus etiquetas son "negativo", un modelo que siempre predice "negativo" obtiene un 95 % de exactitud pero es inútil. Comprueba las distribuciones de clases antes de elegir una métrica.
• Omitir la exploración — mira siempre tus datos antes de modelar. Comprueba rangos, distribuciones y recuentos de valores faltantes.

Conclusión

Ahora tienes un entorno de ML en Python en funcionamiento y comprendes el pipeline completo de aprendizaje supervisado: cargar los datos, limpiarlos, dividirlos, entrenar un modelo y evaluarlo con datos reservados. Los capítulos que siguen profundizan en cada paso — comenzando con la preparación de datos, pasando por los algoritmos individuales y terminando con temas avanzados como la validación cruzada y el ajuste de hiperparámetros.