Categoría: Transformación de Datos

Transformación de Datos

  • Transformaciones de Datos Avanzadas: cómo tratar datos sesgados

    En el análisis y la ciencia de datos, entender la forma de la distribución de los datos es tan importante como los valores en sí. Muchos modelos estadísticos y de machine learning funcionan mejor —o incluso lo asumen— cuando los datos siguen una distribución normal (gaussiana).

    Sin embargo, los datos reales rara vez son perfectos: suelen estar sesgados, contener valores atípicos o tener una dispersión desigual. En este artículo aprenderás:

    • Qué significa que los datos estén sesgados.
    • Qué es la transformación logarítmica y por qué es útil.
    • Cómo implementarla en Python.
    • Qué otras transformaciones avanzadas pueden aplicarse según la situación.

    ¿Qué son los datos sesgados?

    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.

    ¿Por qué importa el sesgo?

    El sesgo afecta al análisis porque muchos métodos estadísticos y modelos predictivos suponen que los datos son normales.
    Por ejemplo:

    • En regresión lineal, el error residual se asume normal.
    • En modelos de clasificación, los algoritmos que usan distancias (como k-NN) pueden verse afectados si las variables no están en escalas comparables o están muy sesgadas.

    Reducir el sesgo mejora:

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

    Transformación Logarítmica

    La transformación logarítmica es una de las herramientas más utilizadas para corregir el sesgo positivo. Consiste en reemplazar cada valor \(x\) por su logaritmo:

    $$x’ = \log(x)$$

    ¿Qué hace exactamente?

    • Comprime los valores grandes, reduciendo el impacto de los outliers.
    • Expande los valores pequeños, acercando la distribución a una forma más simétrica.

    Importante: solo puede aplicarse a valores positivos. Si existen ceros o negativos, hay que desplazarlos previamente (por ejemplo, usando (\log(x + 1))).

    Ejemplo en Python

    Veamos cómo aplicar esta técnica a un conjunto de datos de precios de viviendas.

    import numpy as np
    import pandas as pd
    import seaborn as sns
    import matplotlib.pyplot as plt
    
    # Cargar datos de ejemplo (Kaggle o dataset propio)
    home_data = pd.read_csv('home_data.csv')
    home_prices = home_data['SalePrice']
    
    # Visualizar la distribución original
    sns.histplot(home_prices, kde=True, color="skyblue")
    plt.title("Distribución original de precios de viviendas")
    plt.show()
    
    # Medir asimetría
    print("Asimetría original:", home_prices.skew())
    
    # Aplicar transformación logarítmica
    log_home_prices = np.log(home_prices)
    
    # Visualizar la distribución transformada
    sns.histplot(log_home_prices, kde=True, color="lightgreen")
    plt.title("Distribución tras transformación logarítmica")
    plt.show()
    
    # Medir asimetría posterior
    print("Asimetría después de log-transform:", log_home_prices.skew())

    🔹 Salida esperada:

    Asimetría original: 1.88
    Asimetría después de log-transform: 0.12

    El cambio es notable: los datos ahora están mucho más cerca de una distribución normal.

    Transformación con Scikit-Learn

    Otra forma más flexible es usar la clase PowerTransformer de scikit-learn, que aplica una transformación de potencia (Box-Cox o Yeo-Johnson). Esta última admite valores negativos, lo que la hace ideal en contextos más generales.

    from sklearn.preprocessing import PowerTransformer
    import numpy as np
    
    data = np.array([[1.0], [2.0], [3.0], [10.0], [50.0]])
    
    pt = PowerTransformer(method='yeo-johnson')
    transformed = pt.fit_transform(data)
    
    print("Datos transformados:\n", transformed[:5])
    

    Otras transformaciones avanzadas

    Dependiendo del tipo y del sesgo de los datos, se pueden usar diferentes transformaciones:

    Tipo de SesgoTransformación recomendadaFórmulaNotas
    Sesgo positivo (cola a la derecha)Logarítmica\( x’ = \log(x) \) Solo ( x > 0 )
    Sesgo positivo (con ceros o negativos)Yeo-JohnsonAdmite todo el rango de valores
    Sesgo positivo leveRaíz cuadrada\(x’ = \sqrt{x}\)Suaviza sin comprimir demasiado
    Sesgo negativo (cola a la izquierda)Cuadrática\(x’ = x^2\)Amplifica valores grandes
    Valores con ceros y negativosRaíz cúbica\(x’ = x^{1/3} \)Funciona con ( x < 0 )

    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).
  • Discretizar Datos Numéricos y Contraer Categorías

    En ciencia de datos, no siempre trabajamos con variables limpias o perfectamente preparadas. A menudo necesitamos transformarlas para extraer patrones, visualizar mejor o alimentar modelos de aprendizaje automático. En este artículo aprenderás dos técnicas fundamentales dentro del preprocesamiento y transformación de datos:

    • Agrupar (discretizar) datos numéricos en categorías o intervalos.
    • Combinar (contraer) categorías en variables categóricas.

    Estas operaciones son herramientas simples pero poderosas que te ayudarán a simplificar, resumir y mejorar tus análisis y visualizaciones.

    ¿Qué es la Agrupación (Binning) de Datos Numéricos?

    La agrupación o discretización consiste en transformar una variable numérica continua (por ejemplo, la edad) en categorías o intervalos. Por ejemplo, en lugar de analizar cada edad individualmente (22, 23, 24…), podríamos clasificar a las personas en grupos como:

    • 20–29 años → Jóvenes adultos
    • 30–39 años → Adultos
    • 40–49 años → Edad media

    Esta técnica se conoce como binning (de “bins”, que significa “contenedores”).
    Es muy común en análisis exploratorio, estadística descriptiva y visualización.

    ¿Por qué agrupar datos?

    Existen varias razones por las que discretizar variables puede ser útil:

    1. Simplifica los datos → Menos categorías, más fácil de interpretar.
    2. Facilita visualizaciones → Histogramas y gráficos de barras más claros.
    3. Reduce el ruido → Los pequeños cambios dejan de ser relevantes.
    4. Mejora algunos modelos → Ciertos algoritmos funcionan mejor con categorías discretas (como árboles de decisión).

    En entornos como finanzas o marketing, agrupar variables continuas es habitual:

    • Rangos de ingresos (bajo, medio, alto).
    • Rangos de edad (jóvenes, adultos, mayores).
    • Niveles de gasto o frecuencia de compra.

    Ejemplo: Agrupación de edades

    Supongamos que tenemos los datos de los alumnos de una clase de baile:

    import pandas as pd
    
    dance_class = pd.read_csv('dance_class_data.csv')
    print(dance_class.head(5))

    Salida:

              Name Gender  Age    Experience
    0   Chris Shelton      M   23      beginner
    1  Douglas Watson      M   28  intermediate
    2    Martha Gomez      F   45      beginner
    3      Amos Moore      M   63      beginner
    4   Valentina Sen      F   35      beginner

    Queremos agrupar las edades en rangos de 10 años (20–29, 30–39, 40–49…).

    Crear contenedores con pandas.cut()

    bins = [20, 30, 40, 50, 60, 70]
    labels = ['20s', '30s', '40s', '50s', '60s']
    
    dance_class['AgeGroup'] = pd.cut(dance_class['Age'], bins=bins, labels=labels)
    
    print(dance_class[['Age', 'AgeGroup']].head())

    Salida:

       Age AgeGroup
    0   23      20s
    1   28      20s
    2   45      40s
    3   63      60s
    4   35      30s

    Otras funciones útiles

    • pd.qcut() → Agrupa en cuantiles (por ejemplo, cuartiles o deciles), ideal cuando los datos no están uniformemente distribuidos.
    • np.histogram_bin_edges() → Permite definir automáticamente los límites de los bins según los datos.

    Combinar (Contraer) variables categóricas

    No todas las variables son numéricas. En los conjuntos de datos reales, muchas veces encontramos variables categóricas, como el país, la profesión, el color o el tipo de producto.
    A veces, estas categorías son demasiado numerosas o desbalanceadas, lo que dificulta el análisis.

    Ejemplo práctico

    Supón que tienes este conjunto de datos con los deportes más populares:

    SportCount
    Basketball500
    Football400
    Baseball8
    Tennis7
    Cricket4
    Sailing3

    Claramente, los dos primeros deportes dominan la muestra.
    Podríamos combinar todas las demás categorías menores en una sola llamada “Others”.


    En Python:

    import pandas as pd
    
    sports = pd.DataFrame({
        'Sport': ['Basketball', 'Football', 'Baseball', 'Tennis', 'Cricket', 'Sailing'],
        'Count': [500, 400, 8, 7, 4, 3]
    })
    
    # Definir umbral mínimo
    threshold = 50
    sports['Sport_Grouped'] = sports['Sport'].where(sports['Count'] >= threshold, 'Other')
    
    print(sports)
    

    Salida:

           Sport  Count  Sport_Grouped
    0  Basketball    500    Basketball
    1    Football    400      Football
    2    Baseball      8         Other
    3      Tennis      7         Other
    4     Cricket      4         Other
    5     Sailing      3         Other

    De esta forma, las categorías menores se combinan en una sola, lo que simplifica el análisis y mejora la visualización.

    ¿Por qué contraer categorías?

    • Reduce el ruido visual.
    • Simplifica modelos de ML, ya que menos categorías implican menos variables dummy tras el one-hot encoding.
    • Evita el sesgo de categorías minoritarias.

    En resumen

    TécnicaQué haceCuándo usarlaEjemplo
    Discretización (Binning)Convierte variables continuas en intervalosCuando quieres resumir o suavizar datosEdad → grupos de edad
    Contracción de categoríasCombina etiquetas poco frecuentes en una solaCuando hay categorías desbalanceadasDeportes minoritarios → “Otros”

    Ambas técnicas pertenecen al proceso de transformación y limpieza de datos, una etapa crucial del preprocesamiento en ciencia de datos antes de modelar o visualizar.

  • Centrado y Escalado de Datos

    Como científico de datos, uno de los pasos más importantes antes de visualizar, analizar o modelar información es transformar adecuadamente los datos. En particular, centrar y escalar son operaciones esenciales del preprocesamiento que garantizan que todas las variables contribuyan de manera equilibrada a los modelos estadísticos o de aprendizaje automático.

    En este artículo aprenderás:

    • Qué significa centrar datos e interpretar datos centrados.
    • Por qué es importante escalar tus datos.
    • Cómo escalar datos utilizando normalización min–máx y estandarización.
    • Cuándo elegir entre ambos métodos.

    Centrado de Datos

    El centrado de los datos consiste en restar la media de un conjunto de valores a cada punto del mismo, de manera que la nueva media sea cero.

    $$X^{(centrado)}_i = X_i – \mu$$

    donde:

    • \( X_i \) es un valor individual,
    • \( \mu \) es la media del conjunto \( X \).

    Ejemplo:

    Supón que tenemos un conjunto de edades:

    ages = [24, 40, 28, 22, 56]

    La media es:

    $$\mu = \frac{24 + 40 + 28 + 22 + 56}{5} = 34$$

    Al centrar los datos:

    $$X^{(centrado)} = [-10, 6, -6, -12, 22]$$

    La suma de estos valores es cero, lo que implica que su media también es cero.
    Interpretativamente, cada valor indica cuánto se desvía respecto a la media: la primera persona tiene 10 años menos que el promedio, la última 22 años más.

    Escalado de Datos

    Aunque el centrado corrige el desplazamiento, no resuelve las diferencias de escala entre variables. Por ejemplo, en un conjunto de datos con las variables edad (0–100) e ingresos (0–100,000), el modelo podría interpretar que los ingresos son “más importantes” solo por tener valores mayores.

    Los algoritmos de machine learning —como regresión lineal, SVM, k-means o PCAasumen que todas las variables tienen una escala comparable. Por ello, es fundamental escalar los datos, es decir, ajustar su rango o su dispersión.

    Normalización Min–Máx

    La normalización min–máx reescala los valores para que todos estén dentro del rango ([0, 1]):

    $$X’ = \frac{X – X_{\min}}{X_{\max} – X_{\min}}$$

    donde:

    • \(X_{\min}\) y \( X_{\max}\) son el valor mínimo y máximo de la variable.

    Ejemplo:

    Si \( X_{\min} = 10 ), ( X_{\max} = 30 ), ( X = 20 )\):

    $$X’ = \frac{20 – 10}{30 – 10} = 0.5$$

    En Python

    def min_max_normalize(lst):
        minimum = min(lst)
        maximum = max(lst)
        return [(x - minimum) / (maximum - minimum) for x in lst]
    
    data = [1, 2, 3, 4, 5]
    normalized_data = min_max_normalize(data)
    print(normalized_data)

    O con scikit-learn:

    from sklearn.preprocessing import MinMaxScaler
    
    data = [[1], [2], [3], [4], [5]]
    scaler = MinMaxScaler()
    normalized = scaler.fit_transform(data)
    print(normalized)

    Desventaja

    La normalización min–máx no maneja bien los valores atípicos. Si un único dato es muy grande, comprime el rango del resto. En ese caso, la estandarización es una mejor opción.

    Estandarización (Z-score)

    La estandarización transforma los datos restando la media y dividiendo por la desviación estándar:

    $$Z = \frac{X – \mu}{\sigma}$$

    donde:

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

    De este modo, la variable resultante tiene:

    • Media = 0
    • Desviación estándar = 1

    A diferencia de la normalización, no limita los valores a un rango fijo, por lo que no se ve tan afectada por valores extremos.

    En Python

    def standardize(lst):
        mean = sum(lst) / len(lst)
        std_dev = (sum((x - mean) ** 2 for x in lst) / len(lst)) ** 0.5
        return [(x - mean) / std_dev for x in lst]
    
    data = [1, 2, 3, 4, 5]
    standardized = standardize(data)
    print(standardized)

    O utilizando scikit-learn:

    from sklearn.preprocessing import StandardScaler
    
    data = [[1], [2], [3], [4], [5]]
    scaler = StandardScaler()
    standardized = scaler.fit_transform(data)
    print(standardized)

    Cuándo Normalizar o Estandarizar

    CasoMétodo recomendado
    Quieres los valores en rango [0, 1]Normalización min–máx
    Tienes valores atípicos o distribuciones no uniformesEstandarización
    Modelos sensibles a la escala (k-means, SVM, PCA)Ambos, según el caso
    Modelos basados en árboles (Random Forest, XGBoost)No necesario

    El centrado y escalado de datos no son simples pasos técnicos: son fundamentales para que los algoritmos interpreten correctamente la información. Elegir entre normalización y estandarización dependerá de la naturaleza del conjunto de datos y del modelo que vayas a emplear.

    En resumen:

    • Centrar elimina el sesgo de posición (media ≈ 0).
    • Escalar elimina el sesgo de magnitud (dispersión comparable).
    • La normalización fija un rango; la estandarización fija la media y varianza.

    Ambas operaciones son pilares del preprocesamiento de datos moderno en ciencia de datos y machine learning.

  • Manejo de Datos Faltantes

    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:

    StoreIDProductIDProductColorPrice
    A1Red20
    B3Blue18
    C1NULL20
    C2NULL25

    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)

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

    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)

    Forward Fill (LOCF)

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

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

    Interpolación

    Calcula un valor intermedio entre los datos vecinos:

    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:

    TimestampValue
    08:0112
    08:0213
    08:03Falta
    08:0416

    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

    EstrategiaCuándo usarlaRiesgo
    Eliminación por listaPocos valores faltantesPérdida de datos
    Eliminación por paresSolo faltan algunas variablesMínimo
    Imputación media/medianaDatos numéricos simplesSesgo posible
    LOCF o InterpolaciónSeries temporalesPuede suavizar en exceso
    Modelos predictivosDatos complejos o correlacionadosMayor esfuerzo computacional

    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.

  • Transformación de Datos

    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)

    Reasignar Valores de Clave

    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)

    Eliminar Claves Innecesarias

    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)

    Reindexación Basada en Claves

    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)
    • Aplicar condiciones de validación
    assert (df['column'] > 0).all()
    • Validación de texto con expresiones regulares
    df['text_column'].str.match(r'^\w+$')
    • Detección de valores nulos
    df.isnull().sum()
    df.dropna(subset=['column'], inplace=True)
    • Valores únicos y duplicados
    df['column'].is_unique
    df.drop_duplicates(subset=['column'], inplace=True)
    • Rangos de valores
    df[(df['column'] >= min_value) & (df['column'] <= max_value)]
    • Validación de categorías
    allowed = {'cat1', 'cat2'}
    df['col'].isin(allowed)
    • Validación cruzada entre columnas
    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()
    • Eliminar valores faltantes
    df.dropna()
    • Rellenar valores faltantes
    df.fillna(method='ffill')
    • Conversión de tipos
    df.astype({'col1': 'int32'})
    • Normalización de texto
    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')
    • Guardar los datos limpios
    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()

    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()
    • Transformaciones matemáticas
    df['normalized'] = (df['x'] - df['x'].mean()) / df['x'].std()
    • Descomposición de fechas
    df['year'] = df['date'].dt.year
    • One-hot encoding
    pd.get_dummies(df['category'])
    • Binning
    pd.cut(df['var'], bins=3)
    • Cálculo de diferencias
    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')
    • Normalización de texto
    df['texto'] = df['texto'].str.lower().str.strip()
    • Fechas y horas
    df['fecha'] = pd.to_datetime(df['fecha'])
    • Conversión a categorías
    df['cat'] = df['cat'].astype('category')
    • Exportar a otros formatos
    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()

    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')]

    También puedes aplicar funciones personalizadas:

    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')

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