Tutorial TensorFlow: Generación de nuevas características

¿Qué es la ingeniería de características o Feature Engineering?

La ingeniería de características es un componente esencial en el desarrollo de modelos de aprendizaje automático. Consiste en transformar, crear y seleccionar variables a partir de los datos originales para mejorar la capacidad predictiva de los modelos. Este proceso tiene como objetivo principal proporcionar al modelo información más relevante y representativa, lo que facilita un aprendizaje más efectivo.

Principales técnicas de ingeniería de características

• Transformación de datos: Esta técnica aplica funciones matemáticas a las características existentes para ajustarlas a un formato más adecuado. Por ejemplo:
  • Escalado de valores numéricos.
  • Transformaciones logarítmicas para manejar distribuciones sesgadas.
• Creación de nuevas características: Implica derivar o combinar variables para capturar patrones ocultos en los datos. Por ejemplo:
  • En un problema de predicción de precios de viviendas, se puede crear una nueva característica que sea la relación entre el tamaño del terreno y el tamaño de la vivienda. Esto proporciona una métrica más informativa que puede mejorar las predicciones del modelo.
• Selección de características: Este paso busca identificar y retener únicamente las variables más relevantes, eliminando aquellas redundantes o con poco valor predictivo. Esto mejora:
  • La eficiencia del modelo.
  • La capacidad de generalización al reducir el riesgo de sobreajuste.

Herramientas y ejemplo práctico

Herramientas como TensorFlow facilitan la implementación de técnicas de ingeniería de características mediante sus APIs avanzadas para la manipulación y transformación de datos. Por ejemplo, utilizando las capas de preprocesamiento en Keras, es posible normalizar datos o codificar variables categóricas directamente dentro del modelo.

A continuación, un ejemplo práctico que normaliza una característica numérica antes de alimentarla al modelo:

import tensorflow as tf
from tensorflow.keras import layers, models

# Definición del modelo con preprocesamiento de características
normalization_layer = layers.Normalization()  # Crear la capa de normalización
model = models.Sequential([
    layers.Input(shape=(10,)),          # Entrada con 10 características
    normalization_layer,                # Normalización de características
    layers.Dense(64, activation='relu'), # Capa oculta
    layers.Dense(1)                     # Capa de salida
])

# Datos de ejemplo
data = tf.random.normal((1000, 10))

# Ajustar la capa de normalización con los datos
normalization_layer.adapt(data) 

# Compilación y entrenamiento del modelo
model.compile(optimizer='adam', loss='mse')
model.fit(data, tf.random.normal((1000, 1)), epochs=10)

En este ejemplo:

• La capa Normalization ajusta las características numéricas para que tengan una media cercana a 0 y una desviación estándar de 1.
• Esto ayuda a que el modelo entrene de manera más eficiente al garantizar que las características estén en una escala uniforme.

Beneficios de la ingeniería de características

• Mejora de la eficiencia del modelo: Al eliminar variables redundantes y transformar los datos, se reduce la complejidad computacional del modelo.
• Facilitación del entrenamiento: La normalización y escalado ayudan a evitar problemas relacionados con magnitudes desiguales en las características, lo que acelera la convergencia durante el entrenamiento.
• Reducción del riesgo de sobreajuste: Al centrarse solo en características relevantes, el modelo se generaliza mejor en datos no vistos.
• Adaptabilidad a diferentes tipos de datos: Con la creación de nuevas características, el modelo puede aprender patrones complejos ocultos en los datos originales.

Técnicas de transformación de datos

Las técnicas de transformación de datos son esenciales para preparar los datos de entrada de manera que mejoren el rendimiento y la eficiencia de los modelos de aprendizaje automático. Estas técnicas permiten modificar las características existentes o crear nuevas representaciones de los datos, facilitando así que los modelos capturen patrones más complejos y relevantes.

