Tutorial ScikitLearn: Ingeniería de características

Creación de nuevas características

La creación de nuevas características es un paso crucial en la ingeniería de características que puede mejorar significativamente el rendimiento de los modelos de aprendizaje automático. Al generar nuevas variables a partir de las existentes, es posible captar relaciones y patrones ocultos que los algoritmos pueden explotar para realizar mejores predicciones.

Una técnica común es combinar variables numéricas o categóricas para crear nuevas características que reflejen interacciones o ratios relevantes. Por ejemplo, en un conjunto de datos que incluye el ingreso y la edad de los individuos, podríamos crear una nueva característica que represente el ingreso per cápita por edad:

import pandas as pd

# Supongamos un DataFrame con las columnas 'ingreso' y 'edad'
data = pd.DataFrame({
    'ingreso': [30000, 45000, 50000, 60000, 70000],
    'edad': [25, 35, 45, 55, 65]
})

# Creamos una nueva característica
data['ingreso_por_edad'] = data['ingreso'] / data['edad']

print(data)

En este ejemplo, hemos creado la característica ingreso_por_edad que podría ser más informativa para el modelo que las variables originales por separado.

Otra técnica es la discretización de variables continuas utilizando el KBinsDiscretizer de Scikit-Learn. Este transformador convierte variables numéricas en categorías discretas, lo que puede ser útil para modelos que se benefician de características categóricas o para captar no linealidades:

from sklearn.preprocessing import KBinsDiscretizer
import numpy as np

# Variable continua
X = np.array([[15],
              [18],
              [21],
              [24],
              [27]])

# Discretizamos en 3 intervalos con frecuencia uniforme
discretizador = KBinsDiscretizer(n_bins=3, encode='ordinal', strategy='quantile', random_state=42)
X_binned = discretizador.fit_transform(X)

print(X_binned)

En este caso, la variable continua se ha transformado en una categórica con tres niveles, lo que puede simplificar la relación con la variable objetivo.

La extracción de características temporales es esencial cuando se trabaja con datos de fecha y hora. A partir de una sola columna temporal, es posible crear múltiples características que capturen patrones estacionales o tendencias:

import pandas as pd

# DataFrame con una columna de fechas
data = pd.DataFrame({
    'fecha': pd.date_range(start='2023-01-01', periods=5, freq='D')
})

# Extraemos características temporales
data['día_semana'] = data['fecha'].dt.dayofweek
data['es_fin_de_semana'] = data['fecha'].dt.dayofweek >= 5
data['semana_año'] = data['fecha'].dt.isocalendar().week

print(data)

Aquí, hemos añadido las características día_semana, es_fin_de_semana y semana_año, que pueden ayudar al modelo a reconocer patrones asociados a días específicos.

El uso del FunctionTransformer permite aplicar funciones personalizadas a los datos dentro de un pipeline de Scikit-Learn. Este transformador es especialmente útil para realizar transformaciones que no están cubiertas por los transformadores predefinidos:

from sklearn.preprocessing import FunctionTransformer
import numpy as np

# Función personalizada para calcular el inverso
def calcular_inverso(X):
    return 1 / X

# Creamos el transformador
transformador_inverso = FunctionTransformer(calcular_inverso)

# Datos de ejemplo
X = np.array([[2], [4], [6], [8], [10]])

# Aplicamos la transformación
X_transformado = transformador_inverso.transform(X)

print(X_transformado)

Este ejemplo muestra cómo crear una nueva característica que es el inverso de la variable original, lo que puede ser útil si la relación con la variable objetivo es no lineal.

La creación de características basadas en estadísticas agregadas es otra estrategia efectiva. Cuando se dispone de datos jerárquicos, como transacciones por cliente, calcular métricas como el gasto total o medio puede aportar información valiosa:

import pandas as pd

# DataFrame con transacciones de clientes
data = pd.DataFrame({
    'cliente_id': [1, 1, 2, 2, 3],
    'transacción_id': [101, 102, 103, 104, 105],
    'importe': [100, 150, 200, 250, 300]
})

