Autor: Fernando

¿Qué es la limpieza de datos?

La limpieza de datos (Data Cleaning o Data Cleansing) es el proceso de identificar, corregir o eliminar errores, inconsistencias e información incorrecta dentro de un conjunto de datos con el objetivo de mejorar su calidad y fiabilidad.

En Data Science y Machine Learning, la calidad de los datos es uno de los factores más importantes para el éxito de un proyecto. Un modelo entrenado con datos erróneos, incompletos o inconsistentes producirá resultados poco fiables, independientemente de la complejidad del algoritmo utilizado.

Por este motivo, la limpieza de datos constituye una de las primeras etapas del proceso de preparación de datos y suele consumir una parte significativa del tiempo dedicado a un proyecto analítico.

¿Por qué es importante la limpieza de datos?

Los datos procedentes de sistemas reales suelen contener problemas derivados de:

• Errores humanos durante la introducción de información.
• Fallos en sensores o dispositivos.
• Integraciones entre múltiples sistemas.
• Registros incompletos.
• Problemas de formato.
• Duplicidades.
• Valores atípicos o anómalos.

Por ejemplo:

Los valores -10 y 150 probablemente representan errores que deben revisarse antes de utilizar los datos en un análisis.

¿Cómo funciona la limpieza de datos?

El proceso de limpieza suele incluir varias tareas:

• Identificación de valores faltantes.
• Detección de registros duplicados.
• Corrección de errores de formato.
• Estandarización de categorías.
• Tratamiento de valores atípicos.
• Validación de rangos permitidos.
• Conversión de tipos de datos.
• Eliminación de inconsistencias.

El objetivo es transformar un conjunto de datos bruto en un conjunto de datos preparado para el análisis o el modelado.

Ejemplo de limpieza de datos

Supongamos el siguiente conjunto de datos:

Durante el proceso de limpieza podríamos:

• Imputar el valor faltante de Pedro.
• Eliminar el registro duplicado de Ana.
• Corregir la edad de Luis.
• Estandarizar “Barcelona” y “barcelona”.

Resultado:

El conjunto de datos ahora presenta una mayor consistencia y calidad.

Principales problemas que aborda la limpieza de datos

La limpieza de datos se centra en resolver problemas frecuentes como:

• Valores faltantes: Ocurren cuando una observación carece de información en una o varias variables. Ejemplos:
  • Campos vacíos.
  • Valores nulos.
  • Registros incompletos.
• Datos duplicados: Se producen cuando una misma observación aparece más de una vez en el conjunto de datos. Esto puede generar sesgos y distorsionar los análisis.
• Inconsistencias de formato: Algunos ejemplos son:
  • Fechas con formatos diferentes.
  • Variaciones de mayúsculas y minúsculas.
  • Unidades de medida distintas.
• Valores atípicos: Son observaciones que se alejan significativamente del comportamiento habitual de los datos. Pueden representar:
  • Errores.
  • Casos excepcionales.
  • Fenómenos reales.
• Errores tipográficos: Ejemplos:
  • “Madird” en lugar de “Madrid”.
  • “Barcelna” en lugar de “Barcelona”.

Beneficios de la limpieza de datos

• Mejora la calidad de los datos.
• Incrementa la precisión de los modelos.
• Reduce errores analíticos.
• Facilita la toma de decisiones.
• Mejora la consistencia de la información.
• Reduce sesgos producidos por errores.
• Incrementa la confianza en los resultados.

¿Cuándo realizar la limpieza de datos?

• Antes del análisis exploratorio.
• Antes de construir modelos predictivos.
• Antes de generar informes o dashboards.
• Durante procesos ETL.
• Antes de integrar múltiples fuentes de datos.
• Siempre que se detecten problemas de calidad.

En la práctica, la limpieza suele ser una actividad continua durante todo el ciclo de vida del proyecto.

Ventajas de la limpieza de datos

• Datos más fiables.
• Modelos más precisos.
• Mejor interpretabilidad.
• Menor riesgo de errores.
• Mayor consistencia.
• Mejor rendimiento de algoritmos.
• Mayor calidad de los análisis.

Desventajas

Aunque es una actividad fundamental, también presenta algunos inconvenientes:

• Puede requerir mucho tiempo.
• Algunas correcciones requieren conocimiento del negocio.
• Existe riesgo de eliminar información valiosa.
• Determinadas decisiones pueden introducir sesgos.
• No siempre es posible identificar todos los errores.

Limitaciones

La limpieza de datos no resuelve todos los problemas de un conjunto de datos. Entre sus limitaciones se encuentran:

• No corrige sesgos inherentes a la recopilación de datos.
• No crea información que no existe.
• No garantiza modelos perfectos.
• Algunas anomalías pueden pasar desapercibidas.
• La calidad final depende de las decisiones tomadas durante el proceso.

Además, una limpieza excesiva puede eliminar información relevante para el análisis.

Comparación entre datos limpios y datos sin limpiar

Aplicaciones en Data Science y Machine Learning

La limpieza de datos es una etapa fundamental en:

• Machine Learning supervisado.
• Machine Learning no supervisado.
• Business Intelligence.
• Análisis exploratorio de datos.
• Sistemas de recomendación.
• Procesamiento de lenguaje natural.
• Analítica financiera.
• Predicción de demanda.
• Detección de fraude.
• Visión por computador.

Prácticamente cualquier proyecto basado en datos requiere algún nivel de limpieza antes de comenzar el análisis.

Impacto en los modelos de Machine Learning

Los algoritmos de Machine Learning suelen ser sensibles a problemas de calidad en los datos. Por ejemplo:

• Los valores faltantes pueden impedir el entrenamiento.
• Los duplicados pueden introducir sesgos.
• Los errores tipográficos generan categorías innecesarias.
• Los outliers pueden distorsionar algunos modelos.

Por esta razón, la calidad de los datos suele influir tanto o más que la elección del algoritmo.

Flujo típico de limpieza de datos

Un proceso habitual puede seguir los siguientes pasos:

1. Explorar los datos.
2. Detectar valores faltantes.
3. Identificar duplicados.
4. Corregir formatos.
5. Revisar valores atípicos.
6. Estandarizar categorías.
7. Validar reglas de negocio.
8. Verificar la calidad final.

Este flujo puede variar según el tipo de proyecto y los datos disponibles.

Buenas prácticas

Al realizar limpieza de datos es recomendable:

• Conservar siempre una copia de los datos originales.
• Documentar todas las transformaciones realizadas.
• Comprender el contexto de negocio antes de eliminar registros.
• Automatizar procesos repetitivos.
• Validar los resultados después de cada modificación.
• Utilizar pipelines reproducibles.

Conclusión

La limpieza de datos es una de las etapas más importantes dentro de cualquier proyecto de Data Science y Machine Learning. Su objetivo es detectar y corregir problemas de calidad que puedan afectar al análisis, la interpretación de los datos o el rendimiento de los modelos predictivos.

Aunque suele requerir tiempo y conocimiento del dominio, sus beneficios superan ampliamente los costes asociados. Un conjunto de datos limpio, consistente y fiable constituye la base sobre la que se construyen análisis precisos, modelos robustos y decisiones basadas en evidencia. Por este motivo, la limpieza de datos debe considerarse un paso imprescindible antes de cualquier proceso de análisis o modelado.

¿Qué es Binary Encoding?

Binary Encoding es una técnica de codificación de variables categóricas diseñada para representar categorías mediante números binarios. Su objetivo principal es reducir la dimensionalidad generada por técnicas como One-Hot Encoding sin perder la capacidad de transformar variables categóricas en datos numéricos utilizables por algoritmos de Machine Learning.

Esta técnica combina conceptos de Label Encoding y representación binaria. Primero asigna un identificador numérico a cada categoría y posteriormente convierte dicho identificador a formato binario.

Cada bit de la representación binaria se almacena en una columna independiente.

Binary Encoding es especialmente útil cuando se trabaja con variables categóricas de alta cardinalidad, es decir, variables que contienen un gran número de categorías distintas.

¿Cómo funciona?

El proceso consiste en:

• Identificar las categorías únicas de la variable.
• Asignar un identificador numérico a cada categoría.
• Convertir cada identificador a representación binaria.
• Crear una columna para cada bit generado.
• Sustituir la variable original por las nuevas columnas binarias.

La conversión de un número decimal a binario puede expresarse como:

$$13_{10}=1101_{2}$$

Por ejemplo:

Cada dígito binario se convierte en una nueva característica.

Ejemplo de Binary Encoding

Supongamos la siguiente variable:

Asignamos un identificador:

Convertimos cada código a binario:

Finalmente, cada bit se almacena en una columna independiente:

La variable categórica original queda completamente transformada en variables numéricas.

¿Por qué utilizar Binary Encoding?

Cuando una variable posee muchas categorías, One-Hot Encoding puede generar una enorme cantidad de columnas.

Por ejemplo:

• 1.000 categorías → 1.000 columnas con One-Hot Encoding.
• 1.000 categorías → aproximadamente 10 columnas con Binary Encoding.

Esto ocurre porque el número de columnas necesarias crece de forma logarítmica:

$$Columnas=\lceil\log_2(k)\rceil$$

Donde:

• (k) es el número de categorías.
• (\lceil \cdot \rceil) representa el redondeo hacia arriba.

Esta propiedad convierte a Binary Encoding en una técnica muy eficiente para variables de alta cardinalidad.

Beneficios de Binary Encoding

• Reduce significativamente la dimensionalidad.
• Genera menos columnas que One-Hot Encoding.
• Funciona bien con variables de alta cardinalidad.
• Disminuye el consumo de memoria.
• Mantiene una representación numérica compacta.
• Facilita el entrenamiento de modelos sobre grandes datasets.
• Puede mejorar el rendimiento computacional.

¿Cuándo utilizar Binary Encoding?

• Existen muchas categorías distintas.
• One-Hot Encoding genera demasiadas columnas.
• Se busca un equilibrio entre simplicidad y eficiencia.
• Se trabaja con conjuntos de datos grandes.
• La variable presenta alta cardinalidad.

Casos habituales:

• Ciudades.
• Códigos postales.
• Productos.
• Clientes.
• Identificadores de usuario.
• Categorías de comercio electrónico.

Ventajas

• Menor dimensionalidad que One-Hot Encoding.
• Escalabilidad para miles de categorías.
• Bajo consumo de memoria.
• Fácil integración en pipelines.
• Compatible con la mayoría de algoritmos.
• Reduce el riesgo de matrices extremadamente dispersas.
• Conserva más información que algunas técnicas basadas en frecuencia.

Desventajas

• Menos interpretable que One-Hot Encoding.
• Introduce relaciones numéricas artificiales derivadas de la codificación.
• Puede resultar difícil explicar cada columna generada.
• Algunas categorías comparten parte de sus bits.
• No incorpora información sobre la variable objetivo.

Por ejemplo:

Ambas categorías comparten parte de la representación binaria, aunque no exista relación real entre ellas.

Limitaciones

• No refleja similitudes semánticas entre categorías.
• No utiliza información de la variable objetivo.
• La interpretación de los bits no es intuitiva.
• Puede generar relaciones artificiales entre categorías.
• No siempre supera a One-Hot Encoding en rendimiento predictivo.

Además, algunos modelos lineales pueden verse afectados por las dependencias implícitas introducidas por la representación binaria.

Comparación con otras técnicas de codificación

Binary Encoding vs One-Hot Encoding

Binary Encoding suele ser una alternativa muy atractiva cuando el número de categorías es elevado.

Binary Encoding vs Ordinal Encoding

Aplicaciones en Data Science y Machine Learning

Binary Encoding aparece frecuentemente en:

• Sistemas de recomendación.
• Comercio electrónico.
• Marketing digital.
• Predicción de fraude.
• Segmentación de clientes.
• Modelos de scoring.
• Analítica de usuarios.
• Predicción de abandono.
• Sistemas de clasificación.

Es especialmente útil en proyectos donde las variables categóricas contienen cientos o miles de categorías.

