Tutorial ScikitLearn: Particionamiento de datos

¿Qué es el particionamiento de datos?

El particionamiento de datos es un proceso clave en el aprendizaje automático que implica dividir el conjunto de datos disponible en subconjuntos más pequeños para diferentes etapas del desarrollo de modelos. Esta práctica es esencial para evaluar la capacidad del modelo de generalizar a datos no vistos y evitar problemas como el sobreajuste.

En el desarrollo de modelos predictivos, es común dividir los datos en dos conjuntos principales: el conjunto de entrenamiento y el conjunto de prueba. El conjunto de entrenamiento se utiliza para ajustar el modelo, aprendiendo las relaciones y patrones presentes en los datos. Por otro lado, el conjunto de prueba se emplea para evaluar el desempeño del modelo en datos independientes, proporcionando una estimación realista de su capacidad de predicción en situaciones del mundo real.

Cuando es necesario ajustar hiperparámetros o comparar diferentes modelos, se introduce un tercer conjunto llamado conjunto de validación. Esto permite seleccionar la mejor configuración sin sesgar la evaluación final del modelo. En este caso, el particionamiento se realiza en tres subconjuntos: entrenamiento, validación y prueba.

Una consideración importante al particionar datos es la estratificación, especialmente en casos donde las clases están desbalanceadas. La estratificación asegura que la proporción de clases o categorías se mantenga consistente en los diferentes conjuntos, lo que es fundamental para obtener evaluaciones precisas y evitar sesgos en el modelo.

El particionamiento de datos adecuado permite identificar y mitigar problemas como el sobreajuste (cuando el modelo se ajusta demasiado a los datos de entrenamiento) y el subajuste (cuando el modelo no captura las relaciones necesarias). Al evaluar el modelo en conjuntos separados, podemos asegurarnos de que este tenga un rendimiento equilibrado y sea capaz de generalizar efectivamente.

El método train_test_split y sus parámetros

El método train_test_split es una función esencial en Scikit-Learn que facilita la división de un conjunto de datos en conjuntos de entrenamiento y prueba. Esta división es crucial para evaluar el rendimiento de los modelos de aprendizaje automático, ya que permite entrenar el modelo en un subconjunto de datos y luego probar su capacidad de generalización en datos no vistos.

La función se encuentra en el módulo model_selection y su uso básico es el siguiente:

from sklearn.model_selection import train_test_split

X_entrenamiento, X_prueba, y_entrenamiento, y_prueba = train_test_split(X, y)

Aquí, X representa las características o variables independientes, mientras que y corresponde a las etiquetas o variables dependientes que se desean predecir.

Parámetros principales

El método train_test_split ofrece varios parámetros que permiten personalizar el particionamiento de los datos según las necesidades específicas del análisis:

• test_size: Determina el tamaño del conjunto de prueba. Puede ser un valor entre 0.0 y 1.0 que indica la proporción del conjunto total de datos, o un número entero que especifica el número exacto de muestras. Si no se especifica, por defecto es 0.25, es decir, el 25 % de los datos se reserva para prueba.

Ejemplo usando un 20 % de los datos para prueba:

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

• train_size: Define el tamaño del conjunto de entrenamiento. Similar a test_size, puede ser un valor entre 0.0 y 1.0 o un entero. Si se deja en None, su valor se complementa con el de test_size (es decir, train_size = 1 - test_size).
• random_state: Controla la aleatoriedad en la división de los datos. Al establecer un número entero, se asegura que los resultados sean reproducibles en ejecuciones posteriores. Esto es útil para obtener resultados consistentes durante el desarrollo y la validación del modelo.

Ejemplo con una semilla aleatoria fija:

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