# Calculamos el gasto total por cliente
gasto_por_cliente = data.groupby('cliente_id')['importe'].sum().reset_index()
gasto_por_cliente.rename(columns={'importe': 'gasto_total'}, inplace=True)

# Unimos la nueva característica al DataFrame original
data = data.merge(gasto_por_cliente, on='cliente_id')

print(data)

Con la nueva característica gasto_total, el modelo puede aprender patrones basados en el comportamiento agregado de cada cliente.

Es posible también utilizar transformaciones basadas en funciones matemáticas para realzar ciertas características de los datos. Aunque las transformaciones logarítmicas y polinómicas se abordan en secciones específicas, otras funciones como la raíz cuadrada o las exponenciales pueden ser aplicadas:

import numpy as np
import pandas as pd

# DataFrame con una variable skewed
data = pd.DataFrame({
    'valor': [1, 4, 9, 16, 25]
})

# Aplicamos la transformación de la raíz cuadrada
data['raiz_cuadrada'] = np.sqrt(data['valor'])

print(data)

La aplicación de la función raíz cuadrada puede ayudar a reducir la asimetría de la distribución de la variable, lo que puede mejorar el rendimiento de algunos algoritmos.

La creación de nuevas características debe hacerse con cautela. Es fundamental evaluar el impacto de las características añadidas en el rendimiento del modelo y evitar el sobreajuste. Herramientas como la validación cruzada y los métodos de selección de características pueden ayudar a determinar la utilidad de las nuevas variables.

Es importante integrar la creación de nuevas características en el pipeline de preprocesamiento para garantizar que las transformaciones se apliquen correctamente durante el entrenamiento y la producción. Scikit-Learn facilita esta integración mediante clases y funciones que permiten construir pipelines eficientes y reproducibles.

Polynomial Features

Las características polinomiales son una técnica de ingeniería de características que permite transformar variables independientes para capturar relaciones no lineales en modelos de regresión. Al elevar las variables a diferentes potencias, se pueden modelar patrones más complejos que no se representan con una relación lineal simple.

En Scikit-Learn, el transformador PolynomialFeatures del módulo sklearn.preprocessing facilita la generación automática de estas nuevas características. Este transformador crea nuevas variables que son potencias de las variables originales hasta un grado especificado.

Uso básico de PolynomialFeatures:

Para utilizar este transformador, es necesario importarlo y definir el grado del polinomio que se desea generar.

from sklearn.preprocessing import PolynomialFeatures

# Definimos el grado del polinomio
grado = 2
poly = PolynomialFeatures(degree=grado, include_bias=False)

El parámetro degree especifica el grado máximo de las potencias. El argumento include_bias=False indica que no se añadirá una columna de unos (el término de sesgo), ya que los modelos de regresión suelen añadir este término automáticamente.

Ejemplo práctico:

Supongamos que tenemos una variable independiente X y queremos generar características polinomiales de grado 2.

import numpy as np

# Datos de ejemplo
X = np.array([[1],
              [2],
              [3],
              [4],
              [5]])

# Generamos las características polinomiales
X_poly = poly.fit_transform(X)

print("Características polinomiales:")
print(X_poly)

La salida X_poly contiene las variables X y X^2. Estas nuevas características pueden ser usadas para ajustar modelos más flexibles.

Aplicación en regresión polinomial:

La regresión polinomial es una extensión de la regresión lineal que utiliza características polinomiales para modelar relaciones no lineales.

from sklearn.linear_model import LinearRegression
import matplotlib.pyplot as plt

# Supongamos una variable objetivo y
y = np.array([2, 3, 5, 7, 11])

# Ajustamos el modelo de regresión polinomial
modelo = LinearRegression()
modelo.fit(X_poly, y)

# Predicciones
X_fit = np.linspace(1, 5, 100).reshape(-1, 1)
X_fit_poly = poly.transform(X_fit)
y_pred = modelo.predict(X_fit_poly)

# Visualización
plt.scatter(X, y, color='blue', label='Datos reales')
plt.plot(X_fit, y_pred, color='red', label='Predicción polinomial')
plt.xlabel('X')
plt.ylabel('y')
plt.legend()
plt.show()

