Categoría: Preparación de Datos

En el diseño de arquitecturas de Machine Learning, la calidad de las predicciones de un modelo no depende únicamente de la complejidad del algoritmo matemático seleccionado, sino de la forma geométrica de los datos que le suministramos.

Muchos algoritmos fundamentales (como la Regresión Lineal, la Regresión Logística o las Redes Neuronales) asumen de manera implícita que las variables numéricas de entrada siguen una Distribución Normal (o Gaussiana). Sin embargo, en el mundo real, los datos de negocio suelen ser imperfectos y presentan sesgo o asimetría (skewness), acumulando la mayoría de sus registros en un extremo y extendiendo una larga cola en el sentido opuesto.

En este artículo analítico, abordaremos en exclusiva las técnicas de ingeniería de características cuyo objetivo principal es reducir la asimetría de una distribución para aproximarla a una campana de Gauss.

¿Qué son los datos sesgados?

Cuando un dataset presenta asimetría, la media, la mediana y la moda se separan, provocando que los modelos estadísticos tengan dificultades para aprender los patrones de forma equitativa. El escenario más común en analítica de negocio es la asimetría positiva (o sesgo a la derecha), donde la distribución presenta una cola alargada hacia los valores extremadamente altos. En una distribución normal, la media, la mediana y la moda coinciden, y la curva tiene forma de campana. Matemáticamente, se puede representar como:

$$f(x) = \frac{1}{\sigma\sqrt{2\pi}} e^{-\frac{(x – \mu)^2}{2\sigma^2}}$$

donde:

• \( \mu \) es la media
• \( \sigma \) la desviación estándar.

Sin embargo, muchos conjuntos de datos reales, como ingresos, precios o número de visitas, presentan sesgo (skewness): una asimetría en la distribución.

• Si la cola se extiende hacia la derecha, decimos que está sesgada positivamente.
• Si se extiende hacia la izquierda, está sesgada negativamente.

Por ejemplo, los ingresos de una población suelen estar sesgados a la derecha, porque hay muchas personas con ingresos bajos y pocas con ingresos muy altos.

Reducir el sesgo mejora:

• La precisión del modelo.
• La interpretabilidad de los resultados.
• La estabilidad numérica en el entrenamiento.

Principales técnicas de transformación de datos

A continuación, analizaremos las funciones matemáticas aplicadas en Data Science para comprimir las colas de las distribuciones y redistribuir los datos de forma simétrica.

Transformación Logarítmica

Es la técnica más extendida y utilizada en la industria. Consiste en aplicar el logaritmo natural a la variable predictora.

$$y = \log(x)$$

• Indicada para: Casos de asimetría positiva fuerte y distribuciones con colas extremadamente largas hacia la derecha.
• Casos de uso típicos: Variables socioeconómicas o de comportamiento digital como ingresos, ventas acumuladas o tráfico web, donde unos pocos usuarios o registros presentan valores astronómicos en comparación con la media.
• Limitación: Matemáticamente no está definida para valores menores o iguales a cero. Si existen ceros, suele aplicarse \(\log(x + 1)\) como variante técnica.

Transformación de Raíz Cuadrada

Una alternativa de compresión geométrica moderada.

$$y = \sqrt{x}$$

• Indicada para: Escenarios donde la asimetría positiva es moderada. Al ser menos agresiva que la función logarítmica, no deforma de manera tan drástica las distancias relativas.
• Ventaja: Acepta directamente el valor cero en el dominio de la variable, haciéndola ideal para conteos.

Transformación de Raíz Cúbica

Una herramienta matemática versátil para la manipulación de espectros numéricos amplios.

$$y = \sqrt[3]{x}$$

• Indicada para: Distribuciones que contienen valores positivos, negativos y ceros simultáneamente, siempre que la asimetría no sea extrema. Al conservar el signo del input original, se permite estabilizar la varianza sin perder la naturaleza bidireccional del dato.

Transformación Recíproca

Una de las funciones de transmutación más agresivas en el arsenal estadístico.

$$y = \frac{1}{x}$$

• Indicada para: Distribuciones con una asimetría extremadamente severa y presencia de outliers de gran magnitud. Esta operación invierte el orden de magnitud, transformando los valores extremadamente grandes en valores cercanos a cero, logrando una compresión radical de la cola derecha.

Transformaciones Avanzadas y Automatizadas

En lugar de probar manualmente qué función matemática se adapta mejor a cada columna del dataset, la ciencia de datos moderna utiliza optimizadores algorítmicos que buscan el parámetro de transformación idóneo de manera automatizada.

Transformación Box-Cox

