Preprocesamiento de Datos con Scikit-learn

Introducción

Bienvenido al laboratorio de preprocesamiento de datos de scikit-learn. En el aprendizaje automático, la calidad de tus datos impacta directamente el rendimiento de tu modelo. Los datos brutos a menudo son desordenados, inconsistentes y no están en el formato óptimo para los algoritmos. El preprocesamiento de datos es un paso crucial que implica limpiar y transformar los datos para hacerlos adecuados para un modelo de aprendizaje automático.

En este laboratorio, aprenderás a realizar dos tareas fundamentales de preprocesamiento utilizando la biblioteca scikit-learn:

• Escalado de características (Feature Scaling): Estandarizar el rango de las variables independientes o características de los datos.
• Codificación de etiquetas (Label Encoding): Convertir etiquetas categóricas en un formato numérico.

Utilizaremos el famoso conjunto de datos Iris, que está convenientemente incluido con scikit-learn, para practicar estas técnicas. Al final de este laboratorio, tendrás una comprensión sólida de cómo preparar tus datos para los pipelines de aprendizaje automático.

Dividir datos en características y objetivo con X = iris.data, y = iris.target

En este paso, comenzaremos cargando el conjunto de datos Iris y separándolo en características y la variable objetivo. En el aprendizaje automático, X es la notación convencional para las características (las variables de entrada), y y es la notación para el objetivo (la variable de salida que deseas predecir).

La biblioteca scikit-learn proporciona el conjunto de datos Iris a través de su módulo datasets. El objeto del conjunto de datos cargado se comporta como un diccionario.

Estructura del conjunto de datos Iris:

• iris.data: Matriz de características (150 muestras × 4 características)
• iris.target: Etiquetas objetivo (150 muestras)
• iris.feature_names: Nombres de las 4 características
• iris.target_names: Nombres de las 3 especies de flores

¿Por qué separar X e y?

• X: Características de entrada (de lo que aprende el modelo)
• y: Etiquetas objetivo (lo que el modelo predice)
• Esta es la convención estándar en el aprendizaje automático

Primero, abre el archivo preprocess.py ubicado en el directorio ~/project usando el explorador de archivos a la izquierda. Agregaremos nuestro código a este archivo.

Agrega las siguientes líneas debajo del comentario ## --- Step 1: Split data --- para asignar las características y el objetivo a X e y respectivamente. También imprimiremos sus formas para verificar.

## --- Step 1: Split data ---
X = iris.data
y = iris.target

print("Shape of features (X):", X.shape)
print("Shape of target (y):", y.shape)

Ahora, guarda el archivo y ejecútalo desde la terminal para ver la salida.

python3 preprocess.py

Deberías ver la siguiente salida, que indica que tenemos 150 muestras y 4 características, junto con 150 etiquetas objetivo correspondientes.

Shape of features (X): (150, 4)
Shape of target (y): (150,)

Escalar características usando StandardScaler de sklearn.preprocessing

En este paso, nos prepararemos para escalar nuestras características. El escalado de características es un requisito común para muchos algoritmos de aprendizaje automático porque pueden ser sensibles a la escala de las características de entrada. StandardScaler es una técnica popular que estandariza las características eliminando la media y escalándolas a una varianza unitaria.

Cómo funciona StandardScaler:

• Fórmula: z = (x - u) / s, donde u es la media de las muestras de entrenamiento y s es la desviación estándar
• Efecto: Transforma los datos para que tengan una media de 0 y una desviación estándar de 1
• Beneficios: Evita que las características con escalas mayores dominen el proceso de aprendizaje

Parámetros clave de StandardScaler:

• with_mean=True (por defecto): Centra los datos eliminando la media
• with_std=True (por defecto): Escala los datos dividiendo por la desviación estándar

Utilizaremos StandardScaler de sklearn.preprocessing. La primera parte del proceso es crear una instancia del escalador.

En tu archivo preprocess.py, agrega el siguiente código debajo del comentario ## --- Step 2: Initialize the scaler --- para crear una instancia de StandardScaler.

## --- Step 2: Initialize the scaler ---
scaler = StandardScaler()

print("Scaler object created:", scaler)

Guarda el archivo y ejecútalo de nuevo.