Ventajas y consideraciones:

Las características polinomiales permiten a los modelos lineales capturar no linealidades sin necesidad de cambiar a modelos más complejos. Sin embargo, aumentar el grado polinomial puede llevar a modelos que sobreajustan los datos de entrenamiento. Es esencial equilibrar la complejidad del modelo y su capacidad de generalización.

Regularización:

Para controlar el sobreajuste, es común aplicar técnicas de regularización como la regresión Ridge o Lasso. Estas penalizan los coeficientes del modelo, reduciendo la varianza sin aumentar el sesgo en exceso.

from sklearn.linear_model import Ridge

# Ajustamos un modelo Ridge con características polinomiales
modelo_ridge = Ridge(alpha=1.0)
modelo_ridge.fit(X_poly, y)

Generación de características polinomiales en múltiples variables:

Cuando se trabaja con varias variables independientes, PolynomialFeatures genera todas las combinaciones polinómicas de los features hasta el grado especificado.

# Datos con múltiples variables
X_multi = np.array([[1, 2],
                    [2, 3],
                    [3, 4],
                    [4, 5],
                    [5, 6]])

# Generamos características polinomiales de grado 2
poly_multi = PolynomialFeatures(degree=2, include_bias=False)
X_multi_poly = poly_multi.fit_transform(X_multi)

print("Características polinomiales para múltiples variables:")
print(poly_multi.get_feature_names_out())

La salida incluye términos como X1, X2, X1^2, X1 X2, X2^2. Estas características permiten capturar relaciones más complejas entre las variables.

Nota importante:

La generación de todas las combinaciones polinomiales puede producir un gran número de características, especialmente con un alto número de variables y grados polinomiales elevados. Esto puede aumentar significativamente el tiempo de cómputo y requerir más memoria. Es importante considerar esto al utilizar PolynomialFeatures.

Integración con Pipelines:

Para mantener un flujo de trabajo ordenado, es recomendable integrar PolynomialFeatures en un Pipeline. Esto permite combinar preprocesamiento y modelado en un solo objeto.

from sklearn.pipeline import Pipeline

# Definimos el pipeline
modelo_polinomial = Pipeline([
    ('polynomial_features', PolynomialFeatures(degree=2, include_bias=False)),
    ('linear_regression', LinearRegression())
], memory = None)

# Ajustamos el modelo
modelo_polinomial.fit(X_multi, y)

Ejemplo completo:

import numpy as np
import matplotlib.pyplot as plt
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LinearRegression

# Configuración de la semilla y generador de números aleatorios
seed = 0
generator = np.random.default_rng(seed=seed)

# Datos sintéticos
X = np.sort(generator.random(30).reshape(-1, 1) * 10, axis=0)
y = np.sin(X).ravel() + generator.normal(scale=0.5, size=30)

# Pipeline con características polinomiales y regresión lineal
grado_polinomio = 4
modelo = Pipeline([
    ('polynomial_features', PolynomialFeatures(degree=grado_polinomio, include_bias=False)),
    ('linear_regression', LinearRegression())
], memory = None)

# Ajustamos el modelo
modelo.fit(X, y)

# Predicciones
X_test = np.linspace(0, 10, 100).reshape(-1, 1)
y_pred = modelo.predict(X_test)

# Visualización
plt.scatter(X, y, color='blue', label='Datos de entrenamiento')
plt.plot(X_test, y_pred, color='red', label=f'Predicción polinomial (grado {grado_polinomio})')
plt.xlabel('X')
plt.ylabel('y')
plt.legend(loc='best')
plt.show()

En este ejemplo, se ha ajustado un modelo de regresión polinomial de grado 4 que captura adecuadamente la relación no lineal entre X e y. La integración de PolynomialFeatures en un pipeline simplifica el proceso y asegura que las transformaciones se apliquen correctamente durante el entrenamiento y las predicciones.

Interaction Features

En el aprendizaje automático, las características de interacción son variables que representan la combinación de dos o más características originales para capturar relaciones no lineales entre ellas. Estas interacciones pueden proporcionar información valiosa que los modelos pueden utilizar para mejorar las predicciones.