Algoritmos donde suele utilizarse

Binary Encoding puede utilizarse antes de algoritmos como:

• Regresión logística.
• Árboles de decisión.
• Random Forest.
• Gradient Boosting.
• XGBoost.
• LightGBM.
• Redes neuronales.
• Máquinas de vectores de soporte (SVM).
• K-Nearest Neighbors (KNN).

Su capacidad para reducir dimensionalidad lo convierte en una opción interesante para muchos tipos de modelos.

Implementación en Python

La forma más sencilla de aplicar Binary Encoding es mediante la biblioteca category_encoders.

pip install category_encoders

pip install category_encoders

Ejemplo básico

import pandas as pd
import category_encoders as ce

df = pd.DataFrame({
    "ciudad": [
        "Madrid",
        "Barcelona",
        "Sevilla",
        "Valencia"
    ]
})

encoder = ce.BinaryEncoder(
    cols=["ciudad"]
)

df_encoded = encoder.fit_transform(df)

print(df_encoded)

import pandas as pd
import category_encoders as ce

df = pd.DataFrame({
    "ciudad": [
        "Madrid",
        "Barcelona",
        "Sevilla",
        "Valencia"
    ]
})

encoder = ce.BinaryEncoder(
    cols=["ciudad"]
)

df_encoded = encoder.fit_transform(df)

print(df_encoded)

   ciudad_0  ciudad_1  ciudad_2
0         0         0         1
1         0         1         0
2         0         1         1
3         1         0         0

   ciudad_0  ciudad_1  ciudad_2
0         0         0         1
1         0         1         0
2         0         1         1
3         1         0         0

Codificación de múltiples variables

import category_encoders as ce

encoder = ce.BinaryEncoder(
    cols=["ciudad", "producto"]
)

df_encoded = encoder.fit_transform(df)

import category_encoders as ce

encoder = ce.BinaryEncoder(
    cols=["ciudad", "producto"]
)

df_encoded = encoder.fit_transform(df)

Uso dentro de un Pipeline

from sklearn.pipeline import Pipeline
from sklearn.ensemble import RandomForestClassifier
import category_encoders as ce

pipeline = Pipeline([
    ("encoder",
     ce.BinaryEncoder(cols=["ciudad"])),
    ("modelo",
     RandomForestClassifier())
])

pipeline.fit(X_train, y_train)

from sklearn.pipeline import Pipeline
from sklearn.ensemble import RandomForestClassifier
import category_encoders as ce

pipeline = Pipeline([
    ("encoder",
     ce.BinaryEncoder(cols=["ciudad"])),
    ("modelo",
     RandomForestClassifier())
])

pipeline.fit(X_train, y_train)

Este enfoque garantiza que la misma transformación se aplique tanto en entrenamiento como en producción.

Buenas prácticas

Al utilizar Binary Encoding es recomendable:

• Aplicar la codificación únicamente sobre variables categóricas.
• Ajustar el encoder usando exclusivamente los datos de entrenamiento.
• Gestionar adecuadamente categorías no vistas.
• Comparar su rendimiento con One-Hot Encoding y Target Encoding.
• Evaluar el impacto sobre la interpretabilidad del modelo.

Conclusión

Binary Encoding es una técnica eficiente para transformar variables categóricas mediante representaciones binarias compactas. Su principal ventaja es la reducción significativa de dimensionalidad respecto a One-Hot Encoding, lo que la convierte en una excelente opción para variables de alta cardinalidad.

Aunque introduce cierta complejidad en la interpretación de los datos y puede generar relaciones artificiales entre categorías, ofrece un equilibrio muy interesante entre eficiencia computacional, consumo de memoria y capacidad predictiva. Por ello, es una técnica ampliamente utilizada en proyectos de Data Science y Machine Learning que manejan grandes volúmenes de categorías.

¿Qué es Count Encoding?

Count Encoding es una técnica de codificación de variables categóricas que sustituye cada categoría por el número de veces que aparece en el conjunto de datos.

En lugar de crear múltiples columnas, como ocurre con One-Hot Encoding, o asignar identificadores arbitrarios, como en Label Encoding, Count Encoding utiliza información estadística real para representar las categorías mediante su frecuencia absoluta de aparición.

Esta técnica resulta especialmente útil cuando se trabaja con variables de alta cardinalidad, es decir, variables que contienen un gran número de categorías distintas.

Por ejemplo, si una categoría aparece 500 veces en el conjunto de datos, será reemplazada por el valor 500.

¿Cómo funciona?

El proceso consiste en:

• Identificar todas las categorías únicas de una variable.
• Contar el número de apariciones de cada categoría.
• Crear un diccionario de correspondencia entre categoría y número de ocurrencias.
• Sustituir cada categoría por su conteo correspondiente.

La transformación puede expresarse como:

$$Count(c)=\sum_{i=1}^{N}I(x_i=c)$$

Donde:

• (c) representa una categoría.
• (I(x_i=c)) es una función indicadora que vale 1 cuando la observación pertenece a la categoría (c).
• (N) es el número total de observaciones.

El resultado es un valor numérico que representa cuántas veces aparece cada categoría dentro del conjunto de datos.

Ejemplo de Count Encoding

Supongamos la siguiente variable:

Calculamos el número de apariciones:

Tras aplicar Count Encoding:

Cada categoría queda representada por su número total de apariciones.

Diferencia entre Count Encoding y Frequency Encoding

Ambas técnicas son muy similares, pero utilizan escalas distintas.

Por ejemplo:

Ambas técnicas contienen la misma información, pero representada de forma diferente.

¿Por qué utilizar Count Encoding?

Cuando una variable contiene cientos o miles de categorías, One-Hot Encoding puede generar una enorme cantidad de columnas.

Por ejemplo:

• Código postal.
• Ciudad.
• Producto.
• Cliente.
• Proveedor.
• Marca.

Count Encoding permite mantener una única columna y reducir significativamente el tamaño del conjunto de datos.

Beneficios de Count Encoding

• Reduce la dimensionalidad.
• Mantiene una sola columna por variable.
• Es sencillo de implementar.
• Utiliza información estadística real.
• Funciona bien con variables de alta cardinalidad.
• Reduce el consumo de memoria.
• Puede acelerar el entrenamiento de modelos.

¿Cuándo utilizar Count Encoding?

• Existen muchas categorías distintas.
• Se desea evitar la explosión dimensional.
• El número de apariciones de una categoría aporta información relevante.
• Se trabaja con grandes volúmenes de datos.
• Se busca una representación compacta.

Casos habituales:

• Comercio electrónico.
• Sistemas de recomendación.
• Marketing digital.
• Predicción de fraude.
• Segmentación de clientes.
• Modelos de scoring.

Ventajas

• Bajo consumo de memoria.
• No genera columnas adicionales.
• Escala bien en datasets grandes.
• Compatible con la mayoría de algoritmos.
• Aprovecha información estadística de la variable.
• Adecuado para variables de alta cardinalidad.

Desventajas

• Categorías diferentes pueden recibir exactamente el mismo valor.
• Se pierde parte de la identidad de las categorías.
• No captura relaciones semánticas.
• No utiliza información de la variable objetivo.
• Puede generar ambigüedad cuando varias categorías tienen el mismo conteo.

Por ejemplo:

Tras la codificación, ambas categorías serán indistinguibles para el modelo.

Limitaciones

• No incorpora información predictiva de la variable objetivo.
• No refleja similitud entre categorías.
• Puede perder capacidad discriminativa.
• Las categorías raras pueden quedar infrarrepresentadas.
• Los conteos dependen del conjunto de entrenamiento.

Además, si la distribución de categorías cambia con el tiempo, los valores calculados inicialmente pueden dejar de representar adecuadamente los datos futuros.

Comparación con otras técnicas de codificación

Count Encoding vs One-Hot Encoding

Count Encoding vs Frequency Encoding

En muchos problemas ambos métodos ofrecen resultados muy similares.

Aplicaciones en Data Science y Machine Learning

Count Encoding aparece frecuentemente en:

• Sistemas de recomendación.
• Predicción de fraude.
• Marketing analítico.
• Comercio electrónico.
• Segmentación de clientes.
• Predicción de abandono.
• Scoring crediticio.
• Análisis de comportamiento de usuarios.
• Modelos de clasificación.

Es especialmente útil cuando se trabaja con variables categóricas de alta cardinalidad que hacen inviable el uso de One-Hot Encoding.

Algoritmos donde suele utilizarse

Count Encoding puede utilizarse antes de algoritmos como:

• Regresión logística.
• Árboles de decisión.
• Random Forest.
• Gradient Boosting.
• XGBoost.
• LightGBM.
• CatBoost.
• Redes neuronales.
• Máquinas de vectores de soporte (SVM).

Al mantener una representación compacta, suele facilitar el entrenamiento en grandes conjuntos de datos.

Implementación en Python

Utilizando Pandas

import pandas as pd

df = pd.DataFrame({
    "ciudad": [
        "Madrid",
        "Barcelona",
        "Madrid",
        "Sevilla",
        "Madrid",
        "Barcelona"
    ]
})

conteos = df["ciudad"].value_counts()

df["ciudad_count"] = df["ciudad"].map(conteos)

print(df)

import pandas as pd

df = pd.DataFrame({
    "ciudad": [
        "Madrid",
        "Barcelona",
        "Madrid",
        "Sevilla",
        "Madrid",
        "Barcelona"
    ]
})

conteos = df["ciudad"].value_counts()

df["ciudad_count"] = df["ciudad"].map(conteos)

print(df)

      ciudad  ciudad_count
0     Madrid             3
1  Barcelona             2
2     Madrid             3
3    Sevilla             1
4     Madrid             3
5  Barcelona             2

      ciudad  ciudad_count
0     Madrid             3
1  Barcelona             2
2     Madrid             3
3    Sevilla             1
4     Madrid             3
5  Barcelona             2

Aplicación sobre múltiples columnas

import pandas as pd

columnas = ["ciudad", "producto"]

for columna in columnas:
    conteos = df[columna].value_counts()
    df[columna] = df[columna].map(conteos)

import pandas as pd

columnas = ["ciudad", "producto"]

for columna in columnas:
    conteos = df[columna].value_counts()
    df[columna] = df[columna].map(conteos)

Creando un transformador personalizado

from sklearn.base import BaseEstimator, TransformerMixin

class CountEncoder(
    BaseEstimator,
    TransformerMixin
):

    def fit(self, X, y=None):
        self.count_map = (
            X.iloc[:, 0]
            .value_counts()
            .to_dict()
        )
        return self

    def transform(self, X):
        return X.iloc[:, 0].map(
            self.count_map
        ).to_frame()

from sklearn.base import BaseEstimator, TransformerMixin

class CountEncoder(
    BaseEstimator,
    TransformerMixin
):

    def fit(self, X, y=None):
        self.count_map = (
            X.iloc[:, 0]
            .value_counts()
            .to_dict()
        )
        return self

    def transform(self, X):
        return X.iloc[:, 0].map(
            self.count_map
        ).to_frame()

Uso dentro de un Pipeline

from sklearn.pipeline import Pipeline
from sklearn.ensemble import RandomForestClassifier

pipeline = Pipeline([
    ("encoder", CountEncoder()),
    ("modelo", RandomForestClassifier())
])

pipeline.fit(X_train, y_train)

from sklearn.pipeline import Pipeline
from sklearn.ensemble import RandomForestClassifier

pipeline = Pipeline([
    ("encoder", CountEncoder()),
    ("modelo", RandomForestClassifier())
])

pipeline.fit(X_train, y_train)

Este enfoque garantiza que el mismo mapeo calculado durante el entrenamiento se aplique posteriormente a nuevos datos.

Buenas prácticas

Al utilizar Count Encoding es recomendable:

• Calcular los conteos únicamente sobre el conjunto de entrenamiento.
• Aplicar exactamente el mismo mapeo al conjunto de prueba.
• Definir una estrategia para categorías no vistas.
• Evaluar posibles colisiones entre categorías con igual conteo.
• Comparar su rendimiento frente a Frequency Encoding y One-Hot Encoding.