Una de las técnicas más comunes es la transformación logarítmica, que se utiliza para manejar distribuciones sesgadas. Al aplicar el logaritmo a una característica, se puede reducir la asimetría y estabilizar la varianza, lo que mejora la capacidad del modelo para aprender relaciones lineales. En TensorFlow, esta transformación se puede implementar utilizando funciones de TensorFlow o capas personalizadas. Por ejemplo:

import tensorflow as tf
from tensorflow.keras import layers, models

def log_transform(x):
    return tf.math.log(x + 1)

model = models.Sequential([
    layers.Input(shape=(10,)),
    layers.Lambda(log_transform),
    layers.Dense(64, activation='relu'),
    layers.Dense(1)
])

model.compile(optimizer='adam', loss='mse')

Otra técnica relevante es la transformación polinómica, que extiende las características originales a potencias superiores, permitiendo al modelo capturar interacciones no lineales entre variables. TensorFlow facilita la creación de características polinómicas mediante operaciones tensoriales. Por ejemplo:

import tensorflow as tf
from tensorflow.keras import layers, models

class PolynomialFeatures(layers.Layer):
    def __init__(self, degree=2, **kwargs):
        super(PolynomialFeatures, self).__init__(**kwargs)
        self.degree = degree

    def call(self, inputs):
        features = [inputs]
        for d in range(2, self.degree + 1):
            features.append(tf.pow(inputs, d))
        return tf.concat(features, axis=1)

model = models.Sequential([
    layers.Input(shape=(10,)),
    PolynomialFeatures(degree=3),
    layers.Dense(64, activation='relu'),
    layers.Dense(1)
])

model.compile(optimizer='adam', loss='mse')

La discretización o binning de variables continuas transforma características numéricas en categorías discretas, lo que puede ser útil para manejar relaciones no lineales y mejorar la interpretabilidad del modelo. TensorFlow permite realizar binning mediante la creación de histogramas o utilizando capas personalizadas. Un ejemplo sencillo es:

import tensorflow as tf
from tensorflow.keras import layers, models

def binning(x, bins):
    return tf.raw_ops.Bucketize(input=x, boundaries=bins)

model = models.Sequential([
    layers.Input(shape=(1,)),
    layers.Lambda(lambda x: binning(x, [10, 20, 30])),
    layers.Dense(64, activation='relu'),
    layers.Dense(1)
])

model.compile(optimizer='adam', loss='mse')

Otra técnica importante es la transformación de potencias, como la raíz cuadrada o la transformación Box-Cox, que ayuda a estabilizar la varianza y mejorar la normalidad de las distribuciones. Estas transformaciones pueden implementarse utilizando operaciones matemáticas de TensorFlow o integrarlas en las capas del modelo.

Finalmente, las transformaciones de agrupamiento permiten agrupar características similares o relacionadas, reduciendo la dimensionalidad y resaltando patrones importantes. Por ejemplo, utilizando embeddings para variables categóricas en problemas de alta cardinalidad, se puede representar cada categoría como un vector denso de dimensiones menores, facilitando así el aprendizaje por parte del modelo.

import tensorflow as tf
from tensorflow.keras import layers, models

model = models.Sequential([
    layers.Input(shape=(1,)),
    layers.Embedding(input_dim=1000, output_dim=64),
    layers.Flatten(),
    layers.Dense(64, activation='relu'),
    layers.Dense(1)
])

model.compile(optimizer='adam', loss='mse')

Estas técnicas de transformación de datos, cuando se aplican correctamente, pueden mejorar significativamente la calidad de los modelos de aprendizaje automático al proporcionar representaciones más adecuadas y eficientes de los datos de entrada.

Combinación de características

La combinación de características es una técnica avanzada en la ingeniería de características que consiste en crear nuevas variables a partir de la interacción o combinación de dos o más características existentes. Este enfoque permite capturar relaciones complejas entre variables que podrían no ser evidentes cuando se consideran de forma individual, mejorando así la capacidad predictiva de los modelos de aprendizaje automático.

Una forma común de combinar características es mediante la interacción multiplicativa. Por ejemplo, si tenemos dos características, x1 y x2, podemos crear una nueva característica x1_x2 que es el producto de ambas. Esta nueva característica puede revelar combinaciones no lineales que el modelo puede aprovechar para mejorar su rendimiento.