• shuffle: Indica si se deben barajar los datos antes de dividirlos. Es un valor booleano que por defecto es True. Barajar es importante para evitar sesgos en la selección de los datos, especialmente si el conjunto original está ordenado de alguna manera.
• stratify: Permite realizar una estratificación de los datos basada en una variable específica, manteniendo la misma proporción de clases en los conjuntos de entrenamiento y prueba. Es particularmente útil en problemas de clasificación con clases desbalanceadas. Se utiliza pasando la variable de estratificación, comúnmente y.

Ejemplo de estratificación según las etiquetas:

X_train, X_test, y_train, y_test = train_test_split(X, y, stratify=y)

Ejemplo práctico

Consideremos un conjunto de datos donde se requiere dividir las muestras manteniendo la proporción de clases y asegurando reproducibilidad:

import pandas as pd
from sklearn.model_selection import train_test_split

# Datos de ejemplo
datos = pd.DataFrame({
    'característica_1': [1, 2, 3, 4, 5, 6],
    'característica_2': [10, 20, 30, 40, 50, 60],
    'etiqueta': [0, 1, 0, 1, 0, 1]
})

X = datos[['característica_1', 'característica_2']]
y = datos['etiqueta']

# División de los datos
X_train, X_test, y_train, y_test = train_test_split(
    X, y,
    test_size=0.33,
    random_state=42,
    shuffle=True,
    stratify=y
)

print("Conjunto de entrenamiento:")
print(X_train)
print("Etiquetas de entrenamiento:")
print(y_train)
print("Conjunto de prueba:")
print(X_test)
print("Etiquetas de prueba:")
print(y_test)

En este ejemplo:

• Se usa test_size=0.33 para asignar el 33 % de los datos al conjunto de prueba.
• random_state=42 asegura que la división sea consistente en cada ejecución.
• shuffle=True garantiza que los datos se barajen antes de dividirse.
• stratify=y mantiene la proporción original de las clases en ambos conjuntos.

Manejo de múltiples conjuntos de datos

El método train_test_split también permite dividir múltiples conjuntos de datos de manera coherente, manteniendo la correspondencia entre ellos. Esto es útil cuando se tienen varias matrices de características o variables adicionales.

Ejemplo con múltiples matrices:

X1 = ...
X2 = ...
y = ...

X1_train, X1_test, X2_train, X2_test, y_train, y_test = train_test_split(
    X1, X2, y,
    test_size=0.2,
    random_state=0
)

Importancia de la estratificación

En problemas donde las clases están desbalanceadas, la estratificación es esencial para evitar que el modelo aprenda con un sesgo hacia la clase mayoritaria. Al utilizar stratify, se garantiza que la distribución de las clases sea la misma en los conjuntos de entrenamiento y prueba.

Ejemplo sin estratificación:

# División sin estratificación
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)

Ejemplo con estratificación:

# División con estratificación
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0, stratify=y)

Al comparar ambos casos, se puede observar que la distribución de clases en y_train y y_test varía si no se aplica estratificación, lo que puede afectar negativamente al rendimiento del modelo.

Particionamiento manual en Numpy

El particionamiento manual de datos utilizando NumPy permite un control completo sobre cómo se dividen los conjuntos de datos para el entrenamiento y la prueba de modelos. A diferencia de métodos automáticos como train_test_split, el particionamiento manual es útil cuando se requiere una división específica o se necesita reproducir un experimento con particiones personalizadas.

Para comenzar, supongamos que disponemos de un conjunto de datos almacenado en arrays de NumPy. Estos arrays, denominados comúnmente X para las características y y para las etiquetas o variables objetivo, pueden ser particionados manualmente utilizando índices o rebanadas.

Ejemplo básico de particionamiento

Consideremos un array de características X y un array de etiquetas y, cada uno con 100 muestras. Para dividir estos arrays en conjuntos de entrenamiento y prueba, podemos determinar un punto de corte basado en el tamaño deseado para cada conjunto.

import numpy as np

# Creación de datos de ejemplo
X = np.arange(100).reshape((100, 1))
y = np.arange(100)