Conclusión

Count Encoding es una técnica de codificación eficiente que sustituye cada categoría por su número de apariciones dentro del conjunto de datos. Gracias a su simplicidad y capacidad para manejar variables de alta cardinalidad, se ha convertido en una alternativa muy útil cuando One-Hot Encoding resulta costoso en términos de memoria y dimensionalidad.

Aunque puede perder información cuando varias categorías comparten el mismo conteo y no incorpora información de la variable objetivo, sigue siendo una herramienta valiosa para representar variables categóricas de forma compacta y eficiente en numerosos proyectos de Data Science y Machine Learning.

¿Qué es Frequency Encoding?

Frequency Encoding es una técnica de codificación de variables categóricas que sustituye cada categoría por la frecuencia con la que aparece en el conjunto de datos.

A diferencia de técnicas como One-Hot Encoding o Ordinal Encoding, no crea nuevas columnas ni asigna valores arbitrarios. En su lugar, utiliza información estadística real de los datos para representar cada categoría mediante su número de apariciones o su frecuencia relativa.

Esta técnica resulta especialmente útil cuando una variable contiene un gran número de categorías, ya que permite reducir la dimensionalidad sin perder información relacionada con la distribución de los datos.

¿Cómo funciona?

El proceso consiste en:

• Identificar todas las categorías únicas de una variable.
• Contar cuántas veces aparece cada categoría.
• Calcular la frecuencia absoluta o relativa de cada una.
• Sustituir cada categoría por su frecuencia correspondiente.

La frecuencia absoluta se calcula como:

$$Frecuencia(c)=Conteo(c)$$

La frecuencia relativa se obtiene mediante:

$$Frecuencia\ Relativa(c)=\frac{Conteo(c)}{N}$$

Donde:

• (c) representa una categoría.
• (Conteo(c)) es el número de veces que aparece la categoría.
• (N) es el número total de observaciones.

Ejemplo de Frequency Encoding

Supongamos la siguiente variable:

Calculamos las frecuencias:

Tras aplicar Frequency Encoding:

Si se utiliza frecuencia relativa:

¿Por qué utilizar Frequency Encoding?

Cuando una variable contiene muchas categorías, técnicas como One-Hot Encoding pueden generar cientos o miles de nuevas columnas.

Por ejemplo:

• Código postal.
• Ciudad.
• Producto.
• Usuario.
• Categoría de negocio.

En estos escenarios, Frequency Encoding permite mantener una única columna y reducir considerablemente el tamaño del dataset.

Beneficios de Frequency Encoding

• Reduce la dimensionalidad.
• Mantiene una única columna por variable.
• Es sencillo de implementar.
• Aprovecha información estadística real de los datos.
• Escala bien con variables de alta cardinalidad.
• Requiere poca memoria.
• Puede mejorar la eficiencia computacional.

¿Cuándo utilizar Frequency Encoding?

• Existen muchas categorías distintas.
• Se desea evitar la explosión dimensional de One-Hot Encoding.
• La frecuencia de aparición contiene información relevante.
• Se trabaja con grandes volúmenes de datos.
• La variable tiene alta cardinalidad.

Algunos ejemplos habituales son:

• Códigos postales.
• Ciudades.
• Productos.
• Clientes.
• Identificadores de negocio.
• Categorías de comercio electrónico.

Ventajas

Las principales ventajas son:

• No incrementa el número de columnas.
• Funciona bien con variables de alta cardinalidad.
• Bajo consumo de memoria.
• Fácil de interpretar.
• Implementación sencilla.
• Compatible con la mayoría de algoritmos de Machine Learning.
• Captura información sobre la distribución de las categorías.

Desventajas

• Categorías diferentes pueden recibir el mismo valor.
• Se pierde la identidad original de algunas categorías.
• No incorpora información directa sobre la variable objetivo.
• Puede generar ambigüedad cuando varias categorías comparten frecuencia.
• No representa relaciones semánticas entre categorías.

Por ejemplo:

Tras la codificación, ambas categorías serán idénticas para el modelo.

Limitaciones

Antes de aplicar esta técnica conviene considerar que:

• No refleja similitud entre categorías.
• No captura relaciones con la variable objetivo.
• Puede perder información discriminativa.
• Los valores dependen del conjunto de entrenamiento.
• Nuevas categorías requieren un tratamiento especial.

Además, cuando la distribución de categorías cambia con el tiempo, las frecuencias calculadas inicialmente pueden dejar de ser representativas.

Comparación con otras técnicas de codificación

Frequency Encoding vs One-Hot Encoding

Frequency Encoding vs Target Encoding

Aplicaciones en Data Science y Machine Learning

• Sistemas de recomendación.
• Predicción de abandono de clientes.
• Detección de fraude.
• Marketing analítico.
• Comercio electrónico.
• Segmentación de clientes.
• Modelos de scoring.
• Predicción de demanda.
• Sistemas de clasificación.

Es especialmente útil cuando se trabaja con variables categóricas de alta cardinalidad que dificultan la aplicación de One-Hot Encoding.

Algoritmos donde suele utilizarse

• Regresión logística.
• Árboles de decisión.
• Random Forest.
• Gradient Boosting.
• XGBoost.
• LightGBM.
• CatBoost.
• Redes neuronales.
• Máquinas de vectores de soporte (SVM).

Al reducir la dimensionalidad, suele facilitar el entrenamiento de modelos sobre grandes volúmenes de datos.

Implementación en Python

Utilizando Pandas

import pandas as pd

df = pd.DataFrame({
    "ciudad": [
        "Madrid",
        "Barcelona",
        "Madrid",
        "Sevilla",
        "Madrid",
        "Barcelona"
    ]
})

frecuencias = df["ciudad"].value_counts()

df["ciudad_frequency"] = df["ciudad"].map(frecuencias)

print(df)

import pandas as pd

df = pd.DataFrame({
    "ciudad": [
        "Madrid",
        "Barcelona",
        "Madrid",
        "Sevilla",
        "Madrid",
        "Barcelona"
    ]
})

frecuencias = df["ciudad"].value_counts()

df["ciudad_frequency"] = df["ciudad"].map(frecuencias)

print(df)

      ciudad  ciudad_frequency
0     Madrid                 3
1  Barcelona                 2
2     Madrid                 3
3    Sevilla                 1
4     Madrid                 3
5  Barcelona                 2

      ciudad  ciudad_frequency
0     Madrid                 3
1  Barcelona                 2
2     Madrid                 3
3    Sevilla                 1
4     Madrid                 3
5  Barcelona                 2

Utilizando frecuencia relativa

import pandas as pd

frecuencias = (
    df["ciudad"]
    .value_counts(normalize=True)
)

df["ciudad_frequency"] = (
    df["ciudad"]
    .map(frecuencias)
)

print(df)

import pandas as pd

frecuencias = (
    df["ciudad"]
    .value_counts(normalize=True)
)

df["ciudad_frequency"] = (
    df["ciudad"]
    .map(frecuencias)
)

print(df)

      ciudad  ciudad_frequency
0     Madrid             0.50
1  Barcelona             0.33
2     Madrid             0.50
3    Sevilla             0.17
4     Madrid             0.50
5  Barcelona             0.33

      ciudad  ciudad_frequency
0     Madrid             0.50
1  Barcelona             0.33
2     Madrid             0.50
3    Sevilla             0.17
4     Madrid             0.50
5  Barcelona             0.33

Creando un transformador para Scikit-Learn

from sklearn.base import BaseEstimator, TransformerMixin

class FrequencyEncoder(
    BaseEstimator,
    TransformerMixin
):

    def fit(self, X, y=None):
        self.freq_map = (
            X.iloc[:, 0]
            .value_counts()
            .to_dict()
        )
        return self

    def transform(self, X):
        return X.iloc[:, 0].map(
            self.freq_map
        ).to_frame()

from sklearn.base import BaseEstimator, TransformerMixin

class FrequencyEncoder(
    BaseEstimator,
    TransformerMixin
):

    def fit(self, X, y=None):
        self.freq_map = (
            X.iloc[:, 0]
            .value_counts()
            .to_dict()
        )
        return self

    def transform(self, X):
        return X.iloc[:, 0].map(
            self.freq_map
        ).to_frame()

Uso dentro de un Pipeline

from sklearn.pipeline import Pipeline
from sklearn.ensemble import RandomForestClassifier

pipeline = Pipeline([
    ("encoder", FrequencyEncoder()),
    ("modelo", RandomForestClassifier())
])

pipeline.fit(X_train, y_train)

from sklearn.pipeline import Pipeline
from sklearn.ensemble import RandomForestClassifier

pipeline = Pipeline([
    ("encoder", FrequencyEncoder()),
    ("modelo", RandomForestClassifier())
])

pipeline.fit(X_train, y_train)

Buenas prácticas

Al utilizar Frequency Encoding es recomendable:

• Calcular las frecuencias únicamente sobre el conjunto de entrenamiento.
• Aplicar exactamente el mismo mapeo al conjunto de prueba.
• Definir una estrategia para categorías no vistas.
• Evaluar posibles colisiones entre categorías con igual frecuencia.
• Comparar su rendimiento frente a One-Hot Encoding y Target Encoding.

Conclusión

Frequency Encoding es una técnica eficiente para transformar variables categóricas sustituyendo cada categoría por su frecuencia de aparición en los datos. Su principal ventaja es que permite manejar variables de alta cardinalidad sin aumentar la dimensionalidad del conjunto de datos, manteniendo una representación compacta y fácil de implementar.

Aunque puede perder información cuando distintas categorías comparten la misma frecuencia, sigue siendo una alternativa muy útil en proyectos de Data Science y Machine Learning donde el tamaño del dataset y la eficiencia computacional son factores importantes. Utilizada correctamente, puede proporcionar una representación simple y efectiva de variables categóricas complejas sin incurrir en los problemas de dimensionalidad asociados a otras técnicas de codificación.

¿Qué es Ordinal Encoding?

Ordinal Encoding es una técnica de transformación de datos utilizada para convertir variables categóricas en valores numéricos cuando existe un orden o jerarquía natural entre las categorías.

Muchos algoritmos de Machine Learning trabajan exclusivamente con datos numéricos y no pueden procesar directamente valores de texto como “Bajo”, “Medio” o “Alto”. Ordinal Encoding resuelve este problema asignando un número entero a cada categoría respetando su orden lógico.

Por ejemplo:

En este caso, el modelo puede interpretar correctamente que “Alto” representa una categoría superior a “Medio” y “Medio” es superior a “Bajo”.

¿Cómo funciona Ordinal Encoding?

El proceso consiste en:

• Identificar una variable categórica ordinal.
• Definir el orden correcto de las categorías.
• Asignar un valor numérico a cada nivel.
• Sustituir las categorías originales por sus códigos numéricos.

Supongamos la siguiente variable:

Se puede codificar como:

De esta forma se conserva la relación jerárquica entre categorías.

Ejemplo práctico

Imaginemos un conjunto de datos de evaluación de clientes:

Aplicando Ordinal Encoding:

Ahora la variable puede utilizarse directamente en algoritmos de Machine Learning.

¿Por qué es necesario codificar variables categóricas?

Los modelos matemáticos trabajan con números y operaciones aritméticas. Cuando una variable contiene texto el algoritmo no puede calcular distancias, correlaciones o coeficientes. La codificación transforma estas categorías en valores numéricos manteniendo la información relevante para el modelo.

¿Cuándo utilizar Ordinal Encoding?

Esta técnica es recomendable cuando:

• Existe una relación jerárquica entre categorías.
• El orden de las categorías tiene significado.
• Se desea conservar la información de ranking.
• Las categorías representan niveles o escalas.

Ejemplos comunes:

• Nivel educativo.
• Grado de satisfacción.
• Clasificación de riesgo.
• Prioridad de incidencias.
• Tallas de ropa.
• Nivel de experiencia profesional.
• Escalas de calidad.
• Calificaciones académicas.