import tensorflow as tf
from tensorflow.keras import layers, models

class Interaction(layers.Layer):
    def __init__(self, **kwargs):
        super(Interaction, self).__init__(**kwargs)

    def call(self, inputs):
        x1, x2 = inputs[:, 0], inputs[:, 1]
        return tf.expand_dims(x1 * x2, axis=1)

model = models.Sequential([
    layers.Input(shape=(2,)),
    Interaction(),
    layers.Dense(64, activation='relu'),
    layers.Dense(1)
])

model.compile(optimizer='adam', loss='mse')

En este ejemplo, la capa personalizada Interaction toma dos características de entrada y genera una nueva característica que es el producto de ambas. Esto permite al modelo capturar la interacción entre x1 y x2.

Otra técnica efectiva es la combinación polinómica, donde se generan combinaciones de alto orden de las características originales. TensorFlow ofrece maneras eficientes de crear estas combinaciones utilizando operaciones tensoriales. Por ejemplo, podemos extender las características originales a potencias superiores para capturar relaciones no lineales más complejas.

import tensorflow as tf
from tensorflow.keras import layers, models

class PolynomialFeatures(layers.Layer):
    def __init__(self, degree=2, **kwargs):
        super(PolynomialFeatures, self).__init__(**kwargs)
        self.degree = degree

    def call(self, inputs):
        features = [inputs]
        for d in range(2, self.degree + 1):
            features.append(tf.pow(inputs, d))
        return tf.concat(features, axis=1)

model = models.Sequential([
    layers.Input(shape=(3,)),
    PolynomialFeatures(degree=3),
    layers.Dense(64, activation='relu'),
    layers.Dense(1)
])

model.compile(optimizer='adam', loss='mse')

Aquí, la capa PolynomialFeatures expande las características de entrada hasta el tercer grado, creando combinaciones polinómicas que permiten al modelo capturar interacciones más sofisticadas entre las variables.

La combinación de características categóricas también es crucial, especialmente en conjuntos de datos con variables de alta cardinalidad. Una estrategia efectiva es utilizar embeddings, que representan cada categoría como un vector denso de dimensiones menores, facilitando así el aprendizaje de representaciones semánticas por parte del modelo.

import tensorflow as tf
from tensorflow.keras import layers, models

model = models.Sequential([
    layers.Input(shape=(1,)),
    layers.Embedding(input_dim=1000, output_dim=64),
    layers.Flatten(),
    layers.Dense(64, activation='relu'),
    layers.Dense(1)
])

model.compile(optimizer='adam', loss='mse')

En este ejemplo, una capa de Embedding convierte una variable categórica en una representación vectorial continua, que luego se combina con otras características a través de capas densas.

Además de las interacciones multiplicativas y polinómicas, la combinación aditiva de características es otra técnica útil. Consiste en sumar o promediar diferentes características para crear una nueva variable que represente una combinación balanceada de las originales. Este método puede ser especialmente útil en modelos lineales donde las sumas de características pueden capturar efectos agregados.

import tensorflow as tf
from tensorflow.keras import layers, models

class AddFeatures(layers.Layer):
    def call(self, inputs):
        return tf.expand_dims(tf.reduce_sum(inputs, axis=1), axis=1)

model = models.Sequential([
    layers.Input(shape=(4,)),
    AddFeatures(),
    layers.Dense(64, activation='relu'),
    layers.Dense(1)
])

model.compile(optimizer='adam', loss='mse')

La capa AddFeatures suma las características de entrada, creando una nueva característica que refleja la agregación de las originales.

La combinación de características no solo aumenta la riqueza de la representación de los datos, sino que también puede ayudar a reducir la dimensionalidad cuando se crea una combinación que sintetiza información relevante. Sin embargo, es crucial aplicar estas técnicas de manera cuidadosa para evitar la introducción de ruido o redundancias que puedan afectar negativamente el entrenamiento del modelo.