En Scikit-Learn, es posible generar características de interacción utilizando el transformador PolynomialFeatures con el parámetro interaction_only=True. Esto permite crear nuevas características que son el producto de combinaciones de las variables originales, sin incluir los términos polinomiales.

Uso de PolynomialFeatures para generar características de interacción:

from sklearn.preprocessing import PolynomialFeatures
import numpy as np

# Datos de ejemplo
X = np.array([[2, 3],
              [3, 5],
              [5, 7],
              [7, 11]])

# Creamos el transformador para características de interacción
interaction = PolynomialFeatures(degree=2, interaction_only=True, include_bias=False)

# Generamos las características de interacción
X_interaction = interaction.fit_transform(X)

print("Características originales:")
print(X)
print("\nCaracterísticas de interacción:")
print(X_interaction)

En este ejemplo, hemos generado nuevas características que representan las interacciones entre las variables originales. El resultado X_interaction incluye las columnas originales y los productos entre ellas, es decir, $( X_1 \times X_2 )$.

Interpretación de las características de interacción:

Las características de interacción permiten al modelo capturar efectos conjuntos de variables que no son evidentes cuando se consideran individualmente. Por ejemplo, en un conjunto de datos con las variables edad e ingreso, la interacción entre ambas podría ser relevante para predecir un comportamiento específico.

Aplicación en un modelo de regresión:

Integremos las características de interacción en un pipeline para ajustar un modelo de regresión lineal.

from sklearn.linear_model import LinearRegression
from sklearn.pipeline import Pipeline

# Creamos el pipeline con las características de interacción y el modelo
modelo_interaccion = Pipeline([
    ('interaction', PolynomialFeatures(degree=2, interaction_only=True, include_bias=False)),
    ('regresion_lineal', LinearRegression())
], memory = None)

# Variable objetivo de ejemplo
y = np.array([13, 23, 37, 59])

# Ajustamos el modelo
modelo_interaccion.fit(X, y)

# Coeficientes del modelo
coeficientes = modelo_interaccion.named_steps['regresion_lineal'].coef_
intercepto = modelo_interaccion.named_steps['regresion_lineal'].intercept_

print("Coeficientes del modelo:")
print(coeficientes)
print("\nIntercepto del modelo:")
print(intercepto)

En este código, hemos creado un pipeline que primero genera las características de interacción y luego ajusta un modelo de regresión lineal. Los coeficientes obtenidos reflejan la importancia de cada característica, incluyendo las interacciones.

Visualización del impacto de las interacciones:

Para entender mejor cómo las características de interacción afectan al modelo, podemos comparar las predicciones con y sin estas características.

import matplotlib.pyplot as plt

# Modelo sin interacciones
modelo_simple = LinearRegression()
modelo_simple.fit(X, y)

# Predicciones
y_pred_simple = modelo_simple.predict(X)
y_pred_interaction = modelo_interaccion.predict(X)

# Visualización
plt.scatter(range(len(y)), y, color='blue', label='Valores reales')
plt.plot(range(len(y)), y_pred_simple, color='red', label='Predicción sin interacciones')
plt.plot(range(len(y)), y_pred_interaction, color='green', linestyle='--', label='Predicción con interacciones')
plt.xlabel('Índice')
plt.ylabel('Valor objetivo')
plt.legend()
plt.show()

En este gráfico, observamos cómo el modelo con características de interacción puede ajustar mejor los datos al capturar relaciones que el modelo simple no detecta.

Consideraciones al utilizar características de interacción:

• Dimensionalidad: La introducción de interacciones aumenta el número de características, lo que puede llevar a problemas de sobreajuste si el conjunto de datos es pequeño.
• Interpretabilidad: Los modelos con muchas interacciones pueden ser más difíciles de interpretar, ya que las relaciones se vuelven más complejas.
• Selección de características: Es recomendable aplicar técnicas de selección de características para identificar cuáles interacciones aportan valor al modelo.

Ejemplo con selección de características:

