Autor: Fernando

  • Del Modelo Lineal Simple a la Regresión por Mínimos Cuadrados

    El ajuste por mínimos cuadrados es uno de los pilares del análisis de datos.
    Nos permite encontrar patrones y relaciones entre variables incluso cuando los datos no son perfectos. La idea esencial es siempre la misma:

    Buscar los coeficientes que minimicen el error entre las observaciones reales y las predicciones del modelo.

    A partir de aquí, la regresión lineal se convierte en la base de modelos más complejos de machine learning, donde la idea de “ajustar” parámetros para minimizar errores sigue siendo el núcleo de todo el proceso.

    De los datos a la recta

    Imaginemos que tenemos dos variables, x y y, y sospechamos que están relacionadas de forma lineal. Por ejemplo:

    x = [1, 2, 3, 4, 5]
    y = [7, 11, 15, 19, 23]
    Código de la Grafica

    Código en Matplotlib

    import matplotlib.pyplot as plt
    
    # Datos
    x = [1, 2, 3, 4, 5]
    y = [7, 11, 15, 19, 23]
    
    # Crear gráfico de dispersión
    plt.scatter(x, y, color='blue', marker='o', label='Datos')
    
    # Etiquetas y título
    plt.title('Gráfico de dispersión: relación entre X y Y')
    plt.xlabel('X')
    plt.ylabel('Y')
    plt.grid(True)
    plt.legend()
    
    # Mostrar gráfico
    plt.show()

    El modelo lineal

    Si las variables son linealmente dependientes, podemos escribir:

    $$y = \beta_0 + \beta_1 x$$

    donde:

    • β₀ (beta cero) es el intercepto, el valor de y cuando x = 0.
    • β₁ (beta uno) es la pendiente, que indica cuánto cambia y por cada unidad de x.

    Nuestro objetivo es determinar estos coeficientes (β₀ y β₁) de manera que la recta se ajuste lo mejor posible a los datos.

    Representando el modelo como un sistema lineal

    Podemos escribir la ecuación anterior en forma matricial.
    Para cada observación de \(x\), formamos una fila en una matriz \(M \)que tiene dos columnas: una con los valores de \(x\) y otra con unos.

    $$M =\begin{bmatrix}1 & 1 \\ 2 & 1 \\ 3 & 1 \\ 4 & 1 \\ 5 & 1 \end{bmatrix} ,\quad \beta = \begin{bmatrix} \beta_1 \\ \beta_0 \end{bmatrix}$$

    Entonces el modelo se puede escribir como:

    $$y = M \cdot \beta$$

    donde y es el vector de observaciones reales.

    Si tenemos más ecuaciones que incógnitas (más datos que parámetros), se trata de un sistema sobredeterminado, y no habrá una solución exacta. En esos casos, buscamos una solución aproximada, aquella que minimiza los errores o residuos.

    Resolviendo con el método de los mínimos cuadrados

    La solución óptima en el sentido de mínimos cuadrados se obtiene resolviendo la ecuación normal:

    $$\hat{\beta} = (M^T M)^{-1} M^T y$$

    Aquí:

    • \( M^T \) es la traspuesta de \(M\).
    • \( (M^T M)^{-1} \) es su inversa.
    • \( \hat{\beta} \) son las estimaciones de los coeficientes.

    En el ejemplo de datos anteriores, este procedimiento nos da:

    $$\beta_0 = 3, \quad \beta_1 = 4$$

    por lo que la ecuación ajustada es:

    $$y = 3 + 4x$$

    Si probamos estos valores, obtenemos una coincidencia exacta con los datos: la relación es perfectamente lineal.

    Cuando los datos no son perfectamente lineales

    En la práctica, los datos reales rara vez se ajustan perfectamente a una línea.
    Supongamos que ahora tenemos un conjunto diferente:

    Código de la Grafica

    Código en Matplotlib

    import matplotlib.pyplot as plt
    
    # Datos
    x = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    y = [8, 10, 14, 18, 21, 23, 26, 27, 29, 33]
    
    # Crear gráfico de dispersión
    plt.scatter(x, y, color='blue', marker='o', label='Datos')
    
    # Etiquetas y título
    plt.title('Gráfico de dispersión: relación entre X y Y')
    plt.xlabel('X')
    plt.ylabel('Y')
    plt.grid(True)
    plt.legend()
    
    # Mostrar gráfico
    plt.show()

    Vemos que no todos caen exactamente sobre una misma recta. Aun así, queremos una línea que represente la tendencia general: esa es la llamada línea de mejor ajuste (line of best fit).

    La idea de los residuos

    Cada punto tiene una pequeña distancia vertical hasta la recta estimada. Esa diferencia se llama residuo y se define como:

    $$\text{residuo}_i = y_i – \hat{y}_i$$

    donde \(\hat{y}_i\) es el valor predicho por el modelo. El método de mínimos cuadrados busca los parámetros β₀ y β₁ que minimicen la suma de los cuadrados de esos residuos:

    $$\text{minimizar } \sum_{i=1}^{n} (y_i – \hat{y}_i)^2$$

    En forma desarrollada o explícita:

    $$\text{minimizar: } (y_1 – \hat{y}_1)^2 + (y_2 – \hat{y}_2)^2 + \cdots + (y_n – \hat{y}_n)^2$$

    Al hacerlo, la recta resultante será aquella que “pasa más cerca” de todos los puntos en promedio.

    Interpretación visual

    • β₀ desplaza la recta hacia arriba o abajo.
    • β₁ modifica su inclinación.

    Podemos imaginar que “movemos” y “rotamos” la línea hasta que la suma de los residuos sea lo más pequeña posible. En ese punto, hemos encontrado la línea de mejor ajuste.

    Extensión a modelos polinomiales

    La misma lógica se puede aplicar cuando la relación no es lineal. Por ejemplo, si creemos que \(y \) depende de \(x²\), podemos ajustar un modelo cuadrático:

    $$y = \beta_0 + \beta_1 x + \beta_2 x^2$$

    En este caso, la matriz \(M \) tendrá tres columnas: una para \(x^2\), una para \(x\) y una para los unos.

    $$M = \begin{bmatrix} x_1^2 & x_1 & 1 \\ x_2^2 & x_2 & 1 \\ \vdots & \vdots & \vdots \\ x_n^2 & x_n & 1 \end{bmatrix}$$

    Y nuevamente, los coeficientes se obtienen con la misma fórmula general:

    $$\hat{\beta} = (M^T M)^{-1} M^T y$$

    Si aplicamos este método a un conjunto de datos donde la relación es cuadrática, obtendremos una curva que se adapta mucho mejor a los puntos observados que una simple línea.

    Generalización

    Esta metodología puede ampliarse para ajustar polinomios de grado superior o otros tipos de funciones (logarítmicas, exponenciales, etc.), siempre que podamos expresar el modelo en forma lineal respecto a los coeficientes β.

    Por ejemplo, para un polinomio cúbico:

    $$y = \beta_0 + \beta_1 x + \beta_2 x^2 + \beta_3 x^3$$

    solo tendríamos que añadir una columna más a \(M\)con los valores de (x^3).

  • Resolver Sistemas Lineales de Forma Probabilística con Regresión de Mínimos Cuadrados Ordinarios (OLS)

    Consideremos un sistema sobredeterminado, donde la matriz \( M \) no es cuadrada, sino rectangular: tiene dimensiones \(n \times p \), siendo \( n > p \). Esto ocurre, por ejemplo, cuando tenemos más observaciones que variables.

    Podemos imaginar un ejemplo sencillo:

    • \( x \) –> representa los precios de diferentes productos del supermercado.
    • \( M\) –> es una matriz que contiene la cantidad de cada producto que compraron distintas personas.
    • \( y\)–> es el vector del coste total de la compra de cada individuo.

    Hasta aquí, todo parece un sistema de ecuaciones lineales clásico: \( Mx = y \).
    Sin embargo, en la vida real los precios no son constantes: cambian entre tiendas, promociones o regiones. Así que incorporamos esa variabilidad aleatoria en el modelo.

    La idea probabilística

    Si cada individuo experimenta ligeras variaciones en los precios, no hay un único valor “verdadero” para cada producto. Por eso, nuestro objetivo no será encontrar un precio exacto, sino una estimación promedio de los precios:

    $$ \hat{x}$$

    donde el símbolo del “sombrero” \(ˆ\) indica que se trata de una estimación. De este modo, cada elemento de \( \hat{x} \) representa el precio medio estimado de un producto.

    Con esa estimación podemos obtener un coste total estimado multiplicando:

    $$\hat{y} = M \hat{x}$$

    Si nuestras estimaciones son buenas, entonces \(\hat{y} \) debería aproximarse lo más posible a los valores reales \( y \).

    Qué significa “lo más posible”

    Para medir qué tan cerca está nuestro resultado, podemos calcular la diferencia entre los valores reales y los estimados:

    $$y – \hat{y}$$

    y luego obtener su norma (la “distancia” entre ambos vectores). Nuestro objetivo es minimizar esa distancia. Este enfoque, de minimizar los errores cuadráticos, es justamente lo que hace la regresión OLS.

    Cómo funciona OLS

    En lugar de resolver directamente \( Mx = y \), multiplicamos ambos lados por la transpuesta de \( M \):

    $$M^T M x = M^T y$$

    Con esto obtenemos una matriz cuadrada \(p \times p\), que puede invertirse (si las columnas de \( M \) son linealmente independientes).

    De ahí obtenemos la fórmula del vector estimado:

    $$\hat{x} = (M^T M)^{-1} M^T y$$

    Este vector \( \hat{x} \)contiene los coeficientes de regresión, también llamados parámetros estimados.

    Comprobando la calidad del modelo

    Una vez tenemos \( \hat{x} \), podemos comparar las predicciones \( \hat{y} \) con los valores reales \( y \).
    Hay varias maneras de medir la calidad del ajuste:

    1. La norma del error: mide la magnitud de las diferencias \( y – \hat{y}\).
    2. El coeficiente de determinación \( R^2 \):
      Este valor, entre 0 y 1, indica qué proporción de la variación real de los datos está explicada por el modelo.
      • \( R^2 = 1 \): el modelo explica toda la variación (ajuste perfecto).
      • \(R^2 = 0\): el modelo no explica nada (mal ajuste).

    En esencia, \(R^2 \) compara cuánto mejoran nuestras predicciones respecto a usar solo el promedio de los datos.

    El concepto de residuo

    El residuo es la diferencia entre el valor real y el valor estimado para cada observación individual:

    $$\text{residuo}_i = y_i – \hat{y}_i$$

    Gráficamente, si representamos los puntos reales y los estimados, cada residuo es la distancia vertical entre ellos. Un buen modelo tendrá residuos pequeños y distribuidos al azar.

    Ejemplo: precios de supermercado

    Supongamos que tenemos 9 productos (manzanas, naranjas, pan, etc.) y los registros de compras de 450 personas. Cada persona pudo haber pagado precios ligeramente diferentes por los mismos artículos, dependiendo de la tienda o el día.

    • Si no hubiera variaciones (todos pagan el mismo precio), entonces \( \hat{y} = y \): el modelo reproduce exactamente los costes reales.
    • Si hay variaciones, los puntos estimados y los reales ya no coincidirán perfectamente, y aparecerán residuos.

    Aun así, la regresión OLS nos permite encontrar los promedios óptimos que minimizan los errores totales, proporcionando una estimación realista del comportamiento de compra.

    Paso 1: importar librerías y definir matrices

    import numpy as np
    
    # Matriz M: cantidades compradas (filas = personas, columnas = productos)
    M = np.array([
        [2, 3],   # persona 1: 2 manzanas, 3 naranjas
        [3, 5]    # persona 2: 3 manzanas, 5 naranjas
    ])
    
    # Vector y: total gastado por cada persona
    y = np.array([13, 21.6])

    Paso 2: aplicar la fórmula de OLS

    $$\hat{x} = (M^T M)^{-1} M^T y$$

    # Cálculo del estimador OLS
    x_hat = np.linalg.inv(M.T @ M) @ M.T @ y
    print("Estimaciones de precios:", x_hat)
    

    Salida esperada:

    Estimaciones de precios: [0.2 4.2]

    Esto indica que:

    • Precio estimado de una manzana ≈ $0.20
    • Precio estimado de una naranja ≈ $4.20

    Paso 3: calcular las predicciones y los residuos

    # Predicciones del modelo
    y_hat = M @ x_hat
    
    # Cálculo de los residuos
    residuos = y - y_hat
    
    print("Predicciones (ŷ):", y_hat)
    print("Residuos:", residuos)
    

    Salida esperada:

    Predicciones (ŷ): [13.  21.6]
    Residuos: [0. 0.]

    El modelo reproduce exactamente los valores observados, aunque —como vimos— los precios estimados no reflejan la realidad del sistema, porque el modelo no contempla variaciones individuales.

    Paso 4: medir la calidad del ajuste (R²)

    # Cálculo del coeficiente de determinación
    R2 = 1 - np.sum((y - y_hat)**2) / np.sum((y - np.mean(y))**2)
    print("Coeficiente R²:", R2)

    Salida esperada:

    Coeficiente R²: 1.0

    El modelo tiene un ajuste perfecto con solo dos observaciones, pero los parámetros no son realistas: este es un ejemplo ideal para entender que un buen ajuste no siempre significa un modelo correcto.

    Conclusión

    La regresión de mínimos cuadrados ordinarios (OLS) nos permite resolver sistemas lineales cuando los datos no encajan exactamente, buscando el mejor ajuste promedio posible.
    En este ejemplo, aunque el modelo predice perfectamente los costes totales, los parámetros estimados (los precios) son poco realistas porque los datos iniciales no cumplían las condiciones necesarias para una solución exacta.

    En la práctica, el OLS es una herramienta central en ciencia de datos: es la base de la regresión lineal, de muchos métodos de modelado predictivo y de análisis estadístico que permiten capturar relaciones entre variables reales y ruidosas.

  • Cuando la matriz no es cuadrada: el truco del transpuesto

    Imagina que tenemos una situación un poco diferente a la habitual. Supón que registramos el comportamiento de compra de varias personas en un supermercado. Tenemos los precios de los productos, los gastos totales de cada cliente, y una matriz que muestra cuántas unidades de cada producto compró cada uno.

    Cada persona compra distintas cantidades de unos pocos artículos —por ejemplo, tres productos diferentes—, y tenemos los datos de 100 clientes. Esto significa que nuestro número de filas (n = 100) es mucho mayor que el número de columnas (p = 3). En otras palabras, la matriz que representa esas compras ya no es cuadrada, sino rectangular.

    ¿Y cuál es el problema?
    Que las matrices rectangulares no tienen inversa, por lo que no podemos usar el método de «retroceso» (backsolving) que aplicábamos antes para resolver el sistema. En vez de rendirnos, vamos a usar un truco matemático muy útil: el transpuesto de la matriz.

    Qué significa transponer una matriz

    Transponer una matriz significa reflejar sus elementos respecto de la diagonal principal (la línea que va del vértice superior izquierdo al inferior derecho).
    Por ejemplo:

    • Si tienes un vector fila, su transpuesto será un vector columna.
    • Si tienes una matriz cuadrada, transponerla intercambia sus filas por columnas.
    • Si tienes una matriz rectangular de 3×2, su transpuesta será de 2×3.

    Una propiedad interesante es que el transpuesto del transpuesto te devuelve la matriz original.

    Qué ocurre al multiplicar una matriz por su transpuesta

    Supón que tienes una matriz \( M \) de tamaño \( n \times p \) (por ejemplo, 100 × 3). Si calculas el producto de su transpuesta por ella misma, es decir \( M^T \times M\), el resultado sí es una matriz cuadrada de tamaño \( p \times p \) (en este ejemplo, 3 × 3).
    Eso significa que podemos intentar invertirla.

    En resumen:

    • Si \( M \) es \(n \times p \),
    • entonces \( M^T \) es \(p \times n\),
    • y \( M^T M\) es \( p \times p \), una matriz cuadrada.

    Esto nos abre una puerta para resolver el sistema que antes parecía imposible.

    Aplicando el truco: resolver el sistema con el transpuesto

    En lugar de intentar resolver directamente \( Mx = y \) (lo cual no podemos hacer porque \(M\) no tiene inversa), multiplicamos ambos lados por \( M^T \):

    $$M^T Mx = M^T y$$

    Ahora, el sistema tiene una matriz cuadrada \(M^T M \).
    Si esta matriz tiene inversa, podemos calcular:

    $$x = (M^T M)^{-1} M^T y$$

    Y así obtenemos una solución para x.

    Cuándo existe esa inversa

    La clave está en la independencia lineal de las columnas de \(M\). Si las columnas son linealmente independientes (es decir, ninguna es combinación de las otras), entonces \( M^T M \) tendrá una inversa.

    Si no lo son —por ejemplo, si una columna es el doble de otra—, entonces \( M^T M \) no será invertible y este método no funcionará.

    Cómo hacerlo en Python

    En NumPy puedes obtener el transpuesto de una matriz simplemente con .T.
    Por ejemplo:

    import numpy as np
    
    M = np.array([[1, 2],
                  [3, 4],
                  [5, 6]])
    
    M_trans = M.T
    print(M_trans)

    El resultado será:

    [[1 3 5]
     [2 4 6]]

    Relación con la regresión lineal

    Lo que acabamos de hacer manualmente es, en esencia, una regresión lineal por mínimos cuadrados. En lugar de usar fórmulas estadísticas, usamos álgebra matricial para encontrar los coeficientes (precios) que mejor explican los datos observados (costes totales).

    En Python, este mismo procedimiento lo implementa la clase LinearRegression del paquete scikit-learn. Basta con:

    from sklearn.linear_model import LinearRegression
    
    modelo = LinearRegression(fit_intercept=False)
    modelo.fit(M, y)
    x_hat = modelo.coef_

    En resumen

    Cuando la matriz no es cuadrada, no podemos invertirla directamente. Pero si multiplicamos por su transpuesta, obtenemos una matriz cuadrada que sí puede tener inversa.
    Ese es el truco del transpuesto, y es la base de la regresión lineal y de muchos métodos de optimización en ciencia de datos.

  • Cuando el Backsolving falla: Variación en los Sistemas de Ecuaciones Lineales


    En artículos anteriores trate del backsolving aplicado a sistemas de ecuaciones lineales, es decir, aquellos que tienen la forma \(M \cdot P = C\). Donde \( M \) es una matriz cuadrada conocida, \(P\) es el vector de incógnitas y \( C \) es el vector de resultados conocidos. Resolver este tipo de problemas consiste en aplicar el método de backsolving, lo que equivale a calcular la inversa de la matriz ( M ).

    Recordemos que la matriz inversa es aquella que, al multiplicarse por la matriz original, da como resultado la matriz identidad: una matriz con unos en la diagonal principal y ceros en el resto.

    Este procedimiento funciona perfectamente cuando cada componente de \( P \) tiene una única solución, es decir, cuando el sistema es coherente y no hay ambigüedad.
    Por ejemplo, en el problema de precios de frutas, si el precio de una manzana y el de una naranja son fijos para todos los compradores, podemos resolver el sistema sin dificultad.

    Sin embargo, ¿qué ocurre si los compradores van a diferentes tiendas y los precios no son los mismos para todos?

    Podría suceder que en algunas tiendas las manzanas sean un poco más caras o más baratas. A primera vista, parece un sistema perfectamente válido: dos ecuaciones, dos incógnitas.
    Pero hay un detalle importante: el precio de las manzanas no es el mismo para ambos casos. Esto rompe el supuesto de “valores constantes” necesario para aplicar el backsolving.

    Lo que sucede es que el resultado es incongruente. El problema es que el método asume que los precios son los mismos para todos los individuos. Cuando esta condición no se cumple (como aquí, donde los precios varían entre personas), la solución obtenida no representa la realidad.

    Este tipo de error también ocurre cuando intentamos resolverlo programáticamente con Python. Veamos cómo se representaría en código:

    import numpy as np
    
    # Cantidad de frutas que compra cada persona
    M = np.array([[2, 3],   # Persona 1
                  [3, 5]])  # Persona 2
    
    # Precios variables: persona 1 y 2
    P = np.array([[2.0, 3.0], 
                  [2.2, 3.0]])
    
    # Costes totales observados
    C = np.array([13.0, 21.6])
    
    # Cálculo del coste multiplicando componente a componente
    costes = np.sum(M * P, axis=1)
    print(costes)

    Esto devuelve:

    [13.  21.6]

    Hasta aquí todo bien. Pero si intentamos backsolving con un único vector de precios promedio:

    # Intentar resolver suponiendo precios fijos
    C = np.array([13, 21.6])
    M = np.array([[2, 3],
                  [3, 5]])
    
    P_est = np.linalg.inv(M).dot(C)
    print(P_est)

    El resultado será el mismo que hallamos a mano:

    [0.2 4.2]

    Es decir, la solución matemática es consistente dentro del sistema, pero no tiene interpretación real.

    Conclusión

    El método de backsolving es eficaz solo cuando los parámetros son constantes. Si las variables cambian entre observaciones —como ocurre en este caso con los precios de las manzanas—, el método se vuelve inadecuado y los resultados carecen de sentido práctico.

    En próximos artículos abordo otros enfoques que permitan manejar situaciones donde los valores del vector desconocido varían entre individuos o condiciones, como ocurre en muchos problemas reales de datos.

  • Estadísticas Resumidas: La Base del Análisis de Datos Exploratorio

    En el análisis de datos, especialmente cuando trabajamos con conjuntos de datos tabulares, es común que lo primero que queramos hacer sea “entender el terreno”: obtener una visión rápida de los patrones, la distribución y las características principales de las variables.
    A este proceso lo llamamos estadísticas resumidas (summary statistics), y constituye uno de los pilares del análisis exploratorio de datos (EDA, Exploratory Data Analysis).

    Estas estadísticas nos permiten responder preguntas básicas como:

    • ¿Qué tan centrados o dispersos están los datos?
    • ¿Existen valores extremos o atípicos?
    • ¿Cómo se distribuyen los valores?
    • ¿Qué categorías son más frecuentes?

    Estas herramientas —medias, dispersiones, cuartiles, gráficos y agrupaciones— nos permiten:

    • Preparar los datos para análisis más complejos.
    • Detectar errores o valores extremos.
    • Comprender patrones iniciales.

    Análisis Univariado: Explorando una Variable a la Vez

    El análisis univariado se enfoca en describir y entender una sola variable por vez. Es la forma más directa de comenzar el EDA y nos permite observar tendencias, detectar anomalías y entender el comportamiento general de los datos.

    Podemos dividirlo en dos grandes tipos:

    • Variables cuantitativas (numéricas)
    • Variables categóricas (de tipo texto o etiquetas)

    Veamos cómo se resumen y visualizan cada una.

    Variables Cuantitativas

    Medidas de Tendencia Central

    Las medidas de tendencia central buscan representar el valor “típico” o central de un conjunto de datos.

    • Media (promedio): la suma de todos los valores dividida por el número de observaciones. Es útil, pero sensible a valores atípicos.
    • Mediana: el valor que divide al conjunto en dos partes iguales. Menos afectada por outliers, representa mejor distribuciones sesgadas.
    • Moda: el valor más frecuente. Muy útil en datos categóricos o multimodales.
    • Media recortada: elimina un porcentaje de los valores más altos y bajos antes de calcular la media.
    df['column'].mean() # media
    df['column'].median() # mediana
    df['column'].mode() # Moda
    
    # Media recortada:
    from scipy.stats import trim_mean 
    trim_mean(df.column, proportiontocut=0.1)

    Medidas de Dispersión

    Describen cuánto varían los valores respecto al centro.

    • Rango: diferencia entre el valor máximo y el mínimo.
    • Varianza: mide la variabilidad cuadrática respecto a la media.
    • Desviación estándar: raíz cuadrada de la varianza; indica cuánto se alejan los datos, en promedio, de la media.
    • Desviación media absoluta (MAD): promedio de las diferencias absolutas respecto a la media.
    df['column'].max() - df['column'].min()  # rango
    df['column'].var()  # Varianza
    df['column'].std()  # Desviacion estandar
    (df.column - df.column.mean()).abs().mean()  # Desviación media absoluta

    Asimetría (Skewness) y Curtosis

    Estas métricas describen la forma de la distribución:

    • Asimetría (Skewness): indica si los datos están sesgados a la izquierda o derecha.
      • Sesgo positivo → cola larga a la derecha
      • Sesgo negativo → cola larga a la izquierda
    • Curtosis (Kurtosis): mide el peso de las colas de la distribución (presencia de valores extremos). df['column'].kurt()
      • Leptocúrtica: colas gruesas (muchos outliers)
      • Platicúrtica: colas delgadas
      • Mesocúrtica: similar a la normal
    df['column'].skew()  # Asimetría 
    df['column'].kurt()  # Curtosis

    Percentiles y Cuartiles

    Los percentiles indican el porcentaje de observaciones por debajo de un valor dado.
    Por ejemplo, el percentil 80 = 130 significa que el 80% de los valores son menores que 130.

    np.percentile(df['column'], 80)

    Los cuartiles dividen los datos en cuatro partes iguales:

    • Q1 (25%), Q2 (50% = mediana), Q3 (75%)

    El rango intercuartílico (IQR) se calcula como:

    IQR = Q3 - Q1

    y representa la dispersión central, resistente a outliers.

    Visualización: Histogramas y Boxplots

    Visualizar los datos es esencial para complementar las estadísticas numéricas.

    • Histograma: muestra la frecuencia de valores en intervalos (bins).
    sns.histplot(df['column'])
    • Boxplot (diagrama de caja): representa la mediana, los cuartiles y los valores atípicos.
    sns.boxplot(df['column'])

    Estos gráficos ayudan a detectar sesgos, simetrías y valores extremos de un vistazo.


    Variables Categóricas

    Cuando analizamos variables no numéricas (como “país”, “color” o “tipo de producto”), las estadísticas cambian.

    Frecuencias y Proporciones

    La herramienta básica es el conteo de valores:

    df['column'].value_counts()

    Y para ver proporciones:

    df['column'].value_counts(normalize=True)

    Estas proporciones nos ayudan a entender la distribución de categorías, especialmente cuando hay clases dominantes o poco representadas.

    Visualización

    • Gráficos de barras: ideales para mostrar frecuencias.
    sns.countplot(x='column', data=df)
    • Gráficos circulares (pie charts): útiles para proporciones, aunque menos precisos.

    Agrupación y Agregación de Datos

    En análisis exploratorios más profundos, necesitamos obtener estadísticas por grupo.
    Por ejemplo: ¿Cuál es el precio promedio por tipo de carrocería?

    La función groupby() de pandas permite dividir, aplicar y combinar fácilmente:

    df.groupby('body-style')['price'].mean()

    También podemos aplicar múltiples funciones de agregación:

    df.groupby(['body-style', 'drive-wheels']).agg({
        'height': 'min',
        'length': 'max',
        'price': 'mean'
    })

    Y definir agregaciones personalizadas con agg():

    df.agg({'length':['sum','min'], 'width':['max','min']})

    Este enfoque es esencial para crear tablas resumen, indicadores por categoría y comparativas entre grupos.

    Variables Categóricas Ordinales

    Algunas categorías tienen un orden lógico (por ejemplo: “bajo”, “medio”, “alto”).
    En estos casos, podemos convertirlas en variables de tipo category ordenadas para analizarlas numéricamente:

    order = ['Preschool', 'Primary', 'Secondary', 'College', 'Graduate']
    df['education'] = pd.Categorical(df['education'], categories=order, ordered=True)

    Esto permite calcular la mediana de la categoría:

    median_index = np.median(df['education'].cat.codes)
    order[int(median_index)]

    Importante:

    Aunque podemos asignar números, no debemos calcular medias si las distancias entre categorías no son uniformes.

  • 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.