En el mundo del machine learning, los datos crudos son como piedra bruta: su verdadero valor emerge solo cuando los esculpimos. El feature engineering es ese arte transformador que convierte variables simples en poderosos predictores. En este artículo, desvelaremos las técnicas que elevan modelos mediocres a soluciones de alto rendimiento, dominando la creación de variables en Python con enfoques que van más allá de los métodos convencionales.

La Alquimia de los Datos: Por Qué el Feature Engineering Cambia Todo

Andrew Ng, cofundador de Coursera, afirmó: "Aplicar feature engineering es la forma más efectiva de mejorar modelos". Los datos crudos raramente contienen patrones detectables por algoritmos estándar. La magia ocurre cuando:

• Transformamos coordenadas geográficas en distancias a puntos estratégicos
• Convertimos timestamps en patrones temporales ocultos (hora pico, fin de semana)
• Extraemos relaciones no lineales mediante interacciones polinómicas

Un estudio de Kaggle reveló que los top competitors dedican 70-80% de su tiempo a ingeniería de características. No es casualidad: una sola variable bien construida puede aumentar la precisión más que semanas de ajuste de hiperparámetros.

Transformación de Variables Numéricas: Secretos Más Allá del StandardScaler

La normalización es solo el punto de partida. Dominamos variables numéricas con:

            from sklearn.preprocessing import PowerTransformer
            pt = PowerTransformer(method='yeo-johnson')
        df['income_transformed'] = pt.fit_transform(df[['income']])

        df['age_bin'] = pd.qcut(df['age'], q=5, labels=False)

Técnica avanzada: Uso de splines cúbicos para modelar relaciones complejas:

    
    from sklearn.preprocessing import SplineTransformer
    spline = SplineTransformer(degree=3, n_knots=5)
    df[['spline_feat1', 'spline_feat2']] = spline.fit_transform(df[['price']])
    

Categóricas a Numéricas: Codificación Inteligente con Scikit-Learn

Olvida el One-Hot Encoding convencional. Estas técnicas preservan información:

Precaución crítica: Siempre aplica Target Encoding dentro de validación cruzada para evitar data leakage:

    
    from sklearn.model_selection import KFold
    from category_encoders import TargetEncoder

    kf = KFold(n_splits=5)
    df['categoria_encoded'] = 0

    for train_idx, val_idx in kf.split(df):
        encoder = TargetEncoder()
        df.loc[val_idx, 'categoria_encoded'] = encoder.fit_transform(
            df.loc[val_idx, 'categoria'],
            df.loc[train_idx, 'target']
        )
    

Variables Temporales: Extracción de Patrones Ocultos

Un timestamp contiene más información de la que imaginas. Extraemos:

• Componentes cíclicos:

      
          df['hora_sin'] = np.sin(2 * np.pi * df['hora']/24)
          df['hora_cos'] = np.cos(2 * np.pi * df['hora']/24)
      
      

• Eventos especiales: Festivos, eventos deportivos, temporadas
• Diferencias temporales: Días desde último evento

Técnica avanzada: Creación de features de tendencia y estacionalidad con descomposición STL:

    
    from statsmodels.tsa.seasonal import STL

    stl = STL(df['ventas'], period=7)
    result = stl.fit()
    df['tendencia'] = result.trend
    df['estacionalidad'] = result.seasonal
    

Creación de Variables para Texto: Más Allá de TF-IDF

Transformamos lenguaje natural en características poderosas:

            from sentence_transformers import SentenceTransformer
            model = SentenceTransformer('paraphrase-multilingual-MiniLM-L12-v2')
        embeddings = model.encode(df['texto'])

            import textstat
        df['legibilidad'] = df['texto'].apply(textstat.flesch_reading_ease)

Innovación: Uso de topic modeling para crear características temáticas:

    
    from sklearn.decomposition import LatentDirichletAllocation
    from sklearn.feature_extraction.text import CountVectorizer

    vectorizer = CountVectorizer(max_features=1000)
    X = vectorizer.fit_transform(df['texto'])

    lda = LatentDirichletAllocation(n_components=5)
    df_topicos = pd.DataFrame(lda.fit_transform(X),
    columns=[f'topico_{i}' for i in range(5)])
    

Técnicas Avanzadas: Interacciones y Características Polinómicas

La sinergia entre variables crea poderosos predictores:

• Interacciones multiplicativas: df['ingreso_por_edad'] = df['ingreso'] * df['edad']
• Ratios estratégicos: df['deuda_ingreso_ratio'] = df['deuda'] / (df['ingreso'] + 1e-6)
• Combinaciones geográficas: Distancia entre ubicaciones

PolynomialFeatures automatizado con selección inteligente:

    
    from sklearn.preprocessing import PolynomialFeatures
    from sklearn.feature_selection import SelectKBest, f_regression

    # Crear características polinómicas
    poly = PolynomialFeatures(degree=3, include_bias=False)
    X_poly = poly.fit_transform(df[['var1', 'var2']])

    # Seleccionar las mejores
    selector = SelectKBest(score_func=f_regression, k=10)
    X_selected = selector.fit_transform(X_poly, y)
    

Buenas Prácticas y Errores Comunes

Optimizamos nuestro feature engineering evitando trampas:

Herramienta esencial: Feature stores para reutilización:

• Feast: Open source para gestión de características
• Tecton: Plataforma empresarial para feature engineering
• Hopsworks: Plataforma todo-en-uno para ML

Flujo de Trabajo Integral en Python

Implementamos un pipeline reproducible con:

    
    from sklearn.pipeline import Pipeline
    from sklearn.compose import ColumnTransformer
    from sklearn.impute import SimpleImputer
    from sklearn.preprocessing import FunctionTransformer

    # Función personalizada para características temporales
    def extraer_temporales(X):
        df = pd.DataFrame(X, columns=['timestamp'])
        df['hora_sin'] = np.sin(2*np.pi*df['timestamp'].dt.hour/24)
        return df[['hora_sin']].values

    # Pipeline completo
    preprocessor = ColumnTransformer(transformers=[
    ('num', Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='median')),
    ('transform', PowerTransformer())
    ]), ['ingreso', 'edad']),
    ('temp', FunctionTransformer(extraer_temporales), ['timestamp']),
    ('cat', TargetEncoder(), ['ciudad'])
    ])

    # Integración con modelo
    pipeline = Pipeline(steps=[
    ('preprocessor', preprocessor),
    ('model', RandomForestRegressor())
])

Este pipeline garantiza consistencia entre entrenamiento e inferencia, crucial para modelos en producción.

Conclusión: El Arte Científico de la Creación de Variables

El feature engineering es donde la ciencia de datos se convierte en arte. Más que técnicas aisladas, es un proceso creativo fundamentado en conocimiento del dominio y comprensión profunda de los datos. Los métodos que hemos explorado - desde transformaciones numéricas avanzadas hasta embeddings contextuales - representan herramientas que, cuando se aplican con criterio, pueden elevar exponencialmente el rendimiento de nuestros modelos.

Recordemos siempre: una variable bien construida vale más que mil horas de ajuste de hiperparámetros. En el competitivo panorama del machine learning, el dominio del feature engineering no es solo una habilidad deseable, sino la ventaja competitiva definitiva que separa a los practicantes competentes de los verdaderos maestros.

A medida que evolucionan las técnicas, mantenemos un principio fundamental: cada nueva característica debe contar una historia sobre los datos, revelando patrones ocultos y relaciones no evidentes. Ese es el verdadero secreto que transforma datos crudos en predicciones poderosas.