En resumen, la combinación de características es una estrategia poderosa en la ingeniería de características que permite a los modelos de aprendizaje automático captar relaciones complejas y mejorar su rendimiento predictivo mediante la creación de nuevas variables a partir de las existentes.

Selección de características

La selección de características es un paso crucial en la ingeniería de características, cuyo objetivo es identificar y retener únicamente las variables más relevantes para el modelo de aprendizaje automático. Este proceso no solo mejora la eficiencia del modelo al reducir la dimensionalidad de los datos, sino que también puede aumentar su precisión al eliminar características que generan ruido o redundancia.

Existen tres enfoques principales para la selección de características:

• Métodos de filtro: Evalúan la relevancia de las características de forma independiente al modelo, utilizando métricas estadísticas como la correlación o el valor p. Son rápidos y escalables, pero no consideran las interacciones entre características.

import pandas as pd
from sklearn.feature_selection import SelectKBest, f_regression

# Supongamos que X tiene 4 características
X_np = X.numpy() if hasattr(X, "numpy") else X  # Asegurarse de que X sea un array de NumPy

# Lista de nombres de columna ajustada a la forma real de X
column_names = ["feature1", "feature2", "feature3", "feature4"]  # Cambia según el número real de columnas

# Convertir X a DataFrame
X_df = pd.DataFrame(X_np, columns=column_names)

# Aplicar la selección de características
selector = SelectKBest(score_func=f_regression, k=3)  # Selecciona las 3 mejores características
X_new = selector.fit_transform(X_df, y)
selected_features = X_df.columns[selector.get_support()]
print("Características seleccionadas:", selected_features.tolist())

• Métodos de envoltura (wrapper): Utilizan algoritmos de aprendizaje para evaluar combinaciones de características. Técnicas como la eliminación recursiva de características (RFE) pueden identificar subconjuntos óptimos que mejoran el rendimiento del modelo.

import pandas as pd
from sklearn.feature_selection import RFE
from sklearn.linear_model import LinearRegression

# Convertir X a un DataFrame de pandas (si no lo es ya)
X_np = X.numpy() if hasattr(X, "numpy") else X  # Convertir tensor a NumPy si es necesario
column_names = ["feature1", "feature2", "feature3", "feature4"]  # Asegúrate de que coincida con el número real de columnas
X_df = pd.DataFrame(X_np, columns=column_names)

# Definir el modelo y aplicar RFE
model = LinearRegression()
rfe = RFE(model, n_features_to_select=3)  # Ajusta el número de características deseadas
X_rfe = rfe.fit_transform(X_df, y)
selected_features = X_df.columns[rfe.support_]
print("Características seleccionadas por RFE:", selected_features.tolist())

• Métodos embebidos (embedded): Integran la selección de características dentro del propio proceso de entrenamiento del modelo. Algoritmos como Lasso incorporan penalizaciones que pueden reducir a cero los coeficientes de características menos relevantes.

import pandas as pd
from sklearn.linear_model import LassoCV

# Convertir X a un DataFrame de pandas (si no lo es ya)
X_np = X.numpy() if hasattr(X, "numpy") else X  # Convertir tensor a NumPy si es necesario
column_names = ["feature1", "feature2", "feature3", "feature4"]  # Cambiar según el número de características
X_df = pd.DataFrame(X_np, columns=column_names)

# Aplicar Lasso con validación cruzada
lasso = LassoCV(cv=5)
lasso.fit(X_df, y)

# Seleccionar características con coeficientes diferentes de cero
coeficientes = pd.Series(lasso.coef_, index=X_df.columns)
selected_features = coeficientes[coeficientes != 0].index.tolist()
print("Características seleccionadas por Lasso:", selected_features)

En el contexto de TensorFlow, la selección de características generalmente se realiza antes de alimentar los datos al modelo. Sin embargo, es posible integrar procesos de selección dentro de la pipeline de TensorFlow utilizando tf.data para manipular los conjuntos de datos. A continuación, se muestra un ejemplo de cómo seleccionar características específicas utilizando la API de TensorFlow:

import tensorflow as tf

# Crear un dataset de ejemplo con características y etiquetas
dataset = tf.data.Dataset.from_tensor_slices((
    {
        'caracteristica1': tf.random.uniform([100]),
        'caracteristica2': tf.random.uniform([100]),
        'caracteristica3': tf.random.uniform([100]),
        'caracteristica4': tf.random.uniform([100]),
        'caracteristica5': tf.random.uniform([100])
    },
    tf.random.uniform([100], maxval=2, dtype=tf.int32)  # Etiquetas binarias
))

# Seleccionar características específicas
def seleccionar_caracteristicas(entry):
    datos, etiquetas = entry
    seleccionadas = {
        'caracteristica1': datos['caracteristica1'],
        'caracteristica3': datos['caracteristica3'],
        'caracteristica5': datos['caracteristica5']
    }
    return seleccionadas, etiquetas

# Aplicar la selección de características
dataset_seleccionado = dataset.map(lambda x, y: seleccionar_caracteristicas((x, y)))

# Definir el modelo utilizando la API funcional
inputs = {
    'caracteristica1': tf.keras.Input(shape=(), name='caracteristica1'),
    'caracteristica3': tf.keras.Input(shape=(), name='caracteristica3'),
    'caracteristica5': tf.keras.Input(shape=(), name='caracteristica5'),
}

# Expandir dimensiones y concatenar
reshaped_inputs = [tf.keras.layers.Reshape((1,))(v) for v in inputs.values()]
concatenadas = tf.keras.layers.Concatenate()(reshaped_inputs)

# Construir el modelo
x = tf.keras.layers.Dense(64, activation='relu')(concatenadas)
output = tf.keras.layers.Dense(1)(x)
model = tf.keras.Model(inputs=inputs, outputs=output)

# Compilar el modelo
model.compile(optimizer='adam', loss='mse')

# Entrenar el modelo
model.fit(dataset_seleccionado.batch(10), epochs=10)

En este ejemplo, la función seleccionar_características extrae únicamente las características relevantes del conjunto de datos, reduciendo así la entrada al modelo de TensorFlow. Este enfoque permite mantener la eficiencia en el procesamiento de datos y enfocar el aprendizaje en las variables más significativas.

Además, es posible combinar herramientas de TensorFlow con librerías como scikit-learn para realizar una selección de características más avanzada. Por ejemplo, se puede utilizar scikit-learn para seleccionar las características y luego convertir el conjunto de datos resultante en un tf.data.Dataset para entrenar el modelo en TensorFlow.

from sklearn.feature_selection import SelectKBest, f_regression
from sklearn.model_selection import train_test_split
import tensorflow as tf

# Seleccionar las mejores características
selector = SelectKBest(score_func=f_regression, k=4)
X_new = selector.fit_transform(X, y)

# Dividir en conjuntos de entrenamiento y prueba
X_train, X_test, y_train, y_test = train_test_split(X_new, y, test_size=0.2, random_state=42)

# Crear tf.data.Dataset
train_dataset = tf.data.Dataset.from_tensor_slices((X_train, y_train)).batch(32)
test_dataset = tf.data.Dataset.from_tensor_slices((X_test, y_test)).batch(32)

# Definir y entrenar el modelo
model = tf.keras.Sequential([
    tf.keras.layers.Dense(64, activation='relu', input_shape=(4,)), 
    tf.keras.layers.Dense(1)
])

model.compile(optimizer='adam', loss='mse')
model.fit(train_dataset, epochs=10, validation_data=test_dataset)

Este enfoque híbrido aprovecha las capacidades de selección de características de scikit-learn y la eficiencia de procesamiento de datos de TensorFlow, permitiendo una construcción de modelos más robusta y precisa.

La selección de características es, por tanto, una técnica esencial que, cuando se aplica correctamente, puede mejorar significativamente el rendimiento y la generalización de los modelos de aprendizaje automático desarrollados con TensorFlow.