Casos donde NO debe utilizarse

No es recomendable cuando las categorías no tienen un orden natural.

Por ejemplo:

Si se codifican como:

el modelo podría interpretar incorrectamente que Verde es “mayor” que Azul y Azul es “mayor” que Rojo. En estos casos suele ser preferible utilizar One-Hot Encoding.

Beneficios de Ordinal Encoding

Entre sus principales beneficios destacan:

• Convierte variables categóricas en datos numéricos.
• Conserva el orden natural de las categorías.
• Reduce la dimensionalidad.
• Genera una única columna por variable.
• Es fácil de interpretar.
• Tiene bajo coste computacional.
• Resulta eficiente para grandes volúmenes de datos.

Ventajas de Ordinal Encoding

Las principales ventajas son:

• Implementación sencilla.
• Consumo mínimo de memoria.
• Compatible con prácticamente cualquier algoritmo.
• Mantiene la información jerárquica.
• Evita la explosión de dimensiones.
• Facilita el procesamiento de grandes datasets.

Además, al generar una sola columna codificada, resulta especialmente útil cuando existen muchas observaciones.

Desventajas de Ordinal Encoding

También presenta algunas limitaciones:

• Puede introducir relaciones numéricas artificiales.
• Algunos algoritmos interpretan las diferencias entre categorías como distancias reales.
• La asignación incorrecta del orden puede degradar el rendimiento del modelo.
• No es adecuada para variables nominales.

Por ejemplo:

El algoritmo podría asumir que la diferencia entre Bajo y Medio es exactamente igual que entre Medio y Alto, lo cual no siempre es cierto.

Limitaciones

Antes de aplicar esta técnica conviene considerar que:

• Requiere conocer el orden correcto de las categorías.
• No refleja necesariamente distancias reales entre niveles.
• Puede inducir sesgos en algunos modelos.
• No resulta adecuada para variables sin jerarquía.
• La codificación puede depender del contexto del problema.

Por ejemplo, una escala de satisfacción podría tener diferencias subjetivas entre categorías que no son uniformes.

Comparación con otras técnicas de codificación

Ordinal Encoding vs One-Hot Encoding

La regla general es sencilla:

• Variables ordinales → Ordinal Encoding.
• Variables nominales → One-Hot Encoding.

Aplicaciones en Data Science y Machine Learning

Ordinal Encoding aparece frecuentemente en:

• Modelos de scoring crediticio.
• Predicción de abandono de clientes.
• Sistemas de evaluación de riesgos.
• Recursos humanos.
• Marketing analítico.
• Segmentación de clientes.
• Modelos de satisfacción del cliente.
• Análisis educativo.
• Predicción de calidad de productos.

También es habitual en datasets que contienen:

• Niveles de satisfacción.
• Rangos de ingresos.
• Clasificaciones de riesgo.
• Prioridades operativas.
• Escalas de calidad.

Algoritmos donde suele utilizarse

Ordinal Encoding puede emplearse antes de algoritmos como:

• Regresión logística.
• Regresión lineal.
• Árboles de decisión.
• Random Forest.
• Gradient Boosting.
• XGBoost.
• LightGBM.
• Redes neuronales.
• Máquinas de vectores de soporte (SVM).

No obstante, los algoritmos basados en distancias deben utilizarse con precaución, ya que podrían interpretar los códigos como magnitudes reales.

Implementación en Python

Scikit-Learn incluye la clase OrdinalEncoder para realizar esta transformación.

Ejemplo básico

import pandas as pd
from sklearn.preprocessing import OrdinalEncoder

df = pd.DataFrame({
    "satisfaccion": ["Baja", "Media", "Alta", "Media"]
})

encoder = OrdinalEncoder(
    categories=[["Baja", "Media", "Alta"]]
)

df["satisfaccion_codificada"] = encoder.fit_transform(
    df[["satisfaccion"]]
)

print(df)

import pandas as pd
from sklearn.preprocessing import OrdinalEncoder

df = pd.DataFrame({
    "satisfaccion": ["Baja", "Media", "Alta", "Media"]
})

encoder = OrdinalEncoder(
    categories=[["Baja", "Media", "Alta"]]
)

df["satisfaccion_codificada"] = encoder.fit_transform(
    df[["satisfaccion"]]
)

print(df)

Resultado:

  satisfaccion  satisfaccion_codificada
0        Baja                      0.0
1       Media                      1.0
2        Alta                      2.0
3       Media                      1.0

  satisfaccion  satisfaccion_codificada
0        Baja                      0.0
1       Media                      1.0
2        Alta                      2.0
3       Media                      1.0

Codificación de múltiples variables

import pandas as pd
from sklearn.preprocessing import OrdinalEncoder

df = pd.DataFrame({
    "riesgo": ["Bajo", "Medio", "Alto"],
    "prioridad": ["Baja", "Media", "Alta"]
})

encoder = OrdinalEncoder(
    categories=[
        ["Bajo", "Medio", "Alto"],
        ["Baja", "Media", "Alta"]
    ]
)

df_codificado = encoder.fit_transform(df)

print(df_codificado)

import pandas as pd
from sklearn.preprocessing import OrdinalEncoder

df = pd.DataFrame({
    "riesgo": ["Bajo", "Medio", "Alto"],
    "prioridad": ["Baja", "Media", "Alta"]
})

encoder = OrdinalEncoder(
    categories=[
        ["Bajo", "Medio", "Alto"],
        ["Baja", "Media", "Alta"]
    ]
)

df_codificado = encoder.fit_transform(df)

print(df_codificado)

Uso dentro de un Pipeline

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import OrdinalEncoder
from sklearn.ensemble import RandomForestClassifier

pipeline = Pipeline([
    ("encoder", OrdinalEncoder(
        categories=[["Bajo", "Medio", "Alto"]]
    )),
    ("modelo", RandomForestClassifier())
])

pipeline.fit(X_train, y_train)

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import OrdinalEncoder
from sklearn.ensemble import RandomForestClassifier

pipeline = Pipeline([
    ("encoder", OrdinalEncoder(
        categories=[["Bajo", "Medio", "Alto"]]
    )),
    ("modelo", RandomForestClassifier())
])

pipeline.fit(X_train, y_train)

Este enfoque garantiza que la misma codificación se aplique tanto en entrenamiento como en producción.

Buenas prácticas

Al utilizar Ordinal Encoding es recomendable:

• Verificar que existe un orden real entre categorías.
• Definir explícitamente el orden.
• Documentar la codificación utilizada.
• Evitar aplicarlo a variables nominales.
• Validar el impacto de la codificación sobre el rendimiento del modelo.
• Utilizar pipelines para evitar inconsistencias.

Conclusión

Ordinal Encoding es una técnica fundamental de preparación de datos que permite transformar variables categóricas ordinales en valores numéricos preservando su estructura jerárquica. Su simplicidad, eficiencia y bajo consumo de memoria la convierten en una excelente opción cuando las categorías poseen un orden natural que aporta información relevante al modelo.

Sin embargo, debe utilizarse únicamente cuando existe una relación ordinal real entre las categorías. Aplicarla sobre variables nominales puede introducir relaciones artificiales y afectar negativamente al rendimiento de los algoritmos. Cuando se emplea correctamente, constituye una herramienta sencilla y eficaz para preparar datos categóricos en proyectos de Data Science y Machine Learning.

¿Qué es Unit Vector Scaling?

Unit Vector Scaling, también conocido como Normalization o Normalización por Vector Unitario, es una técnica de escalado que transforma cada observación de un conjunto de datos para que tenga una longitud o norma igual a 1.

A diferencia de otros métodos de escalado como Min-Max Scaling o Standard Scaling, que operan sobre las características (columnas), la normalización por vector unitario actúa sobre las observaciones (filas). Esto significa que cada registro es escalado de forma independiente.

El objetivo principal es conservar la dirección del vector mientras se elimina el efecto de su magnitud. En otras palabras, importa cómo están distribuidos los valores dentro de una observación, no el tamaño absoluto de esos valores.

Esta técnica es ampliamente utilizada en procesamiento de texto, sistemas de recomendación, análisis de similitud y algoritmos basados en distancia o ángulos.

¿Cómo funciona Unit Vector Scaling?

La normalización consiste en dividir cada valor de una observación por la norma del vector al que pertenece. La forma más habitual es utilizar la norma L2 (Euclidiana):

$$x_i^{‘}=\frac{x_i}{\sqrt{x_1^2+x_2^2+\cdots+x_n^2}}$$

Donde:

• \(x_i\) es un valor de la observación.
• El denominador representa la norma L2 del vector.
• \(x_i’\) es el valor normalizado.

Después de la transformación, la longitud del vector será exactamente igual a 1. Matemáticamente: \(|x|_2=1\)

Tipos de normalización más comunes

Scikit-Learn permite utilizar distintas métricas de normalización.

Norma L2

Es la más utilizada en Machine Learning.

$$||x||2=\sqrt{\sum{i=1}^{n}x_i^2}$$

Características:

• Mantiene la dirección del vector.
• Produce vectores de longitud 1.
• Muy utilizada en NLP y similitud coseno.

Norma L1

Se basa en la suma de valores absolutos.

$$||x||1=\sum{i=1}^{n}|x_i|$$

Características:

• Más robusta frente a valores extremos.
• Produce vectores cuya suma absoluta es 1.

Norma Max

Utiliza el valor máximo absoluto del vector.

$$||x||_{\infty}=max(|x_i|)$$

Características:

• Escala usando únicamente el valor de mayor magnitud.
• Menos utilizada en aplicaciones prácticas.

Ejemplo de Unit Vector Scaling

Supongamos la siguiente observación:

Calculamos la norma L2:

$$\sqrt{3^2+4^2}$$

$$\sqrt{9+16}$$

$$\sqrt{25}=5$$

Ahora dividimos cada valor por 5:

La longitud del nuevo vector es: \(\sqrt{0.6^2+0.8^2}=1\). La dirección se mantiene exactamente igual, pero la magnitud desaparece.

Diferencia entre escalado y normalización

Es frecuente confundir ambos conceptos.

• Escalado: Modifica la escala de las variables, actúa sobre columnas. Ejemplos:
  • Min-Max Scaling
  • Standard Scaling
  • Robust Scaling
  • MaxAbs Scaling

• Normalización: Modifica cada observación individualmente, actúa sobre filas. La normalización busca igualar la longitud de todos los vectores. Ejemplos:
  • L1 Normalization
  • L2 Normalization
  • Max Normalization

Beneficios de Unit Vector Scaling

• Elimina el efecto de la magnitud.
• Conserva la dirección de los datos.
• Facilita cálculos de similitud.
• Mejora algoritmos basados en distancia angular.
• Resulta especialmente útil en datos de alta dimensionalidad.
• Permite comparar observaciones independientemente de su tamaño.
• Reduce el impacto de diferencias de escala entre registros.

¿Cuándo utilizar Unit Vector Scaling?

• Se utilizan métricas de similitud.
• Se trabaja con vectores de texto.
• La dirección es más importante que la magnitud.
• Se emplea similitud coseno.
• Existen observaciones con tamaños muy diferentes.
• Se procesan datos de alta dimensionalidad.

Casos habituales:

• Motores de búsqueda.
• Sistemas de recomendación.
• Clasificación de documentos.
• Recuperación de información.
• Procesamiento de lenguaje natural.

Ventajas de Unit Vector Scaling

• Fácil de implementar.
• Mantiene la estructura relativa de cada observación.
• Muy útil para análisis de similitud.
• Funciona bien en espacios de alta dimensionalidad.
• Compatible con matrices dispersas.
• Reduce diferencias de magnitud entre registros.
• Mejora el rendimiento de algunos algoritmos de clustering y clasificación.

Desventajas de Unit Vector Scaling

• No reduce la influencia de outliers.
• No corrige distribuciones sesgadas.
• No centra los datos.
• Puede eliminar información útil relacionada con la magnitud.
• No siempre mejora el rendimiento predictivo.

