Introducción al feature engineering en Machine Learning

El feature engineering es una de las etapas más críticas en proyectos de Inteligencia Artificial y Machine Learning. Consiste en transformar, seleccionar o crear variables (o features) que permitan a los modelos aprender de forma más precisa y eficiente. Sin embargo, el proceso puede volverse rápidamente complejo y repetitivo, especialmente al trabajar con grandes datasets o pipelines modulares.

Python, como lenguaje predominante en IA, ofrece múltiples recursos para simplificar y optimizar esta etapa. Entre ellos, los property decorators son una característica avanzada que facilita la encapsulación de la lógica de transformación de features, permitiendo mantener el código limpio, modular y eficiente.

¿Qué son los Property Decorators y cómo aplican en IA?

Los property decorators en Python son una forma de convertir métodos de una clase en atributos calculados, evitando la necesidad de llamar explícitamente a métodos para acceder a datos derivados. Esto resulta ideal para el feature engineering porque permite definir features computados bajo demanda, garantizando que sus valores se calculen solo cuando se necesitan y permaneciendo actualizados con el estado interno del objeto.

En contexto de IA, los property decorators simplifican la transformación de variables, por ejemplo, creación de nuevas columnas basadas en combinaciones o agregaciones de otras, normalización, codificación o extracción de características complejas. Además, mejoran la mantenibilidad y testeo del código al evitar duplicaciones y hacer evidente qué procesos generan cada feature.

Implementación avanzada: Feature Engineering con Property Decorators

Analicemos un ejemplo sofisticado para un dataset de tabular data, integrando type hints, validaciones y caching personalizado con @property y @functools.cached_property para optimizar el cómputo.

import functools
import pandas as pd
from typing import Optional

class FeatureEngineering:
    def __init__(self, data: pd.DataFrame):
        self._data = data

    @property
    def age(self) -> pd.Series:
        # Asumamos que la columna fecha de nacimiento es 'dob'
        if 'dob' not in self._data.columns:
            raise ValueError("La columna 'dob' no está presente en el dataset")
        current_year = 2024
        # Extraemos el año y calculamos la edad
        return current_year - pd.to_datetime(self._data['dob']).dt.year

    @functools.cached_property
    def age_group(self) -> pd.Series:
        # Clasificación en grupos: joven, adulto, senior
        bins = [0, 18, 60, 100]
        labels = ['joven', 'adulto', 'senior']
        age = self.age
        return pd.cut(age, bins=bins, labels=labels, right=False)

    @property
    def income_log(self) -> pd.Series:
        # Transformación logarítmica de ingreso para suavizar
        import numpy as np
        if 'income' not in self._data.columns:
            raise ValueError("La columna 'income' no está presente en el dataset")
        income = self._data['income']
        return income.apply(lambda x: np.log(x + 1))  # +1 para evitar log(0)

    @functools.cached_property
    def interaction_term(self) -> pd.Series:
        # Feature que multiplica income_log por edad
        return self.income_log * self.age

    def get_all_features(self) -> pd.DataFrame:
        # Método que retorna un dataframe con todos los features calculados
        return pd.DataFrame({
            'age': self.age,
            'age_group': self.age_group,
            'income_log': self.income_log,
            'interaction_term': self.interaction_term
        })

Este diseño permite que cada feature sea accesible como un atributo del objeto, recalculándose sólo bajo demanda y utilizando el caching cuando conviene. Además, al usar type hints, se facilita la integración con entornos de desarrollo modernos con autocompletado y validación estática, importante para evitar bugs en pipelines complejos.

Integración con pipelines PyTorch y TensorFlow

Cuando se trabaja con deep learning, preparar batches de datos con features transformados es clave para el rendimiento y la escalabilidad. Encapsular toda la lógica de feature engineering en clases con properties facilita mucho la integración con Dataset personalizados en PyTorch o pipelines tf.data en TensorFlow.

Ejemplo integración con PyTorch Dataset

import torch
from torch.utils.data import Dataset

class CustomDataset(Dataset):
    def __init__(self, raw_data: pd.DataFrame):
        self.fe = FeatureEngineering(raw_data)
        self.features = self.fe.get_all_features()
        # Convertimos features a tensores
        self.X = torch.tensor(self.features[['age', 'income_log', 'interaction_term']].values, dtype=torch.float32)
        self.y = torch.tensor(raw_data['target'].values, dtype=torch.float32)

    def __len__(self):
        return len(self.y)

    def __getitem__(self, idx):
        return self.X[idx], self.y[idx]

Este patrón permite que la transformación de features sea reutilizable, modular y fácilmente testeable. Además, en caso de que el feature engineering requiera acceso a datos o cálculos costosos, el uso de cached_property evita recomputaciones innecesarias durante el entrenamiento.

Comparativa: Uso de property decorators vs métodos tradicionales

Mejores prácticas y consideraciones

1. Evitar computación pesada en @property sin caching: Para cálculos costosos, usar @cached_property o explicit caching para evitar recomputaciones.
2. Type hints: Añadir hints ayuda a la documentación automática, reducción de errores y facilita el trabajo en equipo.
3. Validaciones y control de errores: Implementar chequeos en properties para garantizar integridad de datos y evitar fallos inesperados.
4. Desacoplar lógica: Mantener las transformaciones dentro del objeto feature engineering, que puede probarse de forma aislada.
5. Documentación: Cada feature debe estar documentado para aclarar su propósito y método de cálculo.
6. Integración con batching: Ajustar las properties para que funcionen bien con operaciones vectorizadas, optimizando pipelines para GPU si aplica.

Conclusión

Los property decorators en Python ofrecen un mecanismo poderoso y elegante para implementar feature engineering en proyectos de IA y Machine Learning. Permiten encapsular la lógica de transformación de forma clara, modular, eficiente y fácilmente integrable con otros componentes del pipeline, como datasets personalizados y modelos.

Al aprovechar características avanzadas como @cached_property y type hints, podemos asegurar que las transformaciones se calculen sólo cuando sean necesarias, reduciendo el overhead computacional y facilitando la mantenibilidad del código.

En resumen, Python no sólo brinda librerías potentes para IA, sino que sus características idiomáticas y patrones de diseño, como los property decorators, habilitan soluciones más limpias y optimizadas para los retos del feature engineering en el desarrollo de modelos de inteligencia artificial.