Tutorial ScikitLearn: Extracción de características

Conceptos básicos de extracción

En el contexto del aprendizaje automático, la extracción de características es un proceso fundamental que consiste en transformar datos brutos en representaciones adecuadas para los algoritmos de aprendizaje. Este proceso permite convertir información cruda en un conjunto de características numéricas que capturan las propiedades esenciales de los datos.

La extracción de características es especialmente crucial cuando se trabaja con datos no estructurados como texto, imágenes o señales de audio. Por ejemplo, en procesamiento de lenguaje natural, es necesario convertir palabras en vectores numéricos mediante técnicas como Bag of Words o TF-IDF. De este modo, se pueden aplicar algoritmos de clasificación o regresión sobre datos textuales.

En scikit-learn, se ofrece un conjunto de herramientas para facilitar la extracción de características. Estas herramientas permiten transformar datos categóricos o textuales en representaciones numéricas. Un ejemplo común es el uso de DictVectorizer para convertir datos categóricos en matrices de características:

from sklearn.feature_extraction import DictVectorizer

datos = [
    {'ciudad': 'Madrid', 'temperatura': 20},
    {'ciudad': 'Barcelona', 'temperatura': 22},
    {'ciudad': 'Valencia', 'temperatura': 25}
]

vectorizador = DictVectorizer(sparse=False)
características = vectorizador.fit_transform(datos)

print(características)
print(vectorizador.get_feature_names_out())

Salida:

En este ejemplo, los valores categóricos de la clave 'ciudad' se transforman mediante codificación one-hot, generando una matriz numérica que puede ser procesada por algoritmos de aprendizaje automático.

La representación adecuada de los datos es crucial para el rendimiento de los modelos. Una buena extracción de características puede mejorar significativamente la capacidad de un modelo para aprender y generalizar. Por ello, es importante seleccionar técnicas de extracción que capturen de manera eficaz la información relevante de los datos.

Además, es habitual que la extracción de características se combine con otras técnicas de preprocesamiento como el escalado o la normalización. Por ejemplo, tras extraer las características, se puede aplicar StandardScaler para estandarizar las variables y mejorar el rendimiento de algoritmos sensibles a las escalas, como las máquinas de soporte vectorial.

Cuando se trabaja con datos de alta dimensionalidad, es posible que la extracción de características genere conjuntos de datos muy grandes. En estos casos, es recomendable utilizar métodos de reducción de dimensionalidad o selección de características para disminuir la complejidad computacional y evitar el sobreajuste.

La elección de la técnica de extracción adecuada depende del tipo de datos y del problema a resolver. Por ejemplo, para datos textuales, además de CountVectorizer, se puede utilizar TfidfVectorizer para tener en cuenta la frecuencia inversa de los documentos. Para imágenes, se pueden extraer características basadas en histogramas de gradientes orientados (HOG) u otras técnicas de visión por computador.

Es importante integrar el proceso de extracción de características dentro de un flujo de trabajo coherente. Gracias a los pipelines de scikit-learn, es posible encadenar la extracción de características con el modelado y la evaluación, facilitando el desarrollo y validación de modelos de aprendizaje automático.

Feature Hashing

El Feature Hashing, también conocido como el truco del hashing, es una técnica de extracción de características que permite convertir datos categóricos o textuales en representaciones numéricas de manera eficiente. Esta técnica es especialmente útil cuando se trabaja con datos de alta dimensionalidad o con vocabularios extensos, como en el procesamiento de lenguaje natural.

En lugar de crear una representación explícita de todas las características posibles, el Feature Hashing utiliza una función de hash para asignar características a índices en un vector de tamaño fijo. Esto reduce significativamente la memoria requerida y mejora el rendimiento computacional.

Ventajas del Feature Hashing

• Eficiencia de memoria: Al utilizar un vector de tamaño fijo, se evita el almacenamiento de un diccionario completo de características, lo que es beneficioso cuando el conjunto de datos es muy grande.
• Velocidad de cálculo: Las operaciones de hashing son rápidas, lo que acelera el proceso de transformación de datos.
• Simplicidad: No es necesario mantener un mapeo explícito de características, lo que simplifica el preprocesamiento.

Implementación con FeatureHasher de Scikit-Learn