En algunos problemas la magnitud contiene información importante que se perderá tras la normalización.

Limitaciones

Antes de aplicar esta técnica conviene considerar que:

• No elimina ruido.
• No trata valores faltantes.
• No corrige asimetrías.
• No transforma distribuciones no normales.
• No reduce la dimensionalidad.
• No es adecuada cuando la magnitud tiene significado predictivo.

Por ejemplo, en modelos financieros o de ventas, el tamaño absoluto de una variable puede ser tan importante como su proporción respecto a otras.

Comparación con otros métodos de escalado

Unit Vector Scaling vs Min-Max Scaling

Min-Max Scaling:

• Escala columnas.
• Lleva los datos a un rango determinado.
• Conserva diferencias de magnitud.

Unit Vector Scaling:

• Escala filas.
• Elimina la magnitud.
• Conserva únicamente la dirección.

Unit Vector Scaling vs Standard Scaling

Standard Scaling:

• Centra los datos en media cero.
• Utiliza la desviación estándar.

Unit Vector Scaling:

• No utiliza media ni desviación.
• Escala cada observación individualmente.

Unit Vector Scaling vs MaxAbs Scaling

MaxAbs Scaling:

• Escala variables.
• Mantiene la distribución original.

Unit Vector Scaling:

• Escala observaciones.
• Modifica completamente la magnitud de cada registro.

Aplicaciones en Data Science y Machine Learning

La normalización por vector unitario es especialmente importante en:

• Procesamiento de lenguaje natural (NLP).
• Análisis de documentos.
• Sistemas de recomendación.
• Recuperación de información.
• Análisis de similitud.
• Búsquedas semánticas.
• Embeddings de texto.
• Visión por computador.
• Detección de duplicados.

También suele utilizarse antes de algoritmos como:

• K-Nearest Neighbors (KNN).
• K-Means.
• Clustering jerárquico.
• Máquinas de vectores de soporte (SVM).
• Análisis de similitud coseno.
• Sistemas basados en embeddings.

Relación con la similitud coseno

Uno de los usos más importantes de la normalización es el cálculo de la similitud coseno. La similitud coseno mide el ángulo entre dos vectores y no depende de su tamaño. Su fórmula es:

$$\cos(\theta)=\frac{A\cdot B}{|A||B|}$$

Cuando ambos vectores han sido normalizados previamente, el cálculo se simplifica considerablemente porque sus normas son iguales a 1. Por esta razón, la normalización L2 es una práctica habitual en motores de búsqueda, sistemas de recomendación y modelos de lenguaje.

Implementación en Python

Scikit-Learn proporciona la función normalize y el transformador Normalizer.

Utilizando normalize()

from sklearn.preprocessing import normalize
import numpy as np

X = np.array([
    [3, 4],
    [1, 2],
    [5, 12]
])

X_norm = normalize(X, norm='l2')

print(X_norm)

from sklearn.preprocessing import normalize
import numpy as np

X = np.array([
    [3, 4],
    [1, 2],
    [5, 12]
])

X_norm = normalize(X, norm='l2')

print(X_norm)

[[0.6        0.8       ]
 [0.4472136  0.89442719]
 [0.38461538 0.92307692]]

[[0.6        0.8       ]
 [0.4472136  0.89442719]
 [0.38461538 0.92307692]]

Utilizando Normalizer

from sklearn.preprocessing import Normalizer

normalizer = Normalizer(norm='l2')

X_norm = normalizer.fit_transform(X)

print(X_norm)

from sklearn.preprocessing import Normalizer

normalizer = Normalizer(norm='l2')

X_norm = normalizer.fit_transform(X)

print(X_norm)

[[0.6        0.8       ]
 [0.4472136  0.89442719]
 [0.38461538 0.92307692]]

[[0.6        0.8       ]
 [0.4472136  0.89442719]
 [0.38461538 0.92307692]]

Normalización L1

from sklearn.preprocessing import Normalizer

normalizer = Normalizer(norm='l1')

X_l1 = normalizer.fit_transform(X)

print(X_l1)

from sklearn.preprocessing import Normalizer

normalizer = Normalizer(norm='l1')

X_l1 = normalizer.fit_transform(X)

print(X_l1)

[[0.42857143 0.57142857]
 [0.33333333 0.66666667]
 [0.29411765 0.70588235]]

[[0.42857143 0.57142857]
 [0.33333333 0.66666667]
 [0.29411765 0.70588235]]

Uso dentro de un Pipeline

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import Normalizer
from sklearn.neighbors import KNeighborsClassifier

pipeline = Pipeline([
    ("normalizacion", Normalizer(norm='l2')),
    ("modelo", KNeighborsClassifier())
])

pipeline.fit(X_train, y_train)

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import Normalizer
from sklearn.neighbors import KNeighborsClassifier

pipeline = Pipeline([
    ("normalizacion", Normalizer(norm='l2')),
    ("modelo", KNeighborsClassifier())
])

pipeline.fit(X_train, y_train)

Este enfoque garantiza que todas las observaciones reciban exactamente la misma transformación tanto durante el entrenamiento como durante la predicción.

Conclusión

Unit Vector Scaling o Normalization es una técnica de transformación que convierte cada observación en un vector de longitud unitaria, preservando su dirección y eliminando las diferencias de magnitud. A diferencia de los métodos tradicionales de escalado, opera sobre filas en lugar de columnas, lo que la hace especialmente útil cuando el interés se centra en las relaciones relativas entre variables dentro de cada observación.

Su aplicación es fundamental en áreas como procesamiento de lenguaje natural, recuperación de información, sistemas de recomendación y análisis de similitud, donde la orientación de los vectores resulta más importante que su tamaño absoluto. Aunque no corrige problemas estadísticos como outliers o distribuciones sesgadas, sigue siendo una de las técnicas más utilizadas en entornos de Machine Learning basados en medidas de distancia y similitud.

¿Qué es MaxAbs Scaling?

MaxAbs Scaling es una técnica de escalado de datos que transforma las variables numéricas dividiendo cada valor por el valor absoluto máximo de su característica. Como resultado, todos los valores quedan dentro del rango comprendido entre -1 y 1.

A diferencia de otros métodos de escalado, MaxAbs Scaling no centra los datos alrededor de cero ni modifica la distribución original de la variable. Su principal objetivo es reducir la magnitud de los datos manteniendo intactas las relaciones entre los valores.

Esta técnica es especialmente útil cuando se trabaja con datos dispersos (sparse data), como matrices de texto generadas mediante Bag of Words (BoW) o TF-IDF, donde preservar los valores cero es fundamental.

¿Cómo funciona MaxAbs Scaling?

El procedimiento consiste en identificar el valor absoluto máximo de cada variable y dividir todos los valores de esa característica por dicho máximo. La transformación se define mediante la siguiente fórmula:

$$x_{scaled}=\frac{x}{|x_{max}|}$$

Donde:

• \(x\) es el valor original.
• \(|x_{max}|\) es el valor absoluto máximo de la característica.
• \(x_{scaled}\) es el valor transformado.

El resultado siempre se encuentra dentro del intervalo:

• -1 para el valor negativo de mayor magnitud.
• 1 para el valor positivo de mayor magnitud.
• 0 permanece exactamente en 0.

Ejemplo de MaxAbs Scaling

Supongamos la siguiente variable:

var = [-50, -25, 0, 25, 50]

var = [-50, -25, 0, 25, 50]

El valor absoluto máximo es: \(|50| = 50\). Aplicando la transformación:

var = [-1.0, -0.5, 0.0, 0.5, 1.0]

var = [-1.0, -0.5, 0.0, 0.5, 1.0]

Puede observarse que:

• La forma de la distribución permanece igual.
• Los signos positivos y negativos se conservan.
• Los valores quedan normalizados entre -1 y 1.

¿Por qué es importante escalar los datos?

Muchos algoritmos de Machine Learning son sensibles a la magnitud de las variables.

Por ejemplo:

• Una característica con valores entre 0 y 100.000 puede dominar a otra cuyos valores oscilan entre 0 y 10.
• Los cálculos de distancia pueden verse distorsionados.
• Los algoritmos de optimización pueden tardar más en converger.

MaxAbs Scaling permite equilibrar las escalas de las variables sin alterar la estructura original de los datos.

Beneficios de MaxAbs Scaling

• Mantiene los valores dentro del rango [-1,1].
• Conserva los valores cero.
• Preserva la dispersión original de los datos.
• No modifica la forma de la distribución.
• Es computacionalmente eficiente.
• Funciona muy bien con matrices dispersas.
• Reduce problemas derivados de escalas muy diferentes entre variables.

¿Cuándo utilizar MaxAbs Scaling?

• Se trabaja con datos dispersos (sparse matrices).
• Los valores cero tienen un significado importante.
• Se utilizan representaciones de texto como BoW o TF-IDF.
• Se desea mantener la distribución original.
• Existen variables positivas y negativas.
• Se busca una transformación rápida y sencilla.

Casos típicos:

• Procesamiento de lenguaje natural (NLP).
• Sistemas de recomendación.
• Motores de búsqueda.
• Clasificación de documentos.
• Análisis de grandes matrices dispersas.

Ventajas de MaxAbs Scaling

• Extremadamente rápido de calcular.
• Muy eficiente en memoria.
• Compatible con datos dispersos.
• No destruye la estructura de los datos.
• Conserva los ceros originales.
• Fácil de interpretar.
• Escala tanto valores positivos como negativos.

Además, es una de las pocas técnicas de escalado diseñadas específicamente para trabajar correctamente con matrices sparse.

Desventajas de MaxAbs Scaling

• Es muy sensible a valores atípicos.
• Un único outlier puede determinar toda la escala.
• No reduce la asimetría de la distribución.
• No corrige problemas de sesgo.
• No centra los datos alrededor de la media.
• Puede producir escalados poco representativos cuando existen valores extremos.

Limitaciones

Antes de utilizar MaxAbs Scaling es importante considerar que:

• No elimina ruido.
• No trata valores faltantes.
• No corrige distribuciones no normales.
• No mejora problemas de multicolinealidad.
• No es adecuado cuando existen outliers muy pronunciados.

Si la variable contiene valores extremos importantes, suelen funcionar mejor técnicas como:

• Robust Scaling.
• Transformación Logarítmica.
• Yeo-Johnson.
• Box-Cox.

Comparación con otros métodos de escalado

MaxAbs Scaling vs Min-Max Scaling

Min-Max Scaling transforma los datos a un rango específico, normalmente entre 0 y 1.

MaxAbs Scaling:

• Mantiene valores negativos.
• Escala entre -1 y 1.
• Conserva los ceros.
• Es más adecuado para matrices dispersas.

MaxAbs Scaling vs Standard Scaling

Standard Scaling:

• Centra los datos en media cero.
• Escala usando la desviación estándar.

MaxAbs Scaling:

• No centra los datos.
• Mantiene la distribución original.
• Es menos costoso computacionalmente.

MaxAbs Scaling vs Robust Scaling

Robust Scaling:

• Utiliza la mediana y el rango intercuartílico.
• Es resistente a outliers.

MaxAbs Scaling:

• Es mucho más sensible a valores extremos.
• Resulta más rápido cuando los datos están relativamente limpios.

Aplicaciones en Data Science y Machine Learning

MaxAbs Scaling aparece frecuentemente en:

• Procesamiento de lenguaje natural (NLP).
• Clasificación de textos.
• Análisis de sentimientos.
• Sistemas de recomendación.
• Motores de búsqueda.
• Detección de spam.
• Recuperación de información.
• Clustering sobre matrices dispersas.
• Modelos lineales de alta dimensionalidad.

También suele utilizarse antes de algoritmos como:

• Regresión logística.
• Máquinas de vectores de soporte (SVM).
• K-Means.
• Redes neuronales.
• Descenso por gradiente.

Implementación en Python

Scikit-Learn incluye una implementación optimizada mediante la clase MaxAbsScaler.

Ejemplo básico