# Determinar el tamaño del conjunto de entrenamiento
tamaño_entrenamiento = int(0.8 * len(X))  # 80% para entrenamiento

# Particionamiento manual
X_entrenamiento = X[:tamaño_entrenamiento]
X_prueba = X[tamaño_entrenamiento:]
y_entrenamiento = y[:tamaño_entrenamiento]
y_prueba = y[tamaño_entrenamiento:]

print("Tamaño del conjunto de entrenamiento:", X_entrenamiento.shape)
print("Tamaño del conjunto de prueba:", X_prueba.shape)

En este ejemplo, se utiliza una partición del 80 % para entrenamiento y el 20 % restante para prueba. Los datos se dividen empleando rebanadas de los arrays, lo que permite seleccionar las muestras correspondientes a cada conjunto.

Barajado de datos

Es importante barajar los datos antes de particionarlos para evitar sesgos en la distribución de las muestras. Si los datos están ordenados, como suele ocurrir en series temporales o cuando las clases están agrupadas, el particionamiento sin barajar puede conducir a conjuntos no representativos.

Para barajar los datos de manera coordinada entre X y y, se pueden generar índices aleatorios y aplicarlos a ambos arrays:

# Generar índices aleatorios
índices = np.random.permutation(len(X))

# Aplicar los índices a los arrays
X_barajado = X[índices]
y_barajado = y[índices]

# Particionamiento después de barajar
X_entrenamiento = X_barajado[:tamaño_entrenamiento]
X_prueba = X_barajado[tamaño_entrenamiento:]
y_entrenamiento = y_barajado[:tamaño_entrenamiento]
y_prueba = y_barajado[tamaño_entrenamiento:]

En este caso, la función np.random.permutation genera una permutación aleatoria de los índices, garantizando que el barajado sea consistente entre X y y.

Control de la semilla aleatoria

Para asegurar la reproducibilidad de los resultados, es recomendable fijar la semilla del generador de números aleatorios de NumPy utilizando np.random.seed. Al establecer una semilla fija, el orden aleatorio de los datos será el mismo en cada ejecución.

# Fijar la semilla aleatoria
np.random.seed(42)

# Generar índices aleatorios reproducibles
índices = np.random.permutation(len(X))

Al utilizar la semilla 42, cualquier persona que ejecute el código obtendrá el mismo barajado de datos, lo cual es crucial para validación y comparación de resultados.

División estratificada

Cuando se trabaja con problemas de clasificación y las clases están desbalanceadas, es importante mantener la proporción de clases en los conjuntos de entrenamiento y prueba. Aunque NumPy no proporciona una función directa para realizar una división estratificada, se puede implementar manualmente utilizando máscaras lógicas.

Por ejemplo, supongamos que y contiene etiquetas de dos clases:

# Simulación de etiquetas desbalanceadas
y = np.array([0]*90 + [1]*10)
X = np.random.rand(100, 5)

# Obtener índices para cada clase
índices_clase_0 = np.where(y == 0)[0]
índices_clase_1 = np.where(y == 1)[0]

# Barajar índices de cada clase
np.random.shuffle(índices_clase_0)
np.random.shuffle(índices_clase_1)

# Determinar tamaños de entrenamiento por clase
tamaño_entrenamiento_clase_0 = int(0.8 * len(índices_clase_0))
tamaño_entrenamiento_clase_1 = int(0.8 * len(índices_clase_1))

# Particionar índices
índices_entrenamiento = np.hstack((
    índices_clase_0[:tamaño_entrenamiento_clase_0],
    índices_clase_1[:tamaño_entrenamiento_clase_1]
))
índices_prueba = np.hstack((
    índices_clase_0[tamaño_entrenamiento_clase_0:],
    índices_clase_1[tamaño_entrenamiento_clase_1:]
))

# Barajar índices de entrenamiento y prueba
np.random.shuffle(índices_entrenamiento)
np.random.shuffle(índices_prueba)