En Scikit-Learn, la clase FeatureHasher proporciona una implementación eficiente del Feature Hashing. A continuación se muestra un ejemplo de cómo utilizarlo:

from sklearn.feature_extraction import FeatureHasher

# Supongamos que tenemos una lista de diccionarios con datos categóricos
datos = [
    {'animal': 'perro', 'color': 'marrón', 'edad': 5},
    {'animal': 'gato', 'color': 'negro', 'edad': 3},
    {'animal': 'perro', 'color': 'blanco', 'edad': 2},
    {'animal': 'pájaro', 'color': 'verde', 'edad': 1}
]

# Creamos un FeatureHasher especificando el número de características
hasher = FeatureHasher(n_features=10, input_type='dict')
características = hasher.transform(datos)

# Convertimos el resultado a una matriz densa si es necesario
características_densas = características.toarray()

print(características_densas)

En este ejemplo, cada diccionario en la lista datos representa un conjunto de características para un ejemplo individual. El FeatureHasher convierte estos diccionarios en una matriz de características de tamaño fijo.

Parámetros importantes

• n_features: Define el tamaño del vector de características resultante. Un valor más alto permite representar más características únicas, pero consume más memoria.
• input_type: Indica el tipo de entrada. Puede ser 'dict', 'pair' o 'string'. En la mayoría de los casos, se utiliza 'dict'.
• alternate_sign: Si se establece en True, los signos de los hash alternan entre positivo y negativo, lo que ayuda a reducir la colisión de características.

Consideraciones sobre colisiones

Debido a que múltiples características pueden mapearse al mismo índice en el vector (fenómeno conocido como colisión), es posible que se mezclen señales de diferentes características. Sin embargo, en la práctica, si el tamaño del vector es suficientemente grande, el impacto de las colisiones es mínimo.

Aplicaciones en procesamiento de texto

El Feature Hashing es particularmente útil en tareas de procesamiento del lenguaje natural, donde el vocabulario puede ser muy amplio. A continuación, se muestra un ejemplo aplicando FeatureHasher a datos textuales:

from sklearn.feature_extraction import FeatureHasher

# Lista de frases
frases = [
    {'texto': 'El perro ladra fuerte'},
    {'texto': 'El gato maúlla suave'},
    {'texto': 'El pájaro canta melodías'}
]

# Preprocesamos las frases para crear diccionarios de palabras
datos_texto = []
for frase in frases:
    palabras = frase['texto'].lower().split()
    conteo_palabras = {palabra: 1 for palabra in palabras}
    datos_texto.append(conteo_palabras)

# Aplicamos FeatureHasher
hasher = FeatureHasher(n_features=20, input_type='dict')
características_texto = hasher.transform(datos_texto).toarray()

print(características_texto)

En este caso, cada frase se transforma en un diccionario que cuenta la presencia de cada palabra. El FeatureHasher convierte estos diccionarios en una representación numérica.

Comparación con DictVectorizer

A diferencia de DictVectorizer, que crea una matriz dispersa con columnas para cada característica única, el FeatureHasher utiliza una función hash para reducir dimensionalidad. Esto es especialmente ventajoso cuando el número de características únicas es muy grande o desconocido.

Uso en un Pipeline

El Feature Hashing se puede integrar fácilmente en un pipeline de Scikit-Learn:

from sklearn.pipeline import Pipeline
from sklearn.linear_model import LogisticRegression

# Creamos un pipeline con FeatureHasher y un modelo de clasificación
pipeline = Pipeline([
    ('hasher', FeatureHasher(n_features=50, input_type='dict')),
    ('clasificador', LogisticRegression())
], memory = None)

# Supongamos que tenemos datos de entrenamiento y etiquetas
X_entrenamiento = datos  # Datos categóricos en forma de diccionarios
y_entrenamiento = [1, 0, 1, 0]  # Etiquetas de clase

# Entrenamos el modelo
pipeline.fit(X_entrenamiento, y_entrenamiento)

# Realizamos predicciones
predicciones = pipeline.predict(X_entrenamiento)

print(predicciones)

Este ejemplo demuestra cómo integrar el FeatureHasher en un flujo de trabajo completo, facilitando el preprocesamiento y el entrenamiento del modelo.

Limitaciones y buenas prácticas