Utilizaremos SelectKBest para seleccionar las mejores características basadas en una prueba estadística.

from sklearn.feature_selection import SelectKBest, f_regression

# Generamos todas las características de interacción
X_full = PolynomialFeatures(degree=2, interaction_only=True, include_bias=False).fit_transform(X)

# Seleccionamos las dos mejores características
selector = SelectKBest(score_func=f_regression, k=2)
X_selected = selector.fit_transform(X_full, y)

print("Características seleccionadas:")
print(X_selected)

Este proceso nos permite enfocarnos en las interacciones más significativas, reduciendo la complejidad del modelo.

Interacciones en variables categóricas:

Las características de interacción también son útiles cuando se trabaja con variables categóricas codificadas. Al combinar categorías, podemos descubrir patrones que no son evidentes.

import pandas as pd
from sklearn.preprocessing import OneHotEncoder

# Datos categóricos de ejemplo
data = pd.DataFrame({
    'Color': ['Rojo', 'Azul', 'Verde', 'Rojo'],
    'Forma': ['Círculo', 'Cuadrado', 'Círculo', 'Triángulo']
})

# Codificación one-hot
encoder = OneHotEncoder(sparse=False)
X_categorico = encoder.fit_transform(data)

# Generación de interacciones
X_interaccion_categ = PolynomialFeatures(degree=2, interaction_only=True, include_bias=False).fit_transform(X_categorico)

print("Interacciones categóricas:")
print(X_interaccion_categ)

En este ejemplo, hemos creado interacciones entre categorías, lo que puede ser especialmente útil en modelos que pueden manejar un gran número de características.

Conclusión sobre el uso de características de interacción:

Las características de interacción son una herramienta poderosa para mejorar la capacidad predictiva de los modelos al capturar relaciones complejas entre variables. Sin embargo, es importante utilizarlas con criterio, considerando el equilibrio entre la complejidad del modelo y su capacidad de generalización.

Estrategias para manejar la complejidad:

• Regularización: Aplicar técnicas como Ridge o Lasso para penalizar los coeficientes y prevenir el sobreajuste.
• PCA: Utilizar Análisis de Componentes Principales para reducir la dimensionalidad después de generar interacciones.
• Muestreo: Si se cuenta con muchos datos, es posible limitar el conjunto de entrenamiento para manejar mejor el número de características.

Ejemplo de regularización con interacciones:

from sklearn.linear_model import Lasso

# Pipeline con Lasso y características de interacción
modelo_lasso = Pipeline([
    ('interaction', PolynomialFeatures(degree=2, interaction_only=True, include_bias=False)),
    ('lasso_regression', Lasso(alpha=0.1))
], memory = None)

# Ajustamos el modelo
modelo_lasso.fit(X, y)

# Coeficientes del modelo Lasso
coeficientes_lasso = modelo_lasso.named_steps['lasso_regression'].coef_

print("Coeficientes tras regularización Lasso:")
print(coeficientes_lasso)

La regularización Lasso ayuda a reducir algunos coeficientes a cero, simplificando el modelo y mejorando su capacidad de generalización.

Implementación en un pipeline completo:

Integrar las características de interacción en un pipeline permite automatizar el proceso y garantizar la reproducibilidad.

from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error

# División de datos
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

# Pipeline completo
pipeline = Pipeline([
    ('interaction', PolynomialFeatures(degree=2, interaction_only=True, include_bias=False)),
    ('regresion_lineal', LinearRegression())
], memory = None)

# Entrenamiento
pipeline.fit(X_train, y_train)

# Predicción y evaluación
y_pred = pipeline.predict(X_test)
error = mean_squared_error(y_test, y_pred)

print("Error cuadrático medio en test:")
print(error)

Con este enfoque, podemos evaluar el impacto de las características de interacción en el rendimiento del modelo de manera estructurada.

Conclusiones finales:

Las características de interacción son especialmente útiles en modelos lineales, donde permiten capturar relaciones no lineales sin recurrir a algoritmos más complejos. Es fundamental experimentar y validar si estas interacciones aportan valor al modelo en cada caso específico.

Log Transformation