Es un método estadístico avanzado que parametriza la transformación mediante un valor de potencia llamado Lambda (\(\lambda\)). El algoritmo busca el \(\lambda\) óptimo que minimiza la asimetría de la variable resultante.

$$y = \begin{cases} \frac{x^\lambda – 1}{\lambda} & \text{si } \lambda \neq 0 \\ \log(x) & \text{si } \lambda = 0 \end{cases}$$

• Gran Limitación: Funciona única y exclusivamente con valores estrictamente positivos. Si la columna contiene un solo cero o un número negativo, el sistema fallará.

Transformación Yeo-Johnson

Considerada la evolución moderna del método Box-Cox. Modifica las ecuaciones para estabilizar las varianzas permitiendo que la potencia \(\lambda\) se calcule de forma segura sobre cualquier naturaleza numérica.

• Ventajas de Producción: Es compatible con valores negativos y ceros. Debido a esta flexibilidad analítica, es una de las técnicas automatizadas más integradas en los pipelines de Machine Learning industriales (como los transformadores nativos de Scikit-Learn).

Comparación de Transformaciones para Datos Sesgados

Buenas prácticas

1. Visualiza siempre tus datos antes y después de transformar.
2. Mide la asimetría \( (\text{skewness})\) antes y después.
3. No transformes por costumbre: hazlo solo si hay una razón estadística o del modelo.
4. Guarda los parámetros de transformación si vas a aplicarlos en datos futuros (por ejemplo, en deploy de modelos).
5. Considera también el escalado posterior (normalización o estandarización).

Uno de los problemas más comunes en cualquier análisis de datos es la presencia de valores faltantes. No importa si trabajas con datos de clientes, de sensores, o de ventas: los huecos están ahí, casi siempre. Y si no los manejas bien, cualquier análisis que hagas puede llevarte a conclusiones incorrectas o sesgadas.

Pero no te preocupes. Hay estrategias simples y efectivas para detectar, entender y manejar los datos faltantes de manera profesional. En este artículo aprenderás cómo hacerlo paso a paso.

¿Qué son los datos faltantes?

Decimos que hay datos faltantes cuando una variable no tiene valor para una observación determinada. En la práctica, suelen aparecer como NULL, NaN, #N/A o simplemente celdas vacías.

Por ejemplo, imagina que trabajas con los datos de ventas de varias tiendas de ropa y te encuentras con esto:

Aquí, las tiendas del grupo C no informaron el color del producto. Si no corriges este problema, cualquier análisis sobre los colores más vendidos será inexacto.

Por qué es importante gestionar los datos faltantes

Tener valores ausentes no solo significa un dataset incompleto. También puede distorsionar tus conclusiones. Por ejemplo, si intentas calcular la media de precios o la correlación entre variables sin tratarlos, obtendrás resultados falsos o sin sentido.

Desde el punto de vista estadístico, manejar los datos faltantes aumenta el poder estadístico (la capacidad de detectar patrones reales en los datos) y reduce el riesgo de errores de interpretación.

En resumen:

• Mejora la precisión del análisis.
• Evita conclusiones engañosas.
• Permite conservar el tamaño de la muestra y su representatividad.

Por qué faltan los datos

Existen varias causas típicas:

1. Errores o causas sistemáticas: El dato nunca se registró. Puede deberse a un descuido humano o a un fallo técnico.
2. Privacidad o consentimiento: A veces los usuarios optan por no proporcionar ciertos datos, como su correo electrónico o edad.
3. Pérdida o corrupción de información: Errores de conexión, fallos en la base de datos o interrupciones durante la carga de información pueden causar huecos.

Tipos de datos faltantes

No todos los datos faltantes son iguales. En ciencia de datos se clasifican en cuatro tipos:

1. Estructuralmente faltantes (Expected Missing): Es normal que falten: por ejemplo, si alguien responde “no tengo asma”, es lógico que los campos sobre inhaladores estén vacíos.
2. MCAR (Missing Completely at Random): Faltan al azar, sin ningún patrón. Es el caso ideal, aunque poco frecuente.
3. MAR (Missing at Random): Faltan por alguna razón, pero dentro de ciertos grupos.
   Ejemplo: personas con un IMC alto tienden a no reportar su peso.
4. MNAR (Missing Not at Random): Faltan por una razón directamente relacionada con el valor faltante. Por ejemplo, si los pacientes con presión arterial muy alta evitan hacerse la medición.

Cómo identificar los datos faltantes

1. Explora pequeñas muestras de datos:
   Visualiza las primeras o últimas filas para ver si hay celdas vacías.