# Crear conjuntos de entrenamiento y prueba
X_entrenamiento = X[índices_entrenamiento]
y_entrenamiento = y[índices_entrenamiento]
X_prueba = X[índices_prueba]
y_prueba = y[índices_prueba]

print("Distribución de clases en entrenamiento:", np.bincount(y_entrenamiento))
print("Distribución de clases en prueba:", np.bincount(y_prueba))

En este código, se logra una partición estratificada al dividir los índices de cada clase por separado y luego combinarlos. Esto garantiza que la proporción de clases se mantenga consistente en ambos conjuntos.

Particionamiento en múltiples conjuntos

Además de dividir en conjuntos de entrenamiento y prueba, a veces es necesario crear un conjunto de validación. Esto puede lograrse extendiendo el enfoque manual de particionamiento.

# Determinar tamaños para entrenamiento, validación y prueba
tamaño_entrenamiento = int(0.6 * len(X))
tamaño_validación = int(0.2 * len(X))

# Barajar los datos
np.random.seed(42)
índices = np.random.permutation(len(X))

# Particionar índices
índices_entrenamiento = índices[:tamaño_entrenamiento]
índices_validación = índices[tamaño_entrenamiento:tamaño_entrenamiento + tamaño_validación]
índices_prueba = índices[tamaño_entrenamiento + tamaño_validación:]

# Crear conjuntos
X_entrenamiento = X[índices_entrenamiento]
y_entrenamiento = y[índices_entrenamiento]
X_validación = X[índices_validación]
y_validación = y[índices_validación]
X_prueba = X[índices_prueba]
y_prueba = y[índices_prueba]

print("Tamaños de los conjuntos:")
print("Entrenamiento:", X_entrenamiento.shape)
print("Validación:", X_validación.shape)
print("Prueba:", X_prueba.shape)

De esta manera, se obtienen tres conjuntos: entrenamiento, validación y prueba, con las proporciones deseadas del 60 %, 20 % y 20 %, respectivamente.

Ventajas y consideraciones

El particionamiento manual con NumPy ofrece una gran flexibilidad para personalizar la división de los datos según requerimientos específicos. Sin embargo, es fundamental prestar atención a detalles como el barajado de datos y la estratificación para asegurar que los conjuntos resultantes sean representativos.

Es recomendable utilizar métodos manuales cuando:

• Se necesita un control preciso sobre la división de los datos.
• Se trabaja con formatos de datos que no son compatibles directamente con herramientas como Scikit-Learn.
• Se requiere implementar particiones o validaciones personalizadas, como en el caso de validación cruzada específica.

No obstante, para tareas comunes, las funciones proporcionadas por librerías especializadas suelen ser más eficientes y menos propensas a errores. Es importante asegurarse de que los procesos manuales cumplan con los requisitos del experimento y mantengan la integridad de los datos.

Particionamiento manual en Pandas

El particionamiento manual con Pandas permite dividir conjuntos de datos de forma personalizada y eficiente, utilizando funcionalidades nativas de los DataFrames. A diferencia de métodos automatizados, el particionamiento manual ofrece mayor control sobre cómo se separan los datos para el entrenamiento y la prueba de modelos.

Para ilustrar este proceso, consideremos un conjunto de datos almacenado en un DataFrame de Pandas. Este DataFrame, denominado df, contiene tanto las características como las etiquetas o variables objetivo que se desean predecir.

Ejemplo básico de particionamiento

Supongamos que trabajamos con un DataFrame df que tiene 1000 observaciones. Queremos dividir este conjunto en un 80 % para entrenamiento y un 20 % para prueba.

import pandas as pd

# Creación de un DataFrame de ejemplo
datos = {
    'característica_1': range(1000),
    'característica_2': range(1000, 2000),
    'etiqueta': [0 if x < 500 else 1 for x in range(1000)]
}

df = pd.DataFrame(datos)

# Determinar el tamaño del conjunto de entrenamiento
tamaño_entrenamiento = int(0.8 * len(df))