import pandas as pd
from sklearn.preprocessing import MaxAbsScaler

datos = pd.DataFrame({
    "ingresos": [1000, 2500, 5000, 10000]
})

scaler = MaxAbsScaler()

datos_escalados = scaler.fit_transform(datos)

print(datos_escalados)

import pandas as pd
from sklearn.preprocessing import MaxAbsScaler

datos = pd.DataFrame({
    "ingresos": [1000, 2500, 5000, 10000]
})

scaler = MaxAbsScaler()

datos_escalados = scaler.fit_transform(datos)

print(datos_escalados)

[[0.10]
 [0.25]
 [0.50]
 [1.00]]

[[0.10]
 [0.25]
 [0.50]
 [1.00]]

Ejemplo con múltiples variables

import pandas as pd
from sklearn.preprocessing import MaxAbsScaler

df = pd.DataFrame({
    "edad": [20, 35, 50, 65],
    "ingresos": [1000, 5000, 10000, 20000]
})

scaler = MaxAbsScaler()

df_scaled = pd.DataFrame(
    scaler.fit_transform(df),
    columns=df.columns
)

print(df_scaled)

import pandas as pd
from sklearn.preprocessing import MaxAbsScaler

df = pd.DataFrame({
    "edad": [20, 35, 50, 65],
    "ingresos": [1000, 5000, 10000, 20000]
})

scaler = MaxAbsScaler()

df_scaled = pd.DataFrame(
    scaler.fit_transform(df),
    columns=df.columns
)

print(df_scaled)

       edad  ingresos
0  0.307692      0.05
1  0.538462      0.25
2  0.769231      0.50
3  1.000000      1.00

       edad  ingresos
0  0.307692      0.05
1  0.538462      0.25
2  0.769231      0.50
3  1.000000      1.00

Uso dentro de un Pipeline

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

pipeline = Pipeline([
    ("scaler", MaxAbsScaler()),
    ("modelo", LogisticRegression())
])

pipeline.fit(X_train, y_train)

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

pipeline = Pipeline([
    ("scaler", MaxAbsScaler()),
    ("modelo", LogisticRegression())
])

pipeline.fit(X_train, y_train)

Este enfoque garantiza que los datos de entrenamiento y predicción reciban exactamente la misma transformación.

Conclusión

MaxAbs Scaling es una técnica de escalado sencilla y eficiente que normaliza las variables utilizando el valor absoluto máximo de cada característica. Su principal fortaleza radica en que preserva la estructura original de los datos y mantiene intactos los valores cero, lo que la convierte en una herramienta especialmente útil para trabajar con matrices dispersas y aplicaciones de procesamiento de texto.

Aunque es rápida y fácil de implementar, su sensibilidad a los valores atípicos limita su utilidad en algunos escenarios. Por ello, suele ser una excelente opción para conjuntos de datos limpios y de alta dimensionalidad, especialmente en proyectos de NLP, sistemas de recomendación y modelos de Machine Learning que requieren variables escaladas sin alterar la distribución original de los datos.

Capturando Relaciones No Lineales en Machine Learning

Las Transformaciones de Ingeniería de Características Polinomiales (Polynomial Feature Engineering) son una técnica ampliamente utilizada en Data Science y Machine Learning para enriquecer un conjunto de datos mediante la creación de nuevas variables derivadas de las características originales.

Su objetivo principal es permitir que algoritmos lineales puedan modelar relaciones no lineales presentes en los datos sin necesidad de utilizar modelos más complejos. Esta técnica resulta especialmente útil cuando existe evidencia de que la relación entre las variables predictoras y la variable objetivo no sigue una tendencia lineal simple.

Las características polinomiales forman parte de las técnicas clásicas de ingeniería de características y suelen utilizarse como paso previo al entrenamiento de modelos predictivos.

¿Qué son las transformaciones de características polinomiales?

Las transformaciones polinomiales consisten en generar nuevas variables elevando las características originales a diferentes potencias y creando combinaciones entre ellas. Por ejemplo, si disponemos de una variable X. Podemos generar nuevas características como:

$$X, X^2, X^3, X^4$$

Si contamos con dos variables: \(X_1, X_2\), las nuevas características podrían incluir:

$$X_1, X_2, X_1^2, X_2^2, X_1X_2$$

Estas nuevas variables permiten representar patrones más complejos que no podrían capturarse utilizando únicamente las características originales.

¿Cómo funcionan las características polinomiales?

La idea fundamental consiste en ampliar el espacio de características. Supongamos una relación real entre una variable de entrada y una variable objetivo:

$$y=x^2+3x+2″$$

Si utilizamos únicamente la variable (x), un modelo lineal tendrá dificultades para representar correctamente la curva. Sin embargo, si añadimos la característica \(X_2\), el problema puede transformarse en una regresión lineal sobre las variables:

• \(x\)
• \(x^2\)

Desde la perspectiva del modelo, la relación sigue siendo lineal respecto a los coeficientes, aunque la función representada sea no lineal.

Generación de características polinomiales

Para un polinomio de grado 2 con dos variables: \(x_1,x_2\) las nuevas características serían:

$$1,x_1,x_2,x_1^2,x_1x_2,x_2^2$$

Para un polinomio de grado 3:

$$x_1^3,x_1^2x_2,x_1x_2^2,x_2^3$$

A medida que aumenta el grado del polinomio, también crece significativamente el número de variables generadas.

Ejemplo conceptual

Supongamos un problema inmobiliario donde queremos predecir el precio de una vivienda utilizando metros cuadrados. La relación real podría ser:

• Las viviendas pequeñas aumentan de precio rápidamente.
• Las viviendas medianas mantienen una tendencia estable.
• Las viviendas muy grandes muestran incrementos menos pronunciados.

Esta relación suele adoptar una forma curva. Al incorporar:

• Metros cuadrados.
• Metros cuadrados al cuadrado.

El modelo puede capturar mejor dicha curvatura.

Beneficios de las transformaciones polinomiales

• Permiten modelar relaciones no lineales.
• Mejoran la capacidad predictiva de modelos lineales.
• Son fáciles de implementar.
• Incrementan la flexibilidad del modelo.
• Facilitan la captura de interacciones entre variables.
• Pueden mejorar significativamente el rendimiento sin cambiar de algoritmo.

¿Cuándo utilizar características polinomiales?

• Existen relaciones no lineales evidentes.
• Los modelos lineales presentan bajo rendimiento.
• Se desea mantener la interpretabilidad.
• El número de variables originales es relativamente reducido.
• Se sospecha que existen interacciones entre variables.

Escenarios habituales:

• Predicción de precios.
• Modelos económicos.
• Series temporales simples.
• Análisis de comportamiento de clientes.
• Modelos de riesgo financiero.

Ejemplos prácticos

Predicción inmobiliaria

Variables originales:

• Superficie.
• Antigüedad.

Características adicionales:

• Superficie².
• Antigüedad².
• Superficie × Antigüedad.

Marketing

Variables originales:

• Inversión publicitaria.
• Frecuencia de exposición.

Características adicionales:

• Inversión².
• Frecuencia².
• Inversión × Frecuencia.

Salud

Variables originales:

• Edad.
• Índice de masa corporal.

Características adicionales:

• Edad².
• IMC².
• Edad × IMC.

Estas nuevas variables permiten capturar patrones más complejos en los datos.

Ventajas

• Fácil aplicación.
• Compatible con numerosos algoritmos.
• Mejora el ajuste de modelos lineales.
• Captura relaciones curvilíneas.
• Permite modelar interacciones.
• Mantiene cierta interpretabilidad.

Además, suele combinarse muy bien con algoritmos como:

• Regresión Lineal.
• Regresión Logística.
• Support Vector Machines.
• Redes neuronales.

Desventajas

• Incrementa rápidamente la dimensionalidad.
• Puede introducir ruido.
• Aumenta el riesgo de sobreajuste.
• Incrementa los tiempos de entrenamiento.
• Reduce la interpretabilidad cuando se generan muchas variables.

A medida que aumenta el grado polinomial, estos problemas suelen hacerse más evidentes.

Limitaciones

• Explosión combinatoria: El número de características generadas crece rápidamente: 10 variables originales es polinomio de grado 3. Pueden generar cientos de nuevas características. Esto aumenta: memoria utilizada, coste computacional y riesgo de sobreajuste.
• Sobreajuste: Los polinomios de grado elevado pueden ajustarse excesivamente a los datos de entrenamiento, como consecuencia, el rendimiento en entrenamiento mejora y la capacidad de generalización disminuye.
• Interpretación más compleja: Aunque el modelo siga siendo lineal, interpretar decenas o cientos de términos polinomiales puede resultar difícil.
• Sensibilidad a escalas: Las variables elevadas a potencias superiores generan valores mucho mayores. Por ello suele recomendarse aplicar previamente: estandarización y normalización.

Aplicaciones en Data Science y Machine Learning

Las transformaciones polinomiales tienen numerosas aplicaciones.

Modelos de regresión

• Predicción de precios.
• Predicción de demanda.
• Pronósticos económicos.

Clasificación

• Regresión logística enriquecida.
• Clasificación de clientes.
• Scoring crediticio.

Machine Learning tradicional

• Support Vector Machines.
• Redes neuronales.
• Gradient Boosting.

Ciencia de datos empresarial

• Marketing analítico.
• Predicción de abandono de clientes.
• Modelos de conversión.

Investigación científica

• Modelado físico.
• Sistemas biológicos.
• Análisis experimentales.

Buenas prácticas al utilizar características polinomiales

Para obtener mejores resultados es recomendable:

• Comenzar con grados bajos (2 o 3).
• Escalar las variables antes de la transformación.
• Utilizar validación cruzada.
• Evaluar posibles problemas de sobreajuste.
• Aplicar regularización cuando sea necesario.

Las técnicas de regularización más utilizadas son:

• Ridge Regression.
• Lasso Regression.
• Elastic Net.

Implementación en Python

Scikit-Learn proporciona la clase PolynomialFeatures para generar automáticamente estas variables.

Ejemplo básico

import numpy as np
from sklearn.preprocessing import PolynomialFeatures

X = np.array([
    [2],
    [3],
    [4]
])

poly = PolynomialFeatures(
    degree=2,
    include_bias=False
)

X_poly = poly.fit_transform(X)

print(X_poly)

import numpy as np
from sklearn.preprocessing import PolynomialFeatures

X = np.array([
    [2],
    [3],
    [4]
])

poly = PolynomialFeatures(
    degree=2,
    include_bias=False
)

X_poly = poly.fit_transform(X)

print(X_poly)

[[ 2.  4.]
 [ 3.  9.]
 [ 4. 16.]]

[[ 2.  4.]
 [ 3.  9.]
 [ 4. 16.]]

La segunda columna corresponde a: \(x^2\)

Ejemplo con múltiples variables

import numpy as np
from sklearn.preprocessing import PolynomialFeatures

X = np.array([
    [2, 3]
])

poly = PolynomialFeatures(
    degree=2,
    include_bias=False
)

X_poly = poly.fit_transform(X)

print(X_poly)

import numpy as np
from sklearn.preprocessing import PolynomialFeatures

X = np.array([
    [2, 3]
])

poly = PolynomialFeatures(
    degree=2,
    include_bias=False
)

X_poly = poly.fit_transform(X)

print(X_poly)

[[2. 3. 4. 6. 9.]]

[[2. 3. 4. 6. 9.]]

Las nuevas características son:

• x₁
• x₂
• x₁²
• x₁x₂
• x₂²

Uso con Regresión Lineal

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

modelo = Pipeline([
    ("poly", PolynomialFeatures(degree=2)),
    ("regressor", LinearRegression())
])

modelo.fit(X_train, y_train)

predicciones = modelo.predict(X_test)

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

modelo = Pipeline([
    ("poly", PolynomialFeatures(degree=2)),
    ("regressor", LinearRegression())
])

modelo.fit(X_train, y_train)

predicciones = modelo.predict(X_test)