python3 preprocess.py

La salida ahora incluirá una línea que confirma que el objeto StandardScaler se ha creado con éxito.

Shape of features (X): (150, 4)
Shape of target (y): (150,)
Scaler object created: StandardScaler()

Ajustar escalador con scaler.fit(X)

En este paso, ajustaremos el StandardScaler a nuestros datos de características X. El método fit() es un concepto fundamental en scikit-learn.

Qué hace fit():

• Calcula las estadísticas necesarias (media y desviación estándar) a partir de los datos de entrenamiento
• Almacena estos parámetros internamente para su uso posterior
• Importante: Solo aprende de los datos, no los transforma

¿Por qué separar fit() y transform()?

• Ajustar solo en datos de entrenamiento: Evita la fuga de datos aprendiendo los parámetros solo del conjunto de entrenamiento
• Aplicar a cualquier dato: Puede transformar tanto los datos de entrenamiento como los de prueba utilizando los mismos parámetros aprendidos
• Consistencia: Asegura que la misma transformación se aplique a todos los datos

Mejor práctica en el mundo real:

• scaler.fit(X_train) - Aprender parámetros solo de los datos de entrenamiento
• X_train_scaled = scaler.transform(X_train) - Transformar los datos de entrenamiento
• X_test_scaled = scaler.transform(X_test) - Transformar los datos de prueba con los mismos parámetros

Agrega el siguiente código a tu archivo preprocess.py debajo del comentario ## --- Step 3: Fit the scaler ---. También imprimiremos el atributo mean_ del escalador para ver qué ha aprendido.

## --- Step 3: Fit the scaler ---
scaler.fit(X)

print("Scaler mean:", scaler.mean_)

Guarda el archivo y ejecútalo.

python3 preprocess.py

La salida ahora mostrará la media de cada una de las cuatro características, que el escalador ha calculado a partir de los datos.

Shape of features (X): (150, 4)
Shape of target (y): (150,)
Scaler object created: StandardScaler()
Scaler mean: [5.84333333 3.05733333 3.758      1.19933333]

Transformar datos con scaler.transform(X)

En este paso, utilizaremos el escalador ajustado para transformar nuestros datos. El método transform() aplica la transformación de escalado a los datos, utilizando la media y la desviación estándar calculadas durante el paso fit(). Esto centrará nuestros datos alrededor de una media de 0 con una desviación estándar de 1.

Almacenaremos los datos transformados en una nueva variable, X_scaled, para mantener intactos los datos originales.

Entendiendo el código:

• X_scaled = scaler.transform(X): Aplica la transformación aprendida a nuestros datos
• np.set_printoptions(precision=2, suppress=True): Formatea la salida para una mejor legibilidad
  • precision=2: Muestra 2 decimales
  • suppress=True: Utiliza notación científica para números muy pequeños/grandes
• np.mean(X, axis=0): Calcula la media a lo largo del eje 0 (columnas)
  • axis=0: Calcula la media para cada característica (columna) en todas las muestras
  • Resultado: Un valor de media por característica

Agrega el siguiente código a tu archivo preprocess.py debajo del comentario ## --- Step 4: Transform the data ---. Imprimiremos la media de los datos originales y escalados para observar el efecto de la transformación.

## --- Step 4: Transform the data ---
X_scaled = scaler.transform(X)

## Use numpy to set precision for cleaner output
np.set_printoptions(precision=2, suppress=True)
print("Original data mean:", np.mean(X, axis=0))
print("Scaled data mean:", np.mean(X_scaled, axis=0))
print("Scaled data sample:\n", X_scaled[:5])

Guarda el archivo y ejecútalo.

python3 preprocess.py

Verás que la media de los datos escalados es efectivamente cero, y los valores de muestra de los datos se han transformado.

Shape of features (X): (150, 4)
Shape of target (y): (150,)
Scaler object created: StandardScaler()
Scaler mean: [5.84333333 3.05733333 3.758      1.19933333]
Original data mean: [5.84 3.06 3.76 1.2 ]
Scaled data mean: [-0. -0. -0. -0.]
Scaled data sample:
 [[-0.9   1.02 -1.34 -1.32]
 [-1.14 -0.13 -1.34 -1.32]
 [-1.39  0.33 -1.4  -1.32]
 [-1.51  0.1  -1.28 -1.32]
 [-1.02  1.25 -1.34 -1.32]]