# Particionamiento manual
df_entrenamiento = df[:tamaño_entrenamiento]
df_prueba = df[tamaño_entrenamiento:]

print("Tamaño del conjunto de entrenamiento:", len(df_entrenamiento))
print("Tamaño del conjunto de prueba:", len(df_prueba))

En este ejemplo, usamos rebanadas del DataFrame para separar las primeras 800 filas como conjunto de entrenamiento y las restantes 200 como conjunto de prueba.

Mezcla aleatoria de datos

Es esencial mezclar los datos antes de particionarlos para evitar sesgos derivados del orden de las observaciones. Pandas proporciona el método sample para barajar las filas de un DataFrame de manera aleatoria.

# Mezclar aleatoriamente el DataFrame
df_barajado = df.sample(frac=1, random_state=42)

# Restablecer los índices
df_barajado.reset_index(drop=True, inplace=True)

# Particionar el DataFrame barajado
df_entrenamiento = df_barajado[:tamaño_entrenamiento]
df_prueba = df_barajado[tamaño_entrenamiento:]

Aquí, frac=1 indica que se debe tomar el 100 % de las filas y random_state=42 garantiza que la mezcla sea reproducible. Al restablecer los índices con reset_index, facilitamos operaciones posteriores sobre el DataFrame.

Control de la semilla aleatoria

Al especificar el parámetro random_state, aseguramos la consistencia en la mezcla de los datos en cada ejecución. Esto es crucial para comparar resultados y mantener la validez de los experimentos.

# Mezcla reproducible con semilla fija
df_barajado = df.sample(frac=1, random_state=2024)

Al cambiar la semilla a 2024, se obtiene un orden diferente, pero reproducible si se vuelve a ejecutar con la misma semilla.

Particionamiento basado en índices

Otra forma de particionar datos es utilizando los índices del DataFrame. Esto es útil cuando se necesita una división específica o cuando se trabaja con subconjuntos particulares.

# Listas de índices personalizados
índices_entrenamiento = df_barajado.index[:tamaño_entrenamiento]
índices_prueba = df_barajado.index[tamaño_entrenamiento:]

# Creación de conjuntos de entrenamiento y prueba
df_entrenamiento = df.loc[índices_entrenamiento]
df_prueba = df.loc[índices_prueba]

El uso de loc permite acceder a filas específicas basadas en sus etiquetas de índice, manteniendo la integridad de los datos.

Particionamiento estratificado

Cuando las clases están desbalanceadas, es importante mantener la proporción de cada clase en los conjuntos de entrenamiento y prueba. Aunque Pandas no ofrece una función directa para el particionamiento estratificado, se puede lograr agrupando los datos por la etiqueta y aplicando muestras aleatorias proporcionadas.

# Función para particionamiento estratificado
def particionar_estratificado(df, columna_clase, tamaño_entrenamiento, random_state=None):
    df_entrenamiento = pd.DataFrame()
    df_prueba = pd.DataFrame()
    
    # Iterar sobre cada categoría de la clase
    for clase in df[columna_clase].unique():
        df_clase = df[df[columna_clase] == clase]
        df_clase_barajado = df_clase.sample(frac=1, random_state=random_state)
        
        tamaño_clase_entrenamiento = int(tamaño_entrenamiento * len(df_clase) / len(df))
        
        df_entrenamiento_clase = df_clase_barajado[:tamaño_clase_entrenamiento]
        df_prueba_clase = df_clase_barajado[tamaño_clase_entrenamiento:]
        
        df_entrenamiento = pd.concat([df_entrenamiento, df_entrenamiento_clase])
        df_prueba = pd.concat([df_prueba, df_prueba_clase])
    
    # Mezclar los conjuntos resultantes
    df_entrenamiento = df_entrenamiento.sample(frac=1, random_state=random_state).reset_index(drop=True)
    df_prueba = df_prueba.sample(frac=1, random_state=random_state).reset_index(drop=True)
    
    return df_entrenamiento, df_prueba