Este enfoque permite entrenar un modelo lineal capaz de representar relaciones no lineales.

Combinación con escalado

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import Ridge

modelo = Pipeline([
    ("scaler", StandardScaler()),
    ("poly", PolynomialFeatures(degree=3)),
    ("ridge", Ridge(alpha=1.0))
])

modelo.fit(X_train, y_train)

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import Ridge

modelo = Pipeline([
    ("scaler", StandardScaler()),
    ("poly", PolynomialFeatures(degree=3)),
    ("ridge", Ridge(alpha=1.0))
])

modelo.fit(X_train, y_train)

Esta combinación suele ofrecer mejores resultados y reduce el riesgo de sobreajuste.

Conclusión

Las Transformaciones de Ingeniería de Características Polinomiales son una técnica fundamental para enriquecer conjuntos de datos y permitir que modelos lineales capturen relaciones no lineales complejas. Mediante la generación de potencias e interacciones entre variables, es posible aumentar significativamente la capacidad predictiva de numerosos algoritmos sin recurrir necesariamente a modelos más sofisticados.

Aunque presentan desafíos relacionados con la dimensionalidad y el sobreajuste, su correcta aplicación, acompañada de escalado y regularización, puede generar mejoras sustanciales en el rendimiento de modelos de Machine Learning. Por ello, constituyen una herramienta esencial dentro del proceso de ingeniería de características y preparación de datos en proyectos de Data Science.

Reducción de Dimensionalidad y Visualización de Datos Complejos

UMAP (Uniform Manifold Approximation and Projection) es una técnica moderna de reducción de dimensionalidad no lineal diseñada para representar conjuntos de datos de alta dimensionalidad en espacios de menor dimensión conservando, en la medida de lo posible, la estructura de los datos originales.

Desarrollada por Leland McInnes, John Healy y James Melville en 2018, UMAP se ha convertido en una de las alternativas más populares a t-SNE gracias a su capacidad para generar visualizaciones de alta calidad, su mayor velocidad de ejecución y su mejor escalabilidad en grandes volúmenes de datos.

Actualmente, UMAP es ampliamente utilizado en Data Science, Machine Learning, Deep Learning, bioinformática, procesamiento del lenguaje natural y visión por computadora para explorar datos complejos y extraer patrones ocultos.

¿Qué es UMAP?

UMAP es una técnica de reducción de dimensionalidad basada en principios de:

• Teoría de variedades (Manifold Learning).
• Topología algebraica.
• Geometría diferencial.
• Teoría de grafos.

Su objetivo consiste en proyectar datos de alta dimensionalidad a un espacio de menor dimensión manteniendo tanto las relaciones locales como parte de la estructura global del conjunto de datos. La idea fundamental es asumir que los datos se encuentran distribuidos sobre una variedad matemática de menor dimensión dentro del espacio original.

Por ejemplo:

• Imágenes representadas por miles de píxeles.
• Embeddings de texto con cientos de dimensiones.
• Datos genómicos con miles de variables.

Aunque aparentemente complejos, estos datos suelen contener estructuras internas que pueden representarse en menos dimensiones sin perder gran parte de la información relevante.

¿Cómo funciona UMAP?

UMAP trabaja en dos etapas principales.

Construcción de una representación topológica

Primero identifica las relaciones de vecindad entre observaciones.

Para ello:

• Calcula los vecinos más cercanos de cada punto.
• Construye un grafo ponderado.
• Estima la estructura local de los datos.

El concepto básico puede representarse mediante la distancia entre observaciones:

$$d(x_i,x_j)=||x_i-x_j||$$

A partir de estas distancias se genera una representación probabilística de las relaciones entre los puntos.

Optimización en baja dimensión

Posteriormente, el algoritmo busca una representación reducida que conserve la estructura del grafo original. Para ello minimiza una función de coste que mide la diferencia entre:

• Las relaciones en el espacio original.
• Las relaciones en el espacio reducido.

El resultado es una proyección de dos o tres dimensiones donde los puntos similares permanecen cercanos.

Fundamentos intuitivos de UMAP

La intuición detrás de UMAP es sencilla. Supongamos un conjunto de fotografías de animales. Cada imagen contiene miles de características numéricas.

UMAP intenta:

• Identificar cuáles imágenes son similares.
• Construir una red de relaciones entre ellas.
• Proyectar esa red en un espacio de menor dimensión.

Como resultado:

• Las imágenes de perros aparecen agrupadas.
• Las imágenes de gatos forman otro grupo.
• Las aves aparecen en una región distinta.

Todo ello conservando gran parte de la estructura original de los datos.

Ejemplo conceptual

Imaginemos una empresa de comercio electrónico con información de clientes basada en:

• Historial de compras.
• Frecuencia de visitas.
• Categorías preferidas.
• Tiempo de permanencia.
• Dispositivos utilizados.
• Interacciones con campañas.

El conjunto podría contener cientos de variables.

Aplicando UMAP es posible:

• Reducir la complejidad de los datos.
• Visualizar segmentos de clientes.
• Detectar grupos de comportamiento similares.
• Identificar posibles anomalías.

Parámetros más importantes de UMAP

El comportamiento del algoritmo depende principalmente de dos hiperparámetros.

• n_neighbors : Controla el número de vecinos considerados para construir la estructura local.
  • Valores pequeños conservan patrones muy locales y detectan grupos pequeños.
  • Valores grandes capturan estructuras más globales y generan agrupaciones más suaves. Los valores más habituales se encuentran entre 5 y 50.

• min_dist: Controla la distancia mínima permitida entre puntos en la representación final.
  • Valores pequeños: generan grupos compactos y destacan mejor los clústeres.
  • Valores grandes: distribuyen más los datos y conservan mejor la estructura global. Generalmente oscila entre: 0.0 y 0.5.

Beneficios de UMAP

• Excelente capacidad de visualización.
• Conserva relaciones locales y parte de las globales.
• Escala mejor que t-SNE.
• Menor tiempo de ejecución.
• Admite conjuntos de datos muy grandes.
• Funciona con relaciones no lineales.
• Puede utilizarse como técnica de preprocesamiento.
• Compatible con aprendizaje supervisado y no supervisado.

Por estas razones se ha convertido en una herramienta estándar en numerosos proyectos modernos de Machine Learning.

¿Cuándo utilizar UMAP?

• Se trabaja con datos de alta dimensionalidad.
• Se desea visualizar información compleja.
• Existen relaciones no lineales entre variables.
• Se requiere una alternativa rápida a t-SNE.
• Se necesita preprocesamiento para modelos posteriores.

Casos frecuentes:

• Exploración de datos.
• Análisis de embeddings.
• Segmentación de clientes.
• Bioinformática.
• Visión artificial.
• Procesamiento del lenguaje natural.

Ventajas

• Mayor velocidad que t-SNE.
• Mejor escalabilidad.
• Conservación simultánea de estructuras locales y globales.
• Capacidad para trabajar con millones de observaciones.
• Flexibilidad en la elección de métricas de distancia.
• Excelente calidad visual.
• Posibilidad de reutilizar el modelo para nuevos datos.

Además, UMAP puede utilizarse no solo para visualización sino también como etapa de reducción dimensional antes del entrenamiento de modelos predictivos.

Desventajas

• Sensibilidad a los hiperparámetros.
• Resultados diferentes según la inicialización.
• Interpretación matemática compleja.
• Posibilidad de generar agrupaciones artificiales si los parámetros no se ajustan correctamente.
• Requiere cierto conocimiento para optimizar sus resultados.

Limitaciones de UMAP

Aunque es una técnica muy potente, presenta algunas limitaciones.

• No preserva todas las distancias originales: prioriza relaciones locales y estructura topológica. Por ello, las distancias exactas entre grupos no siempre conservan su significado original.
• Dependencia de los hiperparámetros: Cambios en n_neighbors y min_dist pueden generar representaciones considerablemente distintas.
• Complejidad matemática: La base teórica de UMAP es más sofisticada que la de técnicas clásicas como PCA, lo que dificulta su interpretación profunda.
• Posible pérdida de información: Como cualquier técnica de reducción dimensional parte de la información original se pierde. La representación final es una aproximación.

Diferencias entre PCA, t-SNE y UMAP

En muchos proyectos modernos, UMAP ha reemplazado a t-SNE debido a su mejor equilibrio entre rendimiento y calidad visual.

Aplicaciones en Data Science y Machine Learning

UMAP posee aplicaciones en numerosas disciplinas.

Machine Learning

• Reducción de dimensionalidad.
• Ingeniería de características.
• Preprocesamiento de datos.
• Visualización de modelos.

Deep Learning

• Análisis de embeddings.
• Visualización de representaciones latentes.
• Interpretación de redes neuronales.

Procesamiento del Lenguaje Natural

• Visualización de Word Embeddings.
• Análisis semántico.
• Exploración de documentos.

Bioinformática

• Análisis de secuenciación genética.
• Clasificación celular.
• Estudios de expresión génica.

Visión Artificial

• Agrupación de imágenes.
• Reconocimiento de patrones.
• Exploración de datasets visuales.

Marketing y Negocio

• Segmentación de clientes.
• Detección de anomalías.
• Análisis de comportamiento.

Implementación en Python

UMAP se encuentra disponible mediante la librería umap-learn.

pip install umap-learn

pip install umap-learn

Ejemplo básico con Iris

from sklearn.datasets import load_iris
import umap

iris = load_iris()

X = iris.data
y = iris.target

reducer = umap.UMAP(
    n_neighbors=15,
    min_dist=0.1,
    n_components=2,
    random_state=42
)

X_umap = reducer.fit_transform(X)

print(X.shape)
print(X_umap.shape)

from sklearn.datasets import load_iris
import umap

iris = load_iris()

X = iris.data
y = iris.target

reducer = umap.UMAP(
    n_neighbors=15,
    min_dist=0.1,
    n_components=2,
    random_state=42
)

X_umap = reducer.fit_transform(X)

print(X.shape)
print(X_umap.shape)

(150, 4)
(150, 2)

(150, 4)
(150, 2)

El conjunto de datos se transforma de cuatro variables originales a una representación bidimensional.

Visualización de resultados

import matplotlib.pyplot as plt

plt.figure(figsize=(8,6))

plt.scatter(
    X_umap[:,0],
    X_umap[:,1],
    c=y,
    cmap="viridis"
)

plt.xlabel("UMAP 1")
plt.ylabel("UMAP 2")
plt.title("Visualización mediante UMAP")

plt.show()

import matplotlib.pyplot as plt

plt.figure(figsize=(8,6))

plt.scatter(
    X_umap[:,0],
    X_umap[:,1],
    c=y,
    cmap="viridis"
)

plt.xlabel("UMAP 1")
plt.ylabel("UMAP 2")
plt.title("Visualización mediante UMAP")

plt.show()

La representación suele mostrar una separación clara entre las diferentes especies del conjunto Iris.

Uso como preprocesamiento para Machine Learning

from sklearn.pipeline import Pipeline
from sklearn.ensemble import RandomForestClassifier
import umap

pipeline = Pipeline([
    ("umap", umap.UMAP(
        n_components=20,
        random_state=42
    )),
    ("classifier", RandomForestClassifier())
])

pipeline.fit(X_train, y_train)

predictions = pipeline.predict(X_test)

from sklearn.pipeline import Pipeline
from sklearn.ensemble import RandomForestClassifier
import umap

pipeline = Pipeline([
    ("umap", umap.UMAP(
        n_components=20,
        random_state=42
    )),
    ("classifier", RandomForestClassifier())
])

pipeline.fit(X_train, y_train)

predictions = pipeline.predict(X_test)

Este enfoque permite reducir dimensionalidad antes de entrenar el modelo, disminuyendo la complejidad computacional y potencialmente mejorando el rendimiento.

Conclusión

UMAP es una de las técnicas de reducción de dimensionalidad más avanzadas y utilizadas actualmente en Data Science y Machine Learning. Su capacidad para preservar relaciones locales, mantener parte de la estructura global de los datos y escalar eficientemente a grandes conjuntos de información lo convierten en una alternativa muy atractiva frente a métodos tradicionales como PCA y t-SNE.