La transformación logarítmica es una técnica de ingeniería de características utilizada para estabilizar la varianza de una variable y reducir su asimetría. Al aplicar el logaritmo a las características numéricas, es posible transformar distribuciones altamente sesgadas en distribuciones más cercanas a la normalidad, lo que puede mejorar el rendimiento de los modelos de aprendizaje automático.

Es especialmente útil cuando se trabaja con variables que presentan una distribución sesgada a la derecha, con valores extremos o outliers que afectan negativamente al modelo. La transformación logarítmica atenúa el efecto de estos valores al comprimir la escala en el extremo superior.

En Scikit-Learn, la implementación de la transformación logarítmica se puede realizar utilizando el FunctionTransformer, que permite aplicar funciones personalizadas a los datos de manera consistente dentro de un pipeline.

Aplicación de la transformación logarítmica con FunctionTransformer:

import numpy as np
import pandas as pd
from sklearn.preprocessing import FunctionTransformer

# Datos de ejemplo
data = pd.DataFrame({
    'ingreso': [25000, 35000, 50000, 75000, 120000]
})

# Definimos la función logarítmica
transformacion_log = FunctionTransformer(np.log1p, feature_names_out='one-to-one')

# Aplicamos la transformación
data['log_ingreso'] = transformacion_log.transform(data[['ingreso']])

print(data)

En este ejemplo, hemos aplicado la función np.log1p, que calcula el logaritmo natural de $( 1 + x )$. Esta función es preferible cuando los datos pueden contener valores cero, ya que np.log(0) no está definido.

El resultado es una nueva columna log_ingreso que contiene la transformación logarítmica del ingreso. Esta característica puede ser utilizada por los modelos para capturar relaciones que no son evidentes en la escala original.

Visualización del efecto de la transformación:

Es importante entender cómo la transformación afecta a la distribución de la variable. Podemos visualizarlo utilizando histogramas.

import matplotlib.pyplot as plt

# Gráfico de la variable original
plt.subplot(1, 2, 1)
plt.hist(data['ingreso'], bins=5, color='skyblue')
plt.title('Distribución original')
plt.xlabel('Ingreso')
plt.ylabel('Frecuencia')

# Gráfico de la variable transformada
plt.subplot(1, 2, 2)
plt.hist(data['log_ingreso'], bins=5, color='salmon')
plt.title('Distribución Log Transformada')
plt.xlabel('Log(Ingreso)')
plt.ylabel('Frecuencia')

plt.tight_layout()
plt.show()

La visualización muestra cómo la transformación logarítmica reduce la asimetría de la distribución, acercándola a una forma más simétrica.

Una alternativa es el uso de la función raíz, np.sqrt, también reduce la asimetría, pero de una forma más suave que la función logarítmica.

Nota: suele ser habitual realizar estas transformaciones antes de estandarizar los datos.

Integración en un Pipeline de Scikit-Learn:

Para garantizar que el preprocesamiento se aplique de forma consistente en entrenamiento y predicción, es recomendable integrar la transformación en un Pipeline.

from sklearn.pipeline import Pipeline
from sklearn.linear_model import LinearRegression

# Definimos el pipeline
pipeline = Pipeline([
    ('log_transform', FunctionTransformer(np.log1p, feature_names_out='one-to-one')),
    ('regresion_lineal', LinearRegression())
], memory = None)

# Variables independientes y dependiente
X = data[['ingreso']]
y = [2, 3, 5, 7, 11]  # Variable objetivo de ejemplo

# Ajustamos el modelo
pipeline.fit(X, y)

# Realizamos predicciones
nuevos_datos = pd.DataFrame({'ingreso': [65000, 85000]})
predicciones = pipeline.predict(nuevos_datos)

print("Predicciones:")
print(predicciones)

Con este enfoque, la transformación se aplica automáticamente antes del ajuste del modelo, asegurando la consistencia en todas las etapas.

Consideraciones al aplicar la transformación logarítmica:

• Datos negativos o cero: La función logarítmica no está definida para valores negativos y tiene problemas con el cero. Por ello, se utiliza np.log1p para evitar estos inconvenientes.
• Reversión de la transformación: Si es necesario interpretar los resultados en la escala original, se debe aplicar la función inversa np.expm1, que calcula $( e^{x} - 1 )$.

  # Inversión de la transformación
  inversa_log = FunctionTransformer(np.expm1, feature_names_out='one-to-one')

  # Valor transformado
  valor_transformado = data['log_ingreso'].iloc[0]

  # Revertimos la transformación
  valor_original = inversa_log.transform([[valor_transformado]])

  print("Valor original:")
  print(valor_original)

• Interpretabilidad: Al transformar las variables, la interpretación de los coeficientes en modelos lineales cambia. Es importante tenerlo en cuenta al analizar los resultados.

Aplicación simultánea en múltiples características:

Si se desean transformar varias columnas, se puede utilizar el ColumnTransformer para aplicar la transformación logarítmica de forma selectiva.

from sklearn.compose import ColumnTransformer

# Datos de ejemplo con múltiples características
data_multi = pd.DataFrame({
    'ingreso': [25000, 35000, 50000, 75000, 120000],
    'gastos': [20000, 15000, 30000, 50000, 60000],
    'edad': [25, 35, 45, 55, 65]
})

# Definimos las transformaciones por columna
transformador_columnas = ColumnTransformer(transformers=[
    ('log_ingreso_gastos', FunctionTransformer(np.log1p, feature_names_out='one-to-one'), ['ingreso', 'gastos']),
    ('passthrough', 'passthrough', ['edad'])
])

# Aplicamos las transformaciones
data_transformada = transformador_columnas.fit_transform(data_multi)

# Convertimos a DataFrame para visualizar
nombres_columnas = transformador_columnas.get_feature_names_out()
data_transformada = pd.DataFrame(data_transformada, columns=nombres_columnas)

print("Datos transformados:")
print(data_transformada)

En este ejemplo, hemos aplicado la transformación logarítmica solo a las columnas ingreso y gastos, manteniendo edad sin cambios.

Detección de variables que requieren transformación:

No todas las variables numéricas necesitan una transformación logarítmica. Es aconsejable analizar la distribución de cada variable y evaluar su asimetría.

# Cálculo de la asimetría
asimetria_ingreso = data_multi['ingreso'].skew()
asimetria_gastos = data_multi['gastos'].skew()
asimetria_edad = data_multi['edad'].skew()

print("Asimetría de las variables:")
print(f"Ingreso: {asimetria_ingreso}")
print(f"Gastos: {asimetria_gastos}")
print(f"Edad: {asimetria_edad}")

Las variables con un coeficiente de asimetría mayor que 1 o menor que -1 se consideran altamente sesgadas y pueden beneficiarse de una transformación logarítmica.

Alternativas a la transformación logarítmica:

En algunos casos, otras transformaciones como la raíz cuadrada o la transformación Box-Cox pueden ser más apropiadas. La elección depende de la naturaleza de la asimetría y de los valores presentes en los datos.

from sklearn.preprocessing import PowerTransformer

# Aplicación de la transformación Box-Cox
transformador_boxcox = PowerTransformer(method='box-cox', standardize=False)

# Solo se puede aplicar a valores positivos
data_positiva = data_multi[['ingreso', 'gastos']]
data_boxcox = transformador_boxcox.fit_transform(data_positiva)

print("Datos transformados con Box-Cox:")
print(data_boxcox)

La transformación Box-Cox encuentra el mejor parámetro lambda para aproximar los datos a una distribución normal.

La transformación logarítmica es una herramienta eficaz para mejorar la calidad de los datos y, por ende, el rendimiento de los modelos. Al reducir la asimetría y estabilizar la varianza, se facilita el aprendizaje de los algoritmos y se potencia la robustez de las predicciones.

Es fundamental integrar las transformaciones en el flujo de trabajo de preprocesamiento, asegurando que se aplican de manera consistente y automatizada. El uso de FunctionTransformer y Pipeline en Scikit-Learn facilita esta integración y promueve buenas prácticas en el desarrollo de modelos.