2. Usa funciones de resumen:
   En Python, data.isnull().sum() te mostrará cuántos valores faltan por columna.
3. Compara recuentos:
   Si una columna tiene menos registros válidos que otras, probablemente tenga valores ausentes.

Estrategias para manejar los datos faltantes

1. Eliminación (borrar los datos faltantes)

A veces la mejor solución es simplemente eliminar filas o columnas con datos faltantes.
Pero cuidado: no siempre es seguro.

Cuándo eliminar

• Cuando los datos faltantes son pocos (menos del 5% del total).
• Cuando los valores faltan al azar (MCAR o MAR).
• Cuando los datos faltantes no afectan directamente al análisis principal.

Cuándo no eliminar

• Si perderías demasiadas observaciones (más del 20%).
• Si los datos faltan por una razón estructural o sistemática.

Tipos de eliminación

Eliminación por lista:
Borra toda la fila con cualquier dato faltante.

data.dropna(inplace=True)

data.dropna(inplace=True)

Eliminación por pares:
Solo elimina las filas que afecten a las variables que estás analizando.

data.dropna(subset=['Height', 'Education'], inplace=True)

data.dropna(subset=['Height', 'Education'], inplace=True)

Eliminación de variables:
Si a una columna le falta más del 60% de los datos, puede ser mejor eliminarla por completo.

2. Imputación (rellenar los huecos)

Cuando los datos son valiosos y no conviene eliminarlos, podemos reemplazar los valores faltantes por otros estimados.

Algunas estrategias:

Media, mediana o moda

Reemplaza los valores faltantes por el promedio, la mediana o el valor más común.

data['Age'].fillna(data['Age'].mean(), inplace=True)

data['Age'].fillna(data['Age'].mean(), inplace=True)

Forward Fill (LOCF)

Usa el valor anterior para completar el actual (útil en series temporales).

data['Value'].ffill(inplace=True)

data['Value'].ffill(inplace=True)

Interpolación

Calcula un valor intermedio entre los datos vecinos:

data['Temperature'].interpolate(inplace=True)

data['Temperature'].interpolate(inplace=True)

Modelos predictivos

Utiliza algoritmos de Machine Learning (como regresión lineal o KNN) para estimar los valores faltantes en base a otras variables.

Caso especial: datos faltantes en series temporales

Cuando los datos se registran en el tiempo (como precios bursátiles o sensores IoT), los huecos pueden rellenarse con métodos temporales, como:

• LOCF (Last Observation Carried Forward)
• Interpolación lineal
• Suavizado exponencial

Por ejemplo:

Podemos reemplazar el valor faltante (08:03) con el anterior (13) o con un promedio (14.5).

Recomendaciones finales

1. Entiende el contexto de tus datos.
   No todos los huecos significan error.
2. Documenta tus decisiones.
   Explica por qué imputaste, eliminaste o dejaste un valor vacío.
3. Evalúa el impacto.
   Comprueba cómo cambian tus resultados antes y después del tratamiento.

En resumen

Manejar los datos faltantes no se trata solo de “rellenar huecos”, sino de preservar la integridad del análisis. Un buen tratamiento puede marcar la diferencia entre un modelo fiable y uno que toma decisiones erróneas. En análisis de datos, la ausencia también habla: cada valor faltante tiene una historia detrás, y entenderla es parte del trabajo de un buen analista.

Uno de los pasos fundamentales del Análisis Exploratorio de Datos (EDA) es el Data Wrangling. La transformación de datos es un conjunto de técnicas utilizadas para convertir datos de un formato o estructura a otro, con el fin de hacerlos más útiles, consistentes y listos para el análisis.

En el proceso de preparación de datos, ciertas tareas suelen realizarse en un orden específico para maximizar la eficiencia y efectividad del flujo de trabajo. Un flujo de trabajo típico de limpieza y preparación de datos seria:

1. Key restructuring (reestructuración de claves)
2. Data validation (validación de datos)
3. Data cleaning (limpieza de datos)
4. Data deduplication (deduplicación de datos)
5. Data derivation (derivación de datos)
6. Format revisioning (revisión de formato)
7. Data aggregation (agregación de datos)
8. Data filtering (filtrado de datos)
9. Data joining (unión de datos)
10. Data integration (integración de datos)

Este flujo de trabajo es iterativo y puede requerir ajustes según las necesidades específicas del proyecto y la naturaleza de los datos. Además, algunos pasos pueden superponerse o requerir revisiones cuando surgen nuevos datos o cambios en los requisitos del análisis.

La razón principal para transformar los datos es obtener una representación más útil y compatible con otros conjuntos de datos. Además, la transformación adecuada favorece la interoperabilidad dentro de un sistema al seguir una estructura y formato común.