Gracias a su versatilidad, rapidez y calidad visual, UMAP se ha consolidado como una herramienta fundamental para la exploración de datos, la visualización de embeddings, la reducción de dimensionalidad y el preprocesamiento de modelos predictivos. Todo profesional que trabaje con datos de alta dimensionalidad debería conocer esta técnica y comprender cuándo aprovechar sus ventajas para obtener representaciones más informativas y útiles de sus datos.

Visualización de Datos de Alta Dimensionalidad

La transformación t-SNE (t-Distributed Stochastic Neighbor Embedding) es una técnica de reducción de dimensionalidad no lineal diseñada principalmente para la visualización de datos complejos en espacios de dos o tres dimensiones. Su capacidad para revelar patrones, agrupaciones y estructuras ocultas la ha convertido en una de las herramientas más populares en Data Science, Machine Learning e Inteligencia Artificial.

A diferencia de técnicas tradicionales como PCA, que buscan conservar la máxima varianza de los datos, t-SNE se enfoca en preservar las relaciones de vecindad entre observaciones. Esto permite representar conjuntos de datos de alta dimensionalidad de forma intuitiva y visualmente interpretable.

La técnica es especialmente útil para explorar datos antes de construir modelos predictivos, ayudando a comprender la estructura interna de la información y detectar agrupaciones naturales.

¿Qué es t-SNE?

t-SNE es un algoritmo de reducción de dimensionalidad desarrollado por Laurens van der Maaten y Geoffrey Hinton en 2008. Su objetivo consiste en transformar datos de muchas dimensiones en un espacio de menor dimensión, generalmente dos o tres dimensiones. Durante esta transformación intenta conservar la proximidad relativa entre observaciones.

En términos sencillos:

• Los puntos cercanos en el espacio original permanecen cercanos en la representación reducida.
• Los puntos alejados tienden a mantenerse separados.

Esto permite visualizar conjuntos de datos complejos que serían imposibles de interpretar directamente.

¿Cómo funciona t-SNE?

El algoritmo transforma las relaciones entre observaciones en probabilidades. Primero calcula la similitud entre puntos en el espacio original. Si dos observaciones son muy parecidas, tendrán una probabilidad alta de ser consideradas vecinas. Esta probabilidad puede representarse mediante una distribución gaussiana:

$$p_{j|i}=\frac{\exp\left(-\frac{||x_i-x_j||^2}{2\sigma_i^2}\right)}{\sum_{k\neq i}\exp\left(-\frac{||x_i-x_k||^2}{2\sigma_i^2}\right)}$$

Posteriormente, t-SNE construye una representación en baja dimensión utilizando una distribución t de Student para medir similitudes:

$$q_{ij}=\frac{(1+||y_i-y_j||^2)^{-1}}{\sum_{k\neq l}(1+||y_k-y_l||^2)^{-1}}$$

Finalmente, el algoritmo intenta minimizar la diferencia entre ambas distribuciones utilizando la divergencia de Kullback-Leibler:

$$KL(P||Q)=\sum_{i}\sum_{j}p_{ij}\log\frac{p_{ij}}{q_{ij}}$$

El resultado es una representación bidimensional o tridimensional que preserva las relaciones locales entre observaciones.

Intuición detrás de t-SNE

La idea principal puede entenderse mediante un ejemplo sencillo. Supongamos un conjunto de imágenes de animales representadas por cientos de características numéricas. En el espacio original:

• Las imágenes de perros estarán cerca unas de otras.
• Las imágenes de gatos formarán otro grupo.
• Las imágenes de aves aparecerán en otra región distinta.

t-SNE intenta mantener esas vecindades cuando reduce las dimensiones. El resultado suele mostrar grupos claramente diferenciados que permiten identificar patrones visualmente.

Ejemplo conceptual

Imaginemos un conjunto de datos de clientes con 100 variables:

• Edad.
• Ingresos.
• Historial de compras.
• Frecuencia de visitas.
• Interacción con campañas.
• Comportamiento digital.

Visualizar directamente estas 100 dimensiones es imposible.

Aplicando t-SNE:

• Los clientes con comportamientos similares aparecerán agrupados.
• Los perfiles diferentes formarán grupos separados.
• Los posibles segmentos de mercado serán más fáciles de identificar.

Parámetros importantes de t-SNE

El comportamiento del algoritmo depende de varios hiperparámetros.

Perplexity

Controla el número efectivo de vecinos considerados.

• Valores comunes: entre 5 y 50, frecuentemente 30 como punto de partida.
• Valores pequeños: Capturan estructuras muy locales.
• Valores grandes: Capturan patrones más globales.

Learning Rate

Determina la velocidad de optimización. Valores habituales:

• Entre 100 y 1000.

Un valor inadecuado puede producir representaciones distorsionadas.

Número de Iteraciones

Controla el proceso de optimización. Generalmente:

• 1000 iteraciones o más.
• Más iteraciones suelen generar resultados más estables.

Beneficios de t-SNE

• Excelente capacidad de visualización.
• Descubre estructuras complejas no lineales.
• Detecta agrupaciones ocultas.
• Facilita el análisis exploratorio.
• Funciona bien con datos de alta dimensionalidad.
• Revela relaciones difíciles de detectar con métodos lineales.
• Produce representaciones visualmente intuitivas.

Por estas razones es una de las herramientas favoritas para análisis exploratorio de datos.

¿Cuándo utilizar t-SNE?

• Se desea visualizar datos de alta dimensionalidad.
• Se busca detectar agrupaciones naturales.
• Se necesita explorar datos antes de modelarlos.
• Se quiere analizar embeddings generados por redes neuronales.
• Se pretende comprender mejor la estructura de un conjunto de datos complejo.

Escenarios comunes:

• Computer Vision.
• Procesamiento del lenguaje natural.
• Bioinformática.
• Sistemas de recomendación.
• Análisis de clientes.
• Detección de anomalías.

Ventajas

• Captura relaciones no lineales.
• Conserva vecindades locales de forma efectiva.
• Produce visualizaciones muy informativas.
• Permite descubrir patrones ocultos.
• Funciona bien con datos complejos.
• Es ampliamente utilizada en investigación y análisis avanzados.

En muchos casos genera representaciones mucho más interpretables que PCA.

Desventajas

• Alto coste computacional.
• Resultados sensibles a los hiperparámetros.
• No es fácilmente interpretable matemáticamente.
• Los resultados pueden variar entre ejecuciones.
• No escala bien a conjuntos extremadamente grandes.

Además, la distancia entre grupos en el gráfico no siempre tiene un significado real en el espacio original.

Limitaciones de t-SNE

Existen varios aspectos que deben considerarse al utilizar esta técnica.

No preserva estructuras globales

t-SNE prioriza relaciones locales.

Como consecuencia:

• Las distancias entre grupos pueden ser engañosas.
• La separación visual no siempre refleja separación real.

Sensibilidad a hiperparámetros

Pequeños cambios en:

• Perplexity.
• Learning rate.
• Número de iteraciones.

Pueden producir visualizaciones muy diferentes.

No es una técnica predictiva

t-SNE está diseñada para:

• Exploración.
• Visualización.

No suele emplearse directamente como entrada para modelos predictivos.

Coste computacional

La complejidad aumenta significativamente conforme crece el número de observaciones. Para millones de registros pueden requerirse alternativas más eficientes.

Aplicaciones en Data Science y Machine Learning

t-SNE tiene una amplia presencia en proyectos analíticos modernos.

Visualización de datasets complejos

• Exploración de datos.
• Identificación de clusters.
• Detección de anomalías.

Computer Vision

• Visualización de embeddings de imágenes.
• Evaluación de modelos de clasificación.
• Análisis de características extraídas por CNN.

Procesamiento del Lenguaje Natural

• Visualización de Word Embeddings.
• Análisis de documentos.
• Exploración semántica.

Bioinformática

• Análisis genómico.
• Clasificación celular.
• Estudios de expresión genética.

Deep Learning

• Inspección de representaciones internas.
• Evaluación de capas ocultas.
• Interpretación de embeddings.

Comparación entre PCA, ICA y t-SNE

En general:

• PCA se utiliza para compresión y reducción rápida.
• ICA para separación de fuentes independientes.
• t-SNE para visualización avanzada.

Implementación en Python

Scikit-Learn proporciona una implementación sencilla mediante la clase TSNE.

Ejemplo con el dataset Iris

from sklearn.datasets import load_iris
from sklearn.manifold import TSNE

iris = load_iris()

X = iris.data
y = iris.target

tsne = TSNE(
    n_components=2,
    perplexity=30,
    random_state=42
)

X_tsne = tsne.fit_transform(X)

print(X.shape)
print(X_tsne.shape)

from sklearn.datasets import load_iris
from sklearn.manifold import TSNE

iris = load_iris()

X = iris.data
y = iris.target

tsne = TSNE(
    n_components=2,
    perplexity=30,
    random_state=42
)

X_tsne = tsne.fit_transform(X)

print(X.shape)
print(X_tsne.shape)

(150, 4)
(150, 2)

(150, 4)
(150, 2)

Los datos originales de cuatro dimensiones se transforman en una representación bidimensional.

Visualización de los resultados

import matplotlib.pyplot as plt

plt.figure(figsize=(8,6))

plt.scatter(
    X_tsne[:,0],
    X_tsne[:,1],
    c=y,
    cmap="viridis"
)

plt.xlabel("t-SNE 1")
plt.ylabel("t-SNE 2")
plt.title("Visualización mediante t-SNE")

plt.show()

import matplotlib.pyplot as plt

plt.figure(figsize=(8,6))

plt.scatter(
    X_tsne[:,0],
    X_tsne[:,1],
    c=y,
    cmap="viridis"
)

plt.xlabel("t-SNE 1")
plt.ylabel("t-SNE 2")
plt.title("Visualización mediante t-SNE")

plt.show()

Ejemplo con Digits Dataset

from sklearn.datasets import load_digits
from sklearn.manifold import TSNE

digits = load_digits()

X = digits.data
y = digits.target

tsne = TSNE(
    n_components=2,
    perplexity=30,
    random_state=42
)

X_tsne = tsne.fit_transform(X)

from sklearn.datasets import load_digits
from sklearn.manifold import TSNE

digits = load_digits()

X = digits.data
y = digits.target

tsne = TSNE(
    n_components=2,
    perplexity=30,
    random_state=42
)

X_tsne = tsne.fit_transform(X)

(1797, 64)
(1797, 2)

(1797, 64)
(1797, 2)

import matplotlib.pyplot as plt

plt.figure(figsize=(8,6))

plt.scatter(
    X_tsne[:,0],
    X_tsne[:,1],
    c=y,
    cmap="viridis"
)

plt.xlabel("t-SNE 1")
plt.ylabel("t-SNE 2")
plt.title("Visualización mediante t-SNE")

plt.show()

import matplotlib.pyplot as plt

plt.figure(figsize=(8,6))

plt.scatter(
    X_tsne[:,0],
    X_tsne[:,1],
    c=y,
    cmap="viridis"
)

plt.xlabel("t-SNE 1")
plt.ylabel("t-SNE 2")
plt.title("Visualización mediante t-SNE")

plt.show()

Conclusión

t-SNE es una de las técnicas más potentes para visualizar datos de alta dimensionalidad. Su capacidad para preservar relaciones locales y descubrir estructuras no lineales la convierte en una herramienta fundamental para el análisis exploratorio de datos, la interpretación de modelos y la investigación en Machine Learning.

Aunque no está diseñada para sustituir métodos de reducción dimensional tradicionales ni para servir como técnica predictiva, su utilidad para comprender la estructura interna de conjuntos de datos complejos es extraordinaria. Utilizada correctamente, t-SNE permite transformar grandes volúmenes de información multidimensional en representaciones visuales intuitivas que facilitan la identificación de patrones, agrupaciones y anomalías ocultas.