• No Interpretabilidad de características: Debido al hashing, no es posible interpretar directamente qué características corresponden a cada índice en el vector resultante.
• Selección del tamaño del vector: Es importante elegir un valor adecuado para n_features para equilibrar entre eficiencia y precisión.
• Datos consistentes: Asegurarse de que los datos de entrenamiento y prueba se transformen con las mismas configuraciones para mantener la consistencia.

Extractores de texto y datos de imágenes

La extracción de características es esencial cuando se trabaja con datos no estructurados como texto e imágenes. En scikit-learn, existen herramientas especializadas para convertir este tipo de datos en representaciones numéricas aptas para algoritmos de aprendizaje automático. A continuación, se detallan los métodos más utilizados para extraer características de texto y de imágenes.

Extracción de características de texto

El procesamiento de lenguaje natural requiere transformar texto en vectores numéricos. Dos técnicas fundamentales para lograr esto en scikit-learn son CountVectorizer y TfidfVectorizer.

• CountVectorizer

Este transformador convierte una colección de documentos de texto en una matriz de conteos de términos. Cada fila representa un documento y cada columna una palabra del vocabulario, con valores que indican la frecuencia de cada palabra en el documento.

from sklearn.feature_extraction.text import CountVectorizer

corpus = [
    'El rápido zorro marrón salta sobre el perro perezoso',
    'Nunca he visto un zorro tan ágil y veloz',
    'El perro no puede alcanzar al zorro'
]

vectorizador = CountVectorizer()
X = vectorizador.fit_transform(corpus)

print("Matriz de características:")
print(X.toarray())
print("Características:")
print(vectorizador.get_feature_names_out())

Salida: 

En este ejemplo, el corpus es una lista de frases en español. El CountVectorizer crea una representación matricial donde cada elemento indica el número de veces que una palabra aparece en cada documento.

• TfidfVectorizer

Mientras que CountVectorizer se basa en conteos brutos, TfidfVectorizer aplica el esquema TF-IDF (Term Frequency-Inverse Document Frequency) para ponderar las palabras según su importancia en el corpus.

from sklearn.feature_extraction.text import TfidfVectorizer

vectorizador_tfidf = TfidfVectorizer()
X_tfidf = vectorizador_tfidf.fit_transform(corpus)

print("Matriz TF-IDF:")
print(X_tfidf.toarray())
print("Características:")
print(vectorizador_tfidf.get_feature_names_out())

El uso de TF-IDF reduce la influencia de palabras muy comunes y resalta términos más informativos. Esto es especialmente útil en tareas de clasificación de texto o análisis de sentimientos.

Parámetros importantes

• stop_words: Permite eliminar palabras vacías como "el", "la", "de". Se puede establecer en 'spanish' para usar una lista predefinida en español.
• ngram_range: Define el rango de n-gramas a extraer. Por ejemplo, (1, 2) extrae unigramas y bigramas.
• max_features: Limita el número de características a las n más frecuentes.

Ejemplo con parámetros ajustados

vectorizador_custom = CountVectorizer(
    stop_words='spanish',
    ngram_range=(1, 2),
    max_features=10
)

X_custom = vectorizador_custom.fit_transform(corpus)

print("Características ajustadas:")
print(vectorizador_custom.get_feature_names_out())

En este caso, se eliminan las palabras vacías, se incluyen bigramas y se limita el vocabulario a las 10 características más frecuentes.

Preprocesamiento de texto

Antes de la vectorización, es común aplicar técnicas de preprocesamiento para mejorar la calidad de las características extraídas:

• Lematización: Reduce las palabras a su forma básica o lema.
• Stemming: Elimina afijos para obtener la raíz de las palabras.
• Normalización: Convierte el texto a minúsculas y elimina caracteres no alfanuméricos.

Ejemplo de preprocesamiento personalizado

import re
from sklearn.base import BaseEstimator, TransformerMixin

class PreprocesadorTexto(BaseEstimator, TransformerMixin):
    def fit(self, X, y=None):
        return self
    def transform(self, X):
        return [re.sub(r'\W+', ' ', documento.lower()) for documento in X]

from sklearn.pipeline import Pipeline

pipeline_texto = Pipeline([
    ('preproceso', PreprocesadorTexto()),
    ('vectorizador', TfidfVectorizer(stop_words='spanish'))
], memory = None)