Key Restructuring

En el ámbito de la ciencia de datos, “Key Restructuring” se refiere a la reorganización o transformación de las claves en un conjunto de datos.
Las “claves” suelen ser identificadores únicos o combinaciones de campos que sirven para relacionar registros entre sí.

Renombrar Claves

df.rename(columns={'old_name': 'new_name'}, inplace=True)

df.rename(columns={'old_name': 'new_name'}, inplace=True)

Reasignar Valores de Clave

df['key_column'] = df['key_column'].map(lambda x: 'new_value' if condition else x)

df['key_column'] = df['key_column'].map(lambda x: 'new_value' if condition else x)

Crear Claves Compuestas

df['composite_key'] = df['key_part1'].astype(str) + '-' + df['key_part2'].astype(str)

df['composite_key'] = df['key_part1'].astype(str) + '-' + df['key_part2'].astype(str)

Eliminar Claves Innecesarias

df.drop(columns=['unnecessary_key'], inplace=True)

df.drop(columns=['unnecessary_key'], inplace=True)

Asegurar la Unicidad

if df['key_column'].is_unique:
    print("Las claves son únicas.")
else:
    df.drop_duplicates(subset=['key_column'], inplace=True)

if df['key_column'].is_unique:
    print("Las claves son únicas.")
else:
    df.drop_duplicates(subset=['key_column'], inplace=True)

Reindexación Basada en Claves

df.set_index('key_column', inplace=True)

df.set_index('key_column', inplace=True)

Data Validation

La validación de datos consiste en verificar si los datos cumplen con un conjunto de reglas o normas antes de ser procesados o analizados. Es una etapa crítica, ya que trabajar con datos erróneos o mal formateados puede llevar a conclusiones incorrectas y resultados poco confiables.

Técnicas comunes en Pandas

• Verificación de tipos de datos

df.dtypes
df['column'] = df['column'].astype(float)

df.dtypes
df['column'] = df['column'].astype(float)

• Aplicar condiciones de validación

assert (df['column'] > 0).all()

assert (df['column'] > 0).all()

• Validación de texto con expresiones regulares

df['text_column'].str.match(r'^\w+$')

df['text_column'].str.match(r'^\w+$')

• Detección de valores nulos

df.isnull().sum()
df.dropna(subset=['column'], inplace=True)

df.isnull().sum()
df.dropna(subset=['column'], inplace=True)

• Valores únicos y duplicados

df['column'].is_unique
df.drop_duplicates(subset=['column'], inplace=True)

df['column'].is_unique
df.drop_duplicates(subset=['column'], inplace=True)

• Rangos de valores

df[(df['column'] >= min_value) & (df['column'] <= max_value)]

df[(df['column'] >= min_value) & (df['column'] <= max_value)]

• Validación de categorías

allowed = {'cat1', 'cat2'}
df['col'].isin(allowed)

allowed = {'cat1', 'cat2'}
df['col'].isin(allowed)

• Validación cruzada entre columnas

df.apply(lambda row: row['col1'] < row['col2'], axis=1)

df.apply(lambda row: row['col1'] < row['col2'], axis=1)

La validación debe ser continua, adaptándose a las reglas del negocio y al tipo de análisis o modelo que se esté desarrollando.

Data Cleaning

La limpieza de datos busca detectar y corregir (o eliminar) registros corruptos, incompletos o inconsistentes, tratando valores faltantes y estandarizando formatos.

Tareas comunes:

• Detectar valores faltantes

df.isnull()

df.isnull()

• Eliminar valores faltantes

df.dropna()

df.dropna()

• Rellenar valores faltantes

df.fillna(method='ffill')

df.fillna(method='ffill')

• Conversión de tipos

df.astype({'col1': 'int32'})

df.astype({'col1': 'int32'})

• Normalización de texto

df['col'] = df['col'].str.strip().str.lower()

df['col'] = df['col'].str.strip().str.lower()

• Manejo de outliers
  Filtrar o imputar valores extremos según percentiles o desviaciones estándar.
• Manejo de fechas

df['fecha'] = pd.to_datetime(df['fecha'], errors='coerce')

df['fecha'] = pd.to_datetime(df['fecha'], errors='coerce')

• Guardar los datos limpios

df.to_csv('clean_data.csv', index=False)

df.to_csv('clean_data.csv', index=False)

Una limpieza adecuada es la base para cualquier análisis o modelado confiable.

Data Deduplication

La deduplicación de datos busca identificar y eliminar registros repetidos dentro de un conjunto de datos. Esto mejora la precisión y evita sesgos en el análisis.