# Uso de la función
df_entrenamiento, df_prueba = particionar_estratificado(df, 'etiqueta', tamaño_entrenamiento, random_state=42)

# Verificar la distribución de clases
print("Distribución en entrenamiento:")
print(df_entrenamiento['etiqueta'].value_counts(normalize=True))
print("Distribución en prueba:")
print(df_prueba['etiqueta'].value_counts(normalize=True))

Esta función divide el DataFrame manteniendo la proporción original de clases en ambos conjuntos. Al iterar sobre cada clase y particionar individualmente, se conserva la estratificación.

Particionamiento en múltiples conjuntos

Si se necesita separar los datos en conjuntos de entrenamiento, validación y prueba, se puede extender el proceso de particionamiento.

# Tamaños para cada conjunto
tamaño_entrenamiento = int(0.7 * len(df))
tamaño_validación = int(0.15 * len(df))
tamaño_prueba = len(df) - tamaño_entrenamiento - tamaño_validación

# Mezclar los datos
df_barajado = df.sample(frac=1, random_state=42).reset_index(drop=True)

# Particionar los datos
df_entrenamiento = df_barajado[:tamaño_entrenamiento]
df_validación = df_barajado[tamaño_entrenamiento:tamaño_entrenamiento + tamaño_validación]
df_prueba = df_barajado[tamaño_entrenamiento + tamaño_validación:]

print("Tamaños de los conjuntos:")
print("Entrenamiento:", len(df_entrenamiento))
print("Validación:", len(df_validación))
print("Prueba:", len(df_prueba))

Este método permite crear tres conjuntos con proporciones del 70 % para entrenamiento, 15 % para validación y 15 % para prueba.

Uso de máscaras booleanas

Las máscaras booleanas son otra herramienta útil para particionar datos basados en condiciones lógicas. Por ejemplo, si se desea separar las observaciones de acuerdo con un umbral específico.

# Separar datos donde la característica_1 es menor a 500
mascara = df['característica_1'] < 500

df_entrenamiento = df[mascara]
df_prueba = df[~mascara]

print("Entrenamiento:", len(df_entrenamiento))
print("Prueba:", len(df_prueba))

Este enfoque es especialmente útil cuando se trabaja con series temporales o se requiere una separación basada en condiciones específicas.

Particionamiento basado en fechas

En análisis de series temporales, es común dividir los datos según fechas, reservando las observaciones más recientes para validación y prueba.

# Supongamos que el DataFrame tiene una columna de fecha
df['fecha'] = pd.date_range(start='2024-01-01', periods=len(df), freq='D')

# Ordenar el DataFrame por fecha
df_ordenado = df.sort_values('fecha')

# Determinar el punto de corte
fecha_corte = '2024-10-01'

# Particionar los datos
df_entrenamiento = df_ordenado[df_ordenado['fecha'] < fecha_corte]
df_prueba = df_ordenado[df_ordenado['fecha'] >= fecha_corte]

print("Entrenamiento hasta:", df_entrenamiento['fecha'].max())
print("Prueba desde:", df_prueba['fecha'].min())

Al ordenar y particionar por fecha, se respeta la secuencia temporal, lo cual es crucial en modelos predictivos basados en tiempo.

Ventajas y consideraciones

El particionamiento manual en Pandas ofrece flexibilidad para adaptar la división de los datos a las necesidades específicas del análisis. Sin embargo, es fundamental tener en cuenta aspectos como:

• Reproducibilidad: Al establecer semillas aleatorias, se asegura que los resultados puedan ser replicados.
• Integridad de los datos: Es importante verificar que no haya solapamiento entre los conjuntos y que todas las observaciones estén correctamente asignadas.
• Representatividad: Asegurarse de que los conjuntos sean representativos de la población, evitando sesgos que puedan afectar al modelo.