Codificar objetivo categórico usando LabelEncoder de sklearn.preprocessing

En este paso, preprocesaremos nuestra variable objetivo y. El objetivo del conjunto de datos Iris es categórico, representado por los números 0, 1 y 2, que corresponden a las tres especies diferentes de flores Iris. Aunque ya son numéricos, es una buena práctica comprender cómo codificar etiquetas categóricas, especialmente si estuvieran en formato de cadena (por ejemplo, 'setosa', 'versicolor').

LabelEncoder explicado:

• Propósito: Convierte etiquetas categóricas (cadenas o tipos mixtos) en enteros
• Cómo funciona: Asigna un entero único a cada categoría única
• Ejemplo: ['cat', 'dog', 'cat'] → [0, 1, 0]

¿Por qué usar LabelEncoder?

• Muchos algoritmos de ML requieren entradas numéricas
• Almacenamiento y computación eficientes
• Mantiene la naturaleza categórica de los datos

Métodos clave:

• fit(y): Aprende el mapeo de categorías a enteros
• transform(y): Aplica el mapeo aprendido
• fit_transform(y): Combina ambos pasos en una sola llamada
• inverse_transform(y_encoded): Convierte enteros de nuevo a categorías originales

Notas importantes:

• El orden es arbitrario (basado en la primera aparición o en la ordenación)
• No es adecuado para datos ordinales donde el orden importa (use OrdinalEncoder en su lugar)
• Para características (no objetivos), considere OneHotEncoder para datos nominales

Agrega el siguiente código a tu archivo preprocess.py debajo del comentario ## --- Step 5: Encode the target ---. Crearemos una instancia de LabelEncoder y usaremos el método fit_transform(), que combina el ajuste y la transformación en un solo paso.

## --- Step 5: Encode the target ---
encoder = LabelEncoder()
y_encoded = encoder.fit_transform(y)

print("\nOriginal target sample:", y[:5])  ## Show first 5 original labels
print("Encoded target sample:", y_encoded[:5])  ## Show first 5 encoded labels
print("Unique encoded values:", np.unique(y_encoded))  ## Show all unique encoded values

Guarda el archivo y ejecútalo por última vez.

python3 preprocess.py

La salida mostrará que la variable objetivo ha sido codificada. Dado que ya estaba en el formato entero correcto, el resultado es el mismo, pero esto demuestra el proceso que usaría para etiquetas basadas en cadenas.

Shape of features (X): (150, 4)
Shape of target (y): (150,)
Scaler object created: StandardScaler()
Scaler mean: [5.84333333 3.05733333 3.758      1.19933333]
Original data mean: [5.84 3.06 3.76 1.2 ]
Scaled data mean: [-0. -0. -0. -0.]
Scaled data sample:
 [[-0.9   1.02 -1.34 -1.32]
 [-1.14 -0.13 -1.34 -1.32]
 [-1.39  0.33 -1.4  -1.32]
 [-1.51  0.1  -1.28 -1.32]
 [-1.02  1.25 -1.34 -1.32]]

Original target sample: [0 0 0 0 0]
Encoded target sample: [0 0 0 0 0]
Unique encoded values: [0 1 2]

Resumen

¡Felicitaciones por completar el laboratorio! Ha realizado con éxito tareas esenciales de preprocesamiento de datos utilizando scikit-learn.

En este laboratorio, aprendió a:

• Cargar un conjunto de datos estándar de scikit-learn.
• Separar los datos en características (X) y un objetivo (y).
• Escalar características numéricas usando StandardScaler, primero ajustándolo (fit) a los datos para aprender los parámetros y luego transformando (transform) los datos.
• Codificar etiquetas de objetivos categóricos en un formato entero legible por máquina usando LabelEncoder.

Estos pasos de preprocesamiento son fundamentales para construir modelos de aprendizaje automático robustos y de alto rendimiento. Ahora está mejor equipado para preparar sus propios conjuntos de datos para futuros proyectos de aprendizaje automático.