Métodos en Pandas:

df.drop_duplicates()
df.duplicated()

df.drop_duplicates()
df.duplicated()

Se puede usar el argumento subset para definir columnas específicas y keep para decidir qué duplicado conservar. Antes de eliminar duplicados, conviene analizar su origen y asegurarse de no eliminar información valiosa.

Data Derivation

La derivación de datos consiste en crear nuevas variables o columnas a partir de datos existentes.

Ejemplos comunes:

• Cálculo de estadísticas

df['avg'] = df['value'].mean()

df['avg'] = df['value'].mean()

• Transformaciones matemáticas

df['normalized'] = (df['x'] - df['x'].mean()) / df['x'].std()

df['normalized'] = (df['x'] - df['x'].mean()) / df['x'].std()

• Descomposición de fechas

df['year'] = df['date'].dt.year

df['year'] = df['date'].dt.year

• One-hot encoding

pd.get_dummies(df['category'])

pd.get_dummies(df['category'])

• Binning

pd.cut(df['var'], bins=3)

pd.cut(df['var'], bins=3)

• Cálculo de diferencias

df['diff'] = df['value'].diff()

df['diff'] = df['value'].diff()

Derivar datos correctamente permite enriquecer el conjunto de análisis y mejorar el rendimiento de los modelos.

Format Revisioning

La revisión de formato implica convertir datos a tipos o estructuras adecuados para el análisis o interoperabilidad.

• Conversión de tipos

df['col'] = pd.to_numeric(df['col'], errors='coerce')

df['col'] = pd.to_numeric(df['col'], errors='coerce')

• Normalización de texto

df['texto'] = df['texto'].str.lower().str.strip()

df['texto'] = df['texto'].str.lower().str.strip()

• Fechas y horas

df['fecha'] = pd.to_datetime(df['fecha'])

df['fecha'] = pd.to_datetime(df['fecha'])

• Conversión a categorías

df['cat'] = df['cat'].astype('category')

df['cat'] = df['cat'].astype('category')

• Exportar a otros formatos

df.to_excel('datos.xlsx', index=False)
df.to_sql('tabla', con=conexion)

df.to_excel('datos.xlsx', index=False)
df.to_sql('tabla', con=conexion)

Data Aggregation

La agregación de datos permite resumir información, extraer métricas y generar resúmenes útiles.

Ejemplos:

df.groupby('col')['ventas'].sum()
df.groupby('col').agg({'ventas': ['mean', 'std']})
df.pivot_table(values='ventas', index='mes', columns='region')
pd.crosstab(df['categoria'], df['region'])
df['ventas'].rolling(window=3).mean()
df.resample('M')['ventas'].sum()

df.groupby('col')['ventas'].sum()
df.groupby('col').agg({'ventas': ['mean', 'std']})
df.pivot_table(values='ventas', index='mes', columns='region')
pd.crosstab(df['categoria'], df['region'])
df['ventas'].rolling(window=3).mean()
df.resample('M')['ventas'].sum()

La agregación facilita el análisis exploratorio y la generación de indicadores clave (KPIs).

Data Filtering

El filtrado de datos consiste en seleccionar subconjuntos relevantes según condiciones o criterios específicos.

Ejemplos:

df[df['edad'] > 30]
df.query('columna > 100')
df[df['pais'].isin(['España', 'Chile'])]
df[(df['ventas'] > 500) & (df['region'] == 'Norte')]

df[df['edad'] > 30]
df.query('columna > 100')
df[df['pais'].isin(['España', 'Chile'])]
df[(df['ventas'] > 500) & (df['region'] == 'Norte')]

También puedes aplicar funciones personalizadas:

df[df['nombre'].apply(lambda x: 'a' in x)]

df[df['nombre'].apply(lambda x: 'a' in x)]

El filtrado ayuda a centrarse en los datos más relevantes y reduce ruido analítico.

Top – Data Joining

El data joining combina conjuntos de datos mediante claves comunes, similar a las uniones de SQL.

Métodos:

• pd.concat() – concatenar DataFrames (vertical u horizontalmente)
• pd.merge() – unión tipo SQL (inner, left, right, outer)
• df.join() – unión por índice o columna
• merge_asof() y merge_ordered() – uniones temporales o ordenadas
• compare() – detectar diferencias entre DataFrames

Ejemplos:

pd.concat([df1, df2], axis=0)
pd.merge(df1, df2, on='id', how='left')

pd.concat([df1, df2], axis=0)
pd.merge(df1, df2, on='id', how='left')

La unión de datos es esencial para integrar fuentes diversas y construir un dataset analítico coherente.