X_procesado = pipeline_texto.fit_transform(corpus)
print("Matriz TF-IDF preprocesada:")
print(X_procesado.toarray())

Aquí se crea un pipeline que primero normaliza el texto y luego aplica TfidfVectorizer. El preprocesador personalizado asegura que el texto esté en un formato adecuado para la vectorización.

Extracción de características de imágenes

Para imágenes, es necesario convertir píxeles en características relevantes que los algoritmos puedan interpretar. scikit-learn ofrece integraciones con bibliotecas como scikit-image para facilitar este proceso.

Uso de Histogramas de Gradientes Orientados (HOG)

Una técnica común es el Histograma de Gradientes Orientados (HOG), que captura la distribución de las intensidades de gradiente y es útil para tareas de reconocimiento de objetos.

from skimage import io, color
from skimage.feature import hog
from sklearn import svm
import matplotlib.pyplot as plt

# Cargar imagen y convertir a escala de grises
imagen = io.imread('ruta/a/la/imagen.jpg')
imagen_gris = color.rgb2gray(imagen)

# Extraer características HOG
caracteristicas_hog, imagen_hog = hog(
    imagen_gris,
    pixels_per_cell=(16, 16),
    cells_per_block=(1, 1),
    visualize=True
)

# Mostrar imagen original y HOG
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(8, 4))
ax1.imshow(imagen_gris, cmap='gray')
ax1.set_title('Imagen Original')
ax2.imshow(imagen_hog, cmap='gray')
ax2.set_title('Características HOG')
plt.show()

En este ejemplo, se utiliza hog de skimage.feature para extraer las características HOG de una imagen y visualizarlas. Estas características pueden ser utilizadas como entrada para un clasificador como SVM en scikit-learn.

Integración en un Pipeline

Al igual que con el texto, es posible crear un pipeline para el procesamiento de imágenes:

from sklearn.pipeline import Pipeline
from sklearn.svm import SVC

def cargar_imagenes(rutas):
    return [color.rgb2gray(io.imread(ruta)) for ruta in rutas]

class ExtractorHOG(BaseEstimator, TransformerMixin):
    def fit(self, X, y=None):
        return self
    def transform(self, X):
        return [hog(imagen, pixels_per_cell=(16, 16), cells_per_block=(1, 1)) for imagen in X]

# Supongamos que tenemos listas de rutas y etiquetas
rutas_imagenes = ['img1.jpg', 'img2.jpg', 'img3.jpg']
etiquetas = [0, 1, 0]

pipeline_imagen = Pipeline([
    ('carga', FunctionTransformer(cargar_imagenes)),
    ('hog', ExtractorHOG()),
    ('clasificador', SVC())
], memory = None)

pipeline_imagen.fit(rutas_imagenes, etiquetas)

Este pipeline carga las imágenes, extrae las características HOG y entrena un clasificador SVM. La clase ExtractorHOG aplica la transformación HOG a cada imagen.

Extracción de píxeles como características

En casos simples, se pueden utilizar directamente los valores de los píxeles como características. Sin embargo, esto es viable solo para imágenes pequeñas debido a la alta dimensionalidad.

import numpy as np

def cargar_píxeles(rutas):
    return [io.imread(ruta).flatten() for ruta en rutas]

X_pixels = cargar_píxeles(rutas_imagenes)

Aunque esta aproximación es sencilla, generalmente es mejor extraer características más significativas que capturen patrones en las imágenes.

Consideraciones al trabajar con texto e imágenes

• Dimensionalidad: Tanto el texto como las imágenes pueden generar matrices de características muy grandes. Es recomendable aplicar técnicas de reducción de dimensionalidad como PCA.
• Normalización: Es importante normalizar o escalar las características para que los algoritmos funcionen correctamente.
• Almacenamiento eficiente: Utilizar matrices dispersas (sparse matrices) cuando se trabaja con datos de texto, ya que ahorra memoria al no almacenar ceros explícitamente.
• Ensayos y validaciones cruzadas: Siempre validar el rendimiento de los modelos con validación cruzada para evitar sobreajuste.

Transformaciones basadas en frecuencia

Las transformaciones basadas en frecuencia son técnicas utilizadas para manipular y modelar datos numéricos o categóricos teniendo en cuenta la distribución de sus valores. Estas transformaciones son especialmente útiles cuando se desea normalizar o discretizar variables para mejorar el rendimiento de los algoritmos de aprendizaje automático.

Una aplicación común es la discretización de variables continuas en intervalos basados en la frecuencia de los datos. Esto permite convertir variables numéricas en categóricas, facilitando la detección de patrones que podrían no ser evidentes en su forma original.

Discretización con KBinsDiscretizer

En scikit-learn, la clase KBinsDiscretizer ofrece una forma eficiente de discretizar variables continuas en k intervalos. Una estrategia popular es la de cuantiles, donde los límites de los intervalos se definen para que cada uno contenga aproximadamente el mismo número de muestras.

import numpy as np
from sklearn.preprocessing import KBinsDiscretizer

# Generar datos simulados
X = np.array([[5], [15], [25], [35], [45], [55], [65], [75], [85], [95]])

# Crear el discretizador
discretizador = KBinsDiscretizer(n_bins=5, encode='ordinal', strategy='quantile')

# Ajustar y transformar los datos
X_binned = discretizador.fit_transform(X)

print("Datos originales:")
print(X.flatten())
print("Datos discretizados:")
print(X_binned.flatten())

Salida:

En este ejemplo, los datos se dividen en 5 intervalos utilizando la estrategia 'quantile'. El parámetro encode='ordinal' indica que los intervalos se codificarán con valores enteros que representan las distintas categorías.

Visualización de la discretización

Es útil visualizar cómo se distribuyen los datos tras la transformación. A continuación, se muestra cómo representar gráficamente los intervalos obtenidos:

import matplotlib.pyplot as plt

# Graficar los datos originales
plt.figure(figsize=(8, 4))
plt.subplot(1, 2, 1)
plt.hist(X, bins=10, edgecolor='k')
plt.title('Datos Originales')

# Graficar los datos discretizados
plt.subplot(1, 2, 2)
plt.hist(X_binned, bins=5, edgecolor='k', align='mid')
plt.xticks(range(5))
plt.title('Datos Discretizados')
plt.tight_layout()
plt.show()

La gráfica muestra cómo los datos continuos se agrupan en categorías basadas en la frecuencia de ocurrencia, equilibrando el número de muestras en cada intervalo.

Opciones de codificación

El parámetro encode en KBinsDiscretizer permite elegir el tipo de codificación de los intervalos:

• 'onehot': Genera una codificación one-hot donde cada categoría se representa con un vector binario.
• 'onehot-dense': Similar a 'onehot', pero el resultado es una matriz densa.
• 'ordinal': Cada categoría se codifica con un entero que indica su orden.

Ejemplo con codificación One-Hot

# Crear el discretizador con codificación one-hot
discretizador_oh = KBinsDiscretizer(n_bins=5, encode='onehot', strategy='quantile')

# Ajustar y transformar los datos
X_oh = discretizador_oh.fit_transform(X)

print("Matriz One-Hot:")
print(X_oh.toarray())

La codificación one-hot es útil cuando se desea que los modelos traten las categorías como variables independientes.

Estrategias de discretización

El argumento strategy define cómo se calculan los límites de los intervalos:

• 'uniform': Los intervalos tienen el mismo ancho en el espacio de los datos.
• 'quantile': Los intervalos contienen aproximadamente el mismo número de muestras.
• 'kmeans': Los límites de los intervalos se ajustan utilizando K-Means, agrupando los datos en k clústeres.

Ejemplo comparativo de estrategias

# Discretizador con estrategia 'uniform'
discretizador_uniform = KBinsDiscretizer(n_bins=5, encode='ordinal', strategy='uniform')
X_uniform = discretizador_uniform.fit_transform(X)

# Discretizador con estrategia 'kmeans'
discretizador_kmeans = KBinsDiscretizer(n_bins=5, encode='ordinal', strategy='kmeans')
X_kmeans = discretizador_kmeans.fit_transform(X)

print("Discretización Uniforme:")
print(X_uniform.flatten())
print("Discretización K-Means:")
print(X_kmeans.flatten())

Al comparar las diferentes estrategias, se puede elegir la más adecuada según la distribución de los datos y las necesidades del modelo.

Aplicación en variables categóricas

Además de variables continuas, es posible aplicar transformaciones basadas en frecuencia a variables categóricas, reemplazando las categorías por sus frecuencias de aparición.

Codificación por frecuencia

import pandas as pd

# Datos categóricos de ejemplo
datos = pd.DataFrame({
    'Color': ['Rojo', 'Azul', 'Verde', 'Azul', 'Rojo', 'Rojo', 'Verde', 'Azul', 'Azul']
})

# Calcular las frecuencias
frecuencias = datos['Color'].value_counts(normalize=True)

# Reemplazar categorías por frecuencias
datos['Color_Freq'] = datos['Color'].map(frecuencias)

print(datos)

En este caso, cada categoría se reemplaza por su frecuencia relativa, convirtiendo la variable categórica en numérica y conservando información sobre la distribución.

Uso en un Pipeline

Integrar estas transformaciones en un pipeline de scikit-learn permite automatizar el preprocesamiento y asegurar que se apliquen de forma consistente.

from sklearn.pipeline import Pipeline
from sklearn.linear_model import LinearRegression
import numpy as np

# Datos de ejemplo
X = np.array([[10], [20], [30], [40], [50], [60], [70], [80], [90], [100]])
y = np.array([1, 3, 2, 5, 4, 6, 7, 8, 9, 10])

# Crear el pipeline
pipeline = Pipeline([
    ('discretizador', KBinsDiscretizer(n_bins=5, encode='onehot-dense', strategy='quantile')),
    ('regresor', LinearRegression())
], memory = None)

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

# Realizar predicciones
X_nuevo = np.array([[25], [55], [85]])
predicciones = pipeline.predict(X_nuevo)

print("Predicciones:")
print(predicciones)

Este pipeline discretiza los datos antes de aplicar el modelo de regresión, lo que puede mejorar el rendimiento en ciertos casos.

Consideraciones importantes

• Datos Ordenados: La discretización basada en frecuencia asume que los datos están ordenados y que la variable es continua.
• Información de las Bin: Es posible acceder a los límites de los intervalos mediante el atributo bin_edges_ del discretizador.
• Cuidado con Valores Atípicos: Los valores atípicos pueden afectar la distribución de las frecuencias y, por ende, la discretización.

Acceso a los límites de los intervalos

# Obtener los límites de los intervalos
limites = discretizador.bin_edges_[0]
print("Límites de los intervalos:")
print(limites)

Conocer los límites puede ser útil para interpretar los resultados y entender cómo se han agrupado los datos.

Transformaciones personalizadas

En algunos casos, puede ser necesario aplicar transformaciones más específicas basadas en la frecuencia. Se pueden crear transformadores personalizados para este propósito.

Ejemplo de transformador personalizado

from sklearn.base import BaseEstimator, TransformerMixin

class FrecuenciaTransformer(BaseEstimator, TransformerMixin):
    def fit(self, X, y=None):
        self.frecuencias_ = pd.Series(X.flatten()).value_counts(normalize=True)
        return self
    def transform(self, X):
        X_transformado = pd.Series(X.flatten()).map(self.frecuencias_).fillna(0)
        return X_transformado.values.reshape(-1, 1)

# Datos categóricos de ejemplo
X_cat = np.array([['A'], ['B'], ['A'], ['C'], ['B'], ['A']])

# Aplicar el transformador
transformador = FrecuenciaTransformer()
X_freq = transformador.fit_transform(X_cat)

print("Datos Transformados:")
print(X_freq)

Este transformador reemplaza cada categoría por su frecuencia, convirtiendo variables categóricas en numéricas basadas en la distribución de los datos.

Ventajas de las transformaciones basadas en frecuencia

• Reducción de sesgos: Al equilibrar las frecuencias, se reduce el sesgo causado por distribuciones desiguales.
• Mejora de rendimiento: Algunos algoritmos funcionan mejor con datos discretizados o normalizados en base a la frecuencia.
• Flexibilidad: Se pueden combinar con otras técnicas de preprocesamiento para adaptarse a diferentes tipos de datos.

Limitaciones y precauciones

• Pérdida de información: La discretización puede llevar a una pérdida de información detallada de los datos originales.
• Sobreajuste: Si se crean demasiadas categorías, existe el riesgo de sobreajustar el modelo a los datos de entrenamiento.
• Aplicabilidad limitada: No todos los algoritmos se benefician de estas transformaciones; es importante evaluar su impacto en cada caso.