Categoría: Matematicas

Artículos de matemáticas para ciencia de datos y machine learning

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

  • Sustitución hacia atrás e inversión de Matrices

    El backsolving es un método para resolver sistemas de ecuaciones lineales una vez que ya hemos reducido el sistema a forma triangular superior mediante eliminación gaussiana (o cualquier otra técnica de factorización como LU).

    Trabajamos el mismo problema del articulo anterior:

    $$ M = \begin{bmatrix} 3 & 6 & 2 \\ 10 & 3 & 8 \\ 1 & 7 & 5 \end{bmatrix} , p = \begin{bmatrix} p_1 \\ p_2 \\ p_3 \end{bmatrix}, c = \begin{bmatrix} 34 \\ 69 \\ 48 \end{bmatrix} $$

    Queremos resolver los precios \( (p) \) de cada producto. En este caso utilizaremos eliminación gaussiana y luego sustitución hacia atrás — eso es, reducir el sistema a triangular superior y luego encontrar las incógnitas empezando por la última.

    Eliminación gaussiana (reducción hacia triangular superior)

    Escribimos el sistema en sus ecuaciones explícitas (producto fila por columna):

    $$ \begin{cases} 3p_1 + 6p_2 + 2p_3 = 34 \\ 10p_1 + 3p_2 + 8p_3 = 69 \\ 1p_1 + 7p_2 + 5p_3 = 48 \end{cases}$$

    Paso 1 — usar la primera ecuación para eliminar \(p_1\) de las filas 2 y 3.

    Despejamos \(p_1\) (temporalmente) o eliminamos directamente:

    Multiplicador para la fila 2: \(\frac{10}{3}=2\).
    Hacemos \(R_2 \leftarrow R_2 – 2R_1\):

    • Columna 1: \(10 – 2\cdot 3 = 0\).
    • Columna 2: \(3 – 2\cdot 6 = 3 – 12 = -9\).

    Multiplicador para la fila 3: \(\frac{1}{3}\).
    Hacemos \(R_3 \leftarrow R_3 – \frac{1}{3}R_1\).

    Después de eliminar \(p_1\) en filas 2 y 3 (operaciones sobre las filas):

    $$\begin{pmatrix}3 & 6 & 2 & | & 34\\0 & -17 & 4 & | & 1\\0 & \frac{4}{3} & \frac{13}{3} & | & \frac{76}{3} \end{pmatrix}$$

    Nota: la fila 2 quedó con coeficiente (-17) en la columna de \(p_2\). La fila 3 tiene fracciones — eso es normal en eliminación.

    Paso 2 — usar la fila 2 para eliminar la componente \(p_2\) de la fila 3.

    Multiplicador para \(R_3\): \(f=\frac{\frac{4}{3}}{-17}=-\frac{4}{51}\).
    Hacemos \(R_3 \leftarrow R_3 – f R_2 = R_3 + \frac{4}{51}R_2\).

    Al realizar esa operación la segunda columna de \(R_3\) queda 0 y obtenemos una ecuación sólo en \(p_3\):

    $$\begin{pmatrix}3 & 6 & 2 & | & 34 \\ 0 & -17 & 4 & | & 1 \\ 0 & 0 & \frac{241}{51} & | & \frac{1296}{51} \end{pmatrix}$$

    Paso 3 — despejar \(p_3\) y luego usar sustitución hacia atrás.

    De la tercera fila:

    $$\frac{241}{51},p_3 = \frac{1296}{51} \quad\Rightarrow\quad p_3 = \frac{1296}{241}$$

    Sustituyendo \(p_3\) en la segunda fila:

    $$-17,p_2 + 4,p_3 = 1 \quad\Rightarrow\quad p_2 = \frac{1 – 4p_3}{-17}$$

    Sustituyendo el valor numérico de \(p_3\) (o directamente resolviendo con las fracciones) se obtiene \(p_2=3\).

    Finalmente sustituimos \(p_2\) y \(p_3\) en la primera ecuación para obtener (p_1), que da (p_1=2).

    Conclusión del método manual (eliminación + sustitución):

    $$\mathbf p = \begin{pmatrix}2 \\ 3 \\ 5\end{pmatrix}$$

    ¿Qué significa calcular la inversa \(M^{-1}\) y cómo se obtiene con matriz aumentada?

    Otra forma más “directa” (y que explica el porqué de la eliminación) es calcular la inversa de \(M\). Si \(M\) es invertible entonces

    $$\mathbf p = M^{-1}\mathbf c$$

    Para encontrar \(M^{-1}\) se construye la matriz aumentada \([,M \mid I,]\) y se aplican operaciones elementales por filas hasta transformar el lado izquierdo en la identidad; entonces el lado derecho habrá quedado como \(M^{-1}\).

    Verificaciones numéricas y redondeo

    En la práctica, cuando calculas \(M^{-1}M\) en ordenador verás que los elementos fuera de la diagonal no son exactamente cero sino números muy pequeños (por ejemplo \(-5\times 10^{-17})\). Eso es error numérico de punto flotante. Si redondeas (por ejemplo a 10 decimales) obtendrás la matriz identidad exacta en la presentación.

    Resumen conceptual

    • Eliminación gaussiana: reduce el sistema a triangular superior (eliminación hacia adelante) y luego despeja las variables (sustitución hacia atrás).
    • Inversa por matriz aumentada: hacer operaciones elementales sobre \([M\mid I]\) hasta convertir \(M\) en \(I\); lo que quede a la derecha será \(M^{-1}\).
    • Comprobación: puedes verificar que \(M^{-1}\mathbf c = \mathbf p\) y \(M^{-1}M = I\) (hasta errores numéricos muy pequeños).

    Código Python

    import numpy as np
    
    # Definición de la matriz y vectores (el sistema del ejemplo)
    M = np.array([[3, 6, 2],
                  [10, 3, 8],
                  [1, 7, 5]], dtype=float)
    
    c = np.array([34, 69, 48], dtype=float)
    
    # 1) Resolver el sistema M p = c
    p = np.linalg.solve(M, c)
    print("Solución (np.linalg.solve):", p)
    
    # 2) Calcular la inversa de M
    M_inv = np.linalg.inv(M)
    print("\nInversa M^{-1}:\n", M_inv)
    
    # 3) Verificar que M^{-1} * c = p
    p_from_inv = M_inv @ c
    print("\nM^{-1} @ c =", p_from_inv)
    
    # 4) Verificar que M_inv @ M ≈ I (mostramos la matriz y una versión redondeada)
    I_approx = M_inv @ M
    print("\nM^{-1} @ M (aprox):\n", I_approx)
    print("\nM^{-1} @ M (redondeado a 10 decimales):\n", np.round(I_approx, 10))
    

    Salida:

    Solución (np.linalg.solve): [2. 3. 5.]
    
    Inversa M^{-1}:
     [[ 0.17012448  0.06639004 -0.17427386]
     [ 0.17427386 -0.05394191  0.01659751]
     [-0.2780083   0.06224066  0.21161826]]
    
    M^{-1} @ c = [2. 3. 5.]
    
    M^{-1} @ M (aprox):
     [[ 1.00000000e+00  0.00000000e+00  0.00000000e+00]
     [-1.56125113e-16  1.00000000e+00 -5.55111512e-17]
     [ 5.55111512e-17  0.00000000e+00  1.00000000e+00]]
    
    M^{-1} @ M (redondeado a 10 decimales):
     [[ 1.  0.  0.]
     [-0.  1. -0.]
     [ 0.  0.  1.]]
    

    Qué observar al ejecutar:

    • p debe salir como [2. 3. 5.].
    • M_inv @ c debe coincidir con p (igual numéricamente, dentro de tolerancias de punto flotante).
    • M_inv @ M será numéricamente la identidad; si ves valores muy pequeños fuera de la diagonal, es normal: redondea para comprobar que esos valores son efectivamente cero dentro de la precisión de la máquina.

    Resumen

    La eliminación y la inversa son dos caras de la misma moneda: la primera resuelve un sistema concreto, la segunda construye la “función inversa” que, aplicada a cualquier vector de costes, devolvería los precios.

    En aplicaciones (ciencia de datos, econometría, ingeniería), normalmente no calculamos la inversa si solo queremos resolver un sistema: usamos solve (algoritmos de factorización) por razones de estabilidad numérica y eficiencia. Sin embargo, obtener la inversa es útil para entender conceptualmente la transformada inversa y para comprobaciones.

  • Sistemas de Ecuaciones Lineales

    Resolviendo problemas reales.

    En artículos anteriores vimos operaciones sobre vectores y matrices desde la perspectiva matemática. Vamos a ver cómo esas mismas operaciones pueden resolver problemas reales, como descubrir cuánto cuesta cada producto de un supermercado.

    Escenario

    Volvemos a nuestro supermercado de frutas. Imaginemos que tenemos tres personas:
    Bob, Alice y Tim, que han ido al supermercado y compraron manzanas, naranjas y peras. Podemos representar sus compras en una matriz \(M\):

    $$M = \begin{bmatrix} 3 & 6 & 2 \\ 10 & 3 & 8 \\ 1 & 7 & 5 \end{bmatrix}$$

    Cada fila representa una persona, y cada columna representa un producto:

    PersonaManzanasNaranjasPeras
    Bob362
    Alice1038
    Tim175

    El coste total

    Sabemos cuánto pagó cada persona:

    $$C =\begin{bmatrix} 34 \\ 69 \\ 48 \end{bmatrix}$$

    Y queremos averiguar cuánto cuesta cada producto. Presentemos los importes que gasto cada uno en un vector que llamamos \( P \) , vector de precios:

    $$P = \begin{bmatrix} p_1 \\ p_2 \\ p_3 \end{bmatrix} $$

    Donde:

    • \(p_1\) –> precio de la manzana
    • \(p_2\) –> precio de la naranja
    • \(p_3\) –> precio de la pera

    Sabemos que:

    $$M \cdot P = C$$

    o, dicho en palabras: la cantidad comprada multiplicada por el precio unitario da el coste total.

    Escribiendo las ecuaciones

    Multiplicar la matriz \(M\) por el vector \(P\) nos da tres ecuaciones:

    $$ \begin{cases} 3p_1 + 6p_2 + 2p_3 = 34 \\ 10p_1 + 3p_2 + 8p_3 = 69 \\ 1p_1 + 7p_2 + 5p_3 = 48 \end{cases}$$

    Esto es un sistema de ecuaciones lineales con tres incógnitas: \( p_1, p_2, p_3 \). El sistema de ecuaciones en formato matricial:

    $$ \begin{bmatrix} 3 & 6 & 2 \\ 10 & 3 & 8 \\ 1 & 7 & 5 \end{bmatrix} \cdot \begin{bmatrix} p_1 \\ p_2 \\ p_3 \end{bmatrix} = \begin{bmatrix} 34 \\ 69 \\ 48 \end{bmatrix} $$

    Recordando, tenemos aqui:

    • Matriz de coeficientes: contiene los números que multiplican a las variables (las cantidades de las frutas).
    • Vector de incógnitas: las variables que queremos encontrar (precio de las frutas).
    • Vector de resultados: los valores en el lado derecho (total de dinero gastado).

    Solución

    Método de eliminación (Gauss, eliminación hacia adelante con sustitución). Se despeja una variable y se sustituye, reduciendo gradualmente el sistema hasta obtener cada variable.

    Paso 1 — despejar p1 de la ecuación (1)

    $$ 3p_1 + 6p_2 + 2p_3 = 34$$

    $$ p_1 =\frac{34}{3} \, – 2p_2 \, – \frac{2p_3}{3}$$

    Paso 2 — sustituir \(p_1\)​ en las ecuaciones (2) y (3)

    Sustitución en la ecuación (2):

    $$10p_1 + 3p_2 + 8p_3 = 69$$

    $$10(\frac{34}{3} – 2p_2 – \frac{2p_3}{3}) + 3p_2 + 8p_3 = 69$$

    Multiplicamos todo por 3 para eliminar el denominador:

    $$340−60p2​−20p3​+9p2​+24p3 \\ ​=207$$

    Agrupamos términos semejantes:

    • Términos en p_2​: −60p_2+9p_2=−51p_2
    • Términos en p_3​: −20p_3+24p_3=4p_3

    Queda:

    $$340−51p2​+4p3​=207$$

    Pasamos 340 al otro lado y calculamos:

    $$−51p2​+4p3​=207−340$$

    $$−51p2​+4p3​=-133$$

    Multiplicamos por −1 (para simplificar signos)(Ecuación A):

    $$51p2​-4p3​=133$$

    Sustitución en la ecuación (3):

    $$1p_1 + 7p_2 + 5p_3 = 48$$

    $$\frac{34}{3} – 2p_2 – \frac{2p_3}{3} + 7p_2 + 5p_3 = 48$$

    Multiplicamos por 3:

    $$34−6p2​−2p3​+21p2​+15p3​=144$$

    Agrupamos:

    • Términos en \(p_2: -6p_2 + 21p_2 = 15p_2\)
    • Términos en \(p_3: -2p_3 + 15p_3 = 13p_3\)

    Queda:

    $$34+15p_2​+13p_3​=144$$

    Pasamos 34 al otro lado (Ecuación B):

    $$15p_2​+13p_3​=144−34=110$$

    Ahora hemos reducido el sistema original a dos ecuaciones en \(p_2\)​ y \(p_3\)​:

    • (A) \(51p_2 – 4p_3 = 133\)
    • (B) \(15p_2 +13p_3 = 110\)

    Paso 3 — resolver el sistema reducido (A) y (B)

    Usamos eliminación. Multiplicamos la ecuación A por 15 y la B por −51 para cancelar \(p_2\)​:

    • A * 15: \( 765p_2 – 60p_3 = 1995\)
    • B * (-51): \( -765p_2 – 663p_3 = -5610\)

    Sumamos las dos ecuaciones:

    $$(765p2​−60p3​)+(−765p2​−663p3​)\\=1995−5610$$

    Se cancelan los \(p_2\) Queda:

    $$−723p3​=−3615$$

    Despejamos \(p_3\)​:

    $$p_3 = \frac{-3615}{-723} = \frac{3615}{723} = 5$$

    Ahora sustituimos \(p_3 = 5\) en la ecuación B:

    $$15p_2​+13 \cdot 5=110$$

    $$15p_2​+65 =110$$

    $$15p_2​ =45$$

    $$p_2​ =3$$

    Por último, calculamos \(p_1\)​ usando la fórmula que obtuvimos en el Paso 1:

    $$p_1 = \frac{34 – 6p_2 – 2p_3}{3}$$

    $$p_1 = \frac{34 – 6 \cdot 3 – 2 \cdot 5}{3}$$

    $$p_1 = \frac{34 – 18 – 10}{3}$$

    $$p_1 = \frac{6}{3} = 2$$

    Resultado final: \(p_1 = 2, p_2 = 3, p_3 = 5\)

    Precios

    • Manaza: 2$
    • Naranja: 3€
    • Pera: 5€

    Paso 4 — verificación (comprobación directa)

    Multiplicamos la matriz por el vector precios para ver si obtenemos los costes:

    $$M = \begin{bmatrix} 3 & 6 & 2 \\ 10 & 3 & 8 \\ 1 & 7 & 5 \end{bmatrix}, p = \begin{bmatrix} 2 \\ 3 \\ 5 \end{bmatrix}$$

    Producto \(Mp\):

    • Fila 1: \( 3 \cdot 2 + 6 \cdot 3 + 2 \cdot 5 = 34\)
    • Fila 2: \( 10 \cdot 2 + 3 \cdot 3 + 8 \cdot 5 = 69\)
    • Fila 3: \( 1 \cdot 2 + 7 \cdot 3 + 5 \cdot 5 = 48\)

    Solución con Python

    Este código usa numpy.linalg.solve, que aplica internamente eliminación de Gauss con pivotado, y es la forma más eficiente y segura de resolver sistemas lineales \(\)A \cdot x = b en Python.

    import numpy as np
    
    # Matriz de coeficientes
    A = np.array([
        [3, 6, 2],
        [10, 3, 8],
        [1, 7, 5]
    ], dtype=float)
    
    # Vector de resultados
    b = np.array([34, 69, 48], dtype=float)
    
    # Resolver el sistema A·x = b
    sol = np.linalg.solve(A, b)
    
    # Mostrar resultados
    p1, p2, p3 = sol
    print(f"p1 = {p1:.2f}, p2 = {p2:.2f}, p3 = {p3:.2f}")

    Salida:

    p1 = 2.00, p2 = 3.00, p3 = 5.00
  • Eigenvectores, Eigenvalores y Compresión de Datos (Eigenfaces)

    En el artículo anterior se trabajo los autovalores y autovectores, es común quedarse con la sensación de que son conceptos abstractos. Pero en realidad, están detrás de muchas de las herramientas más potentes del análisis de datos moderno.

    Una de ellas es el Análisis de Componentes Principales (PCA), una técnica que permite comprimir información sin perder lo esencial.

    En este artículo veremos cómo los eigenvectores sirven para reducir la dimensionalidad de los datos, y cómo este principio se aplica a algo tan visual como la compresión de imágenes de rostros humanos.

    Cuando trabajamos con datos reales —imágenes, audio, sensores o registros de clientes— solemos tener miles de variables. Eso significa que el procesamiento se vuelve lento, costoso y muchas veces innecesario, porque buena parte de los datos son redundantes.

    El PCA (Principal Component Analysis) se basa precisamente en encontrar las direcciones de mayor variabilidad dentro de los datos. Y esas direcciones no son otras que los autovectores de la matriz de covarianza del conjunto.

    Visualizando el concepto con una imagen

    Una imagen digital no es más que una matriz de números, donde cada valor representa la intensidad del color (por ejemplo, del blanco al negro si es en escala de grises).

    Para este ejemplo usaremos el famoso dataset de rostros de celebridades incluido en scikit-learn.

    from sklearn.datasets import fetch_lfw_people
    import matplotlib.pyplot as plt
    
    # Cargamos el dataset de caras
    faces = fetch_lfw_people(min_faces_per_person=60)
    image = faces.images[0]
    
    plt.imshow(image, cmap='bone')
    plt.title(f"Ejemplo de imagen: {faces.target_names[0]}")
    plt.axis('off')
    plt.show()
    

    Cada imagen tiene 62 filas × 47 columnas, es decir, 2.914 píxeles o variables.
    PCA nos permitirá representar esta misma información con muchas menos variables.


    Aplicando PCA paso a paso

    PCA consiste básicamente en tres fases:

    1. Calcular la matriz de covarianza del conjunto de datos.
    2. Obtener sus autovectores y autovalores.
    3. Proyectar los datos sobre las direcciones asociadas a los autovalores más grandes, que contienen la mayor parte de la varianza.

    En código, podemos hacerlo así:

    from sklearn.decomposition import PCA
    import numpy as np
    
    # Aplanamos las imágenes 2D a vectores 1D
    X = faces.data
    
    # Aplicamos PCA para conservar solo 15 componentes principales
    pca = PCA(n_components=15)
    X_pca = pca.fit_transform(X)
    
    # Reconstruimos las imágenes desde los componentes principales
    X_reconstructed = pca.inverse_transform(X_pca)
    
    # Mostramos la imagen original y la reconstruida
    fig, axes = plt.subplots(1, 2, figsize=(8, 4))
    axes[0].imshow(X[0].reshape(62, 47), cmap='bone')
    axes[0].set_title("Imagen original")
    axes[0].axis('off')
    
    axes[1].imshow(X_reconstructed[0].reshape(62, 47), cmap='bone')
    axes[1].set_title("Reconstruida (15 componentes)")
    axes[1].axis('off')
    
    plt.show()
    

    ¿Qué estamos haciendo en realidad?

    Cada componente principal es un autovector de la matriz de covarianza.
    Cada uno representa una dirección en el espacio de datos donde la información cambia más.
    Los autovalores indican cuánta “varianza” explica cada componente.

    En este caso, al reconstruir la imagen con solo 15 componentes, vemos una versión algo borrosa, pero perfectamente reconocible. Hemos pasado de 2.914 variables a solo 15, manteniendo casi toda la información útil.

    Si reducimos a 5 componentes, la imagen pierde detalle; si aumentamos a 50, se ve casi igual que la original. Todo depende del equilibrio que queramos entre tamaño y fidelidad.


    Las “eigenfaces”

    Una de las formas más visuales de entender PCA en imágenes es observar los autovectores directamente. En este caso se les conoce como eigenfaces, o “caras propias”.

    Cada eigenface representa un patrón característico: sombras de ojos, contorno del rostro, luz lateral, expresión, etc.

    Podemos verlos así:

    fig, axes = plt.subplots(3, 5, figsize=(9, 6))
    for i, ax in enumerate(axes.flat):
        ax.imshow(pca.components_[i].reshape(62, 47), cmap='bone')
        ax.set_title(f"Comp {i+1}")
        ax.axis('off')
    plt.suptitle("Los 15 eigenfaces principales")
    plt.show()
    

    Los eigenvectores son, en el fondo, una forma de entender la estructura interna de los datos.

  • Eigenvectors y eigenvalues

    Verás que, aunque una transformación lineal cambia la dirección de la mayoría de los vectores, existen algunos vectores especiales que no rotan, solo se estiran o encogen.
    Esos vectores son los autovectores (eigenvector), y la cantidad por la que se estiran o encogen se llama autovalor (eigenvalues).

    Intuición: vectores que no cambian de dirección

    Imagina una matriz que representa una transformación lineal —por ejemplo, una matriz de “shear” (cizallamiento), que deforma un cuadrado en un paralelogramo.
    En la mayoría de los casos, todos los vectores cambian de dirección al aplicar la transformación… excepto algunos muy particulares. Esos vectores especiales mantienen su dirección (aunque pueden cambiar su longitud). Por eso decimos que son autovectores.

    Ejemplo de una transformación Lineal:

    import numpy as np
    
    M = np.array([[2, 1],
                  [1, 3]])
    
    square = np.array([[0, 0, 1, 1, 0],
                       [0, 1, 1, 0, 0]])
    transformed = M @ square
    Código de la grafica

    Código Python con Matplotlib

    fig, ax = plt.subplots(figsize=(8,8))
    ax.plot(square[0], square[1], 'b--', label='Original')
    ax.plot(transformed[0], transformed[1], 'r-', label=f'Shear con b={b}')
    
    ax.set_xlim(-1, 3)
    ax.set_ylim(-1, 3)
    ax.axhline(0, color='black')
    ax.axvline(0, color='black')
    ax.set_aspect('equal')
    ax.legend()
    plt.show()

    Definición

    Un vector \( \vec{v} \) es un autovector de una matriz \( M \) si, al aplicar la matriz transformadora sobre él, el resultado es el mismo vector escalado por un número \( \lambda \):

    $$M \vec{v} = \lambda \vec{v}$$

    Donde:

    • \( M \) → es una matriz cuadrada \(n \times n\)
    • \( \vec{v} \) → es un autovector
    • \( \lambda \) → es el autovalor asociado

    Este número \( \lambda \) indica cuánto se estira o encoge el vector cuando la matriz actúa sobre él.

    Interpretación geométrica

    • Si \( \lambda > 1 \): el vector se alarga.
    • Si \( 0 < \lambda < 1 \): el vector se encoge.
    • Si \( \lambda < 0 \): el vector cambia de sentido (se invierte).
    • Si \( \lambda = 1 \): el vector queda igual.

    Calculando los eigenvectors y eigenvalues

    Continuamos con el ejemplo inicial:

    import numpy as np
    
    # Calcular eigenvalores y eigenvectores
    w, V = np.linalg.eig(M)
    
    print("\nEigenvalores:\n", w)
    print("\nEigenvectores (columnas):\n", V)

    Salida:

    Eigenvalores:
     [1.38196601 3.61803399]
    
    Eigenvectores (columnas):
     [[-0.85065081 -0.52573111]
     [ 0.52573111 -0.85065081]]
    Código de la grafica

    Código Matplotlib

    import matplotlib.pyplot as plt
    fig, ax = plt.subplots(figsize=(8,8))
    
    # Cuadrado original (azul) y transformado (rojo)
    ax.plot(square[0], square[1], 'b--', label='Original (cuadrado unidad)')
    ax.plot(transformed[0], transformed[1], 'r-', label='Transformado M·S')
    
    # Ejes
    ax.axhline(0, color='black', linewidth=1)
    ax.axvline(0, color='black', linewidth=1)
    
    # Eigenvectores
    for i in range(len(w)):
        v = V[:, i]            # vector propio
        Mv = M @ v             # su transformación
        λ = w[i]
    
        # Dibuja el eigenvector (azul)
        ax.quiver(0, 0, v[0], v[1], angles='xy', scale_units='xy', scale=1,
                  color='blue', width=0.007, label=fr'$v_{i+1}$')
    
        # Dibuja el vector transformado (rojo)
        ax.quiver(0, 0, Mv[0], Mv[1], angles='xy', scale_units='xy', scale=1,
                  color='red', width=0.007, label=fr'$M v_{i+1} = \lambda_{i+1} v_{i+1}$')
    
        # Muestra texto con el eigenvalor
        ax.text(Mv[0]*1.1, Mv[1]*1.1, fr'$\lambda_{i+1}={λ:.2f}$', color='red', fontsize=10)
    
    ax.set_xlim(-4, 4)
    ax.set_ylim(-4, 4)
    ax.set_aspect('equal', adjustable='box')
    ax.legend(loc='upper left', facecolor='none', edgecolor='none')
    ax.set_title("Transformación lineal y Eigenvectores", fontsize=14)
    ax.set_xlabel("x")
    ax.set_ylabel("y")
    plt.grid(True)
    plt.show()
    

    Matrices simétricas

    Cuando una matriz es simétrica (es decir, \( M = M^T \)), se cumple algo muy útil:

    • Todos sus autovectores son perpendiculares entre sí.
    • Sus autovalores son reales.

    Por ejemplo:

    A = np.array([[4, 1],
                  [1, 4]])
    
    autovalores, autovectores = np.linalg.eig(A)
    print("Autovalores:", autovalores)
    print("Autovectores:\n", autovectores)
    
    print("Producto punto entre los autovectores:", np.dot(autovectores[:,0], autovectores[:,1]))

    La salida mostrará que el producto punto es 0, confirmando que los autovectores son ortogonales.

    Autovalores: [5. 3.]
    Autovectores:
     [[ 0.70710678 -0.70710678]
     [ 0.70710678  0.70710678]]
    Producto punto entre los autovectores: 0.0

    Aplicaciones en ciencia de datos

    Los eigenvectores y eigenvalores son fundamentales en data science:

    Análisis de Componentes Principales (PCA)

    • Qué hace: Reduce dimensiones de un dataset encontrando los eigenvectores de la matriz de covarianza.
    • Ejemplo: Dataset Iris (150×4) → eigenvectores indican las direcciones de mayor variación (ej: longitud vs ancho de pétalo).

    Redes Neuronales

    • Eigenvectores optimizan transformaciones en capas de redes profundas.
    • Ejemplo: Ajustar pesos para maximizar patrones.

    Procesamiento de Imágenes

    • Eigenvectores en eigenfaces identifican características faciales clave.
    • Ejemplo: Reconocimiento facial en apps de seguridad.

    Sistemas Dinámicos

    • Modelan cómo cambian datos con el tiempo (ej: predicciones financieras).
    • Eigenvalores determinan la estabilidad de los sistemas.

    Historia real: En 2024, Spotify usó eigenvectores en su sistema de recomendaciones para identificar patrones en gustos musicales, mejorando la precisión en un 10%.

    Cómo encontrar los Eigenvalues y Eigenvectors

    Para cualquier matriz \(M\):

    1. Primero encontramos todos los eigenvalores λ.
    2. Luego, usando esos eigenvalores, encontramos los eigenvectores correspondientes.

    La ecuación base \(M \vec{v} = \lambda \cdot \vec{v}\) será la clave de todo.

    Pero para trabajar con ella algebraicamente, vamos a transformarla un poco.

    La matriz identidad

    Necesitamos la matriz especial llamada la matriz identidad, que se denota por \(I\). La matriz identidad es una matriz cuadrada con unos en la diagonal principal (de arriba a la izquierda hasta abajo a la derecha) y ceros en todas las demás posiciones. Ya la vimos como ejemplo anteriormente en el articulo de las matrices.

    Por ejemplo, la matriz identidad de tamaño 3×3 es:

    $$I = \begin{bmatrix} 1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1\end{bmatrix}$$

    Y se llama “identidad” porque, al multiplicarla por cualquier matriz o vector, el resultado es exactamente el mismo.

    Podemos decir que: \(I \cdot M = M\) y tambien que: \(I \cdot v = v\)

    Manipulamos la ecuación para llegar al sistema característico

    Volvamos a nuestra ecuación:

    $$M \vec{v} = \lambda \cdot \vec{v}$$

    Podemos escribir el lado derecho como \(\lambda I \cdot v\), ya que \(I \cdot v.\).

    Entonces la ecuación queda así:

    $$M \vec{v} = \lambda I \cdot \vec{v}$$

    Restamos el término del lado derecho en ambos lados:

    $$M \cdot \vec{v} \ – \lambda I \cdot \vec{v} = 0 $$

    Sacamos vvv como factor común (como si fuera un número):

    $$(M \ – \lambda I) \cdot \vec{v} = 0 $$

    Y esta ecuación es fundamental: se conoce como la ecuación característica.


    La condición de existencia de eigenvectores

    Esta ecuación tiene dos tipos de soluciones posibles:

    1. La trivial, cuando \(v=0\).
      Pero ese vector no nos dice nada (no tiene dirección ni longitud), así que lo descartamos.
    2. La no trivial, cuando \(v≠0\).
      Para que exista esta solución, debe cumplirse una condición especial.

    Recuerda una propiedad del álgebra lineal:

    Una ecuación de la forma \(A \cdot v=0\) solo tiene una solución no trivial \(v≠0\) si la matriz A es singular, es decir, su determinante es igual a cero.

    Aplicando esto a nuestra ecuación \((M \ – \lambda I) \cdot \vec{v} = 0 \), la condición será: \(det(M \ – \lambda I) \cdot \vec{v} = 0 \)

    Esta ecuación nos permitirá encontrar los valores de \( \lambda \), los eigenvalores.


    Interpretación geométrica: el área que se hace cero

    Detrás de todo esto hay una idea visual muy poderosa.

    Imagina que tienes una matriz \(M\) que transforma puntos del plano \(XY\). Puedes representarla como una transformación del cuadrado unitario (un cuadrado de lado 1 anclado en el origen).

    Cuando multiplicas \(M\) por las coordenadas de los vértices de ese cuadrado, obtienes un nuevo cuadrilátero. En general, este nuevo cuadrilátero es un paralelogramo.

    • Si \(M\) solo escala el cuadrado, obtienes un rectángulo.
    • Si además deforma el cuadrado (por ejemplo, en un cizallamiento), obtienes un paralelogramo inclinado.

    El área de ese paralelogramo es una medida de cuánto “estira” o “encoge” la transformación de \(M\).
    Y el determinante de la matriz está directamente relacionado con esa área.

    Cuando el determinante es cero, significa que la transformación ha colapsado el plano en una línea o un punto, es decir, ha perdido una dimensión. Eso ocurre exactamente cuando estamos en un eigenvalor, porque en ese caso el espacio queda “aplastado” en una dirección particular: la del eigenvector.


    Ejemplo visual con una matriz 2×2

    Imaginemos una matriz genérica \(M\) de 2×2:

    $$M = \begin{bmatrix} a & b \\ c & d \end{bmatrix}$$

    Y tomemos el cuadrado unitario cuyos vértices son (0,0), (1,0), (1,1) y (0,1).

    Cuando aplicamos \(M\) sobre esos puntos, el cuadrado se transforma en un paralelogramo cuyos vértices vienen dados por los productos matriciales:

    $$M \cdot S$$

    donde \(S\) contiene las coordenadas de los vértices del cuadrado.
    El área de ese nuevo paralelogramo se puede calcular directamente como:

    $$\text{Área} = ad – bc$$

    que es precisamente el determinante de \(M\).

    Así que cuando el determinante \(ad−bc=0\), el paralelogramo “se aplasta” y pierde área. Geométricamente, eso es lo que ocurre cuando hay un eigenvalor: la transformación ya no conserva el área y “colapsa” el espacio en una dirección.


    Cálculo con Python: encontrar los eigenvalores

    Ejemplo con matriz 2×2.

    $$M = \begin{bmatrix} 2 & 1 \\ 1 & 2 \end{bmatrix}$$

    M = np.array([[2, 1],
                  [1, 2]])

    Calculamos eigenvalores y eigenvectores

    eigenvalores, eigenvectores = np.linalg.eig(M)
    
    print("Matriz M:")
    print(M)
    
    print("\nEigenvalores:")
    print(eigenvalores)
    
    print("\nEigenvectores (por columnas):")
    print(eigenvectores)
    Eigenvalores:
    [1.38196601 3.61803399]
    
    Eigenvectores (por columnas):
    [[-0.85065081 -0.52573111]
     [ 0.52573111 -0.85065081]]

    Ejemplo con matriz 3×3.

    M3 = np.array([
        [4, -2, 1],
        [0, 3, -1],
        [0, 0, 2]
    ])
    
    eigenvalores3, eigenvectores3 = np.linalg.eig(M3)
    
    print("Matriz M3:")
    print(M3)
    
    print("\nEigenvalores:")
    print(eigenvalores3)
    
    print("\nEigenvectores (por columnas):")
    print(eigenvectores3)
    Matriz M3:
    [[ 4 -2  1]
     [ 0  3 -1]
     [ 0  0  2]]
    
    Eigenvalores:
    [4. 3. 2.]
    
    Eigenvectores (por columnas):
    [[1.         0.89442719 0.33333333]
     [0.         0.4472136  0.66666667]
     [0.         0.         0.66666667]]

  • Matrices: la estructura fundamental de los datos

    ¿Qué es una matriz?

    Si los vectores son puntos en un mapa, las matrices son el mapa completo: Una matriz es una cuadrícula de números organizada en filas y columnas. Puedes pensarla como un conjunto de vectores fila o vectores columna, dependiendo del caso.

    Matemáticamente, se escribe como un conjunto rectangular de números:

    $$ A = \begin{bmatrix} 1 & 2 & 3 \\ 4 & 5 & 6 \\ 7 & 8 & 9 \end{bmatrix} $$

    Aquí la matriz \(A\) tiene 3 filas y 3 columnas, por lo tanto, su dimensión es \(3 \times 3\). Cada número dentro de la matriz se llama elemento, y se identifica por su posición:
    \(a_{ij}\) es el elemento que está en la fila i y la columna j.

    • Filas: 3 (cada una es un vector: \( [1, 2, 3], [4, 5, 6], [7, 8, 9]\))
    • Columnas: 3 (cada una es un vector: \([1, 4, 7], [2, 5, 8], [3, 6, 9]\))
    • Dimensión: \(3×3\) (filas x columnas)

    Dimensiones

    • Scalar

    $$a = 1$$

    • 1D Vector

    $$\vec{v} = \begin{bmatrix}1 \\ 2 \end{bmatrix}$$

    • 2D Matriz

    $$A = \begin{bmatrix}1 & 2 \\ 3 & 4 \end{bmatrix}$$

    • 3D Tensor

    $$T_{ijk} = \begin{bmatrix}[1 & 2] & [3 & 4] \\ [5 & 6] & [7 & 8]\end{bmatrix}$$

    Tipos de matrices

    • Matriz cuadrada: tiene el mismo número de filas y columnas \( (n \times n) \).
    • Matriz fila: una sola fila.
    • Matriz columna: una sola columna.
    • Matriz identidad: tiene 1 en la diagonal principal y 0 en el resto.
    • Matriz nula: todos los elementos son 0.

    La matriz identidad, por ejemplo, es clave porque actúa como el “1” de la multiplicación matricial:

    $$I = \begin{bmatrix} 1 & 0 \\ 0 & 1 \end{bmatrix} \quad \Rightarrow \quad A \cdot I = A$$

    Matrices como datos

    En ciencia de datos, todo lo que analizamos puede representarse con matrices:

    • Un dataset es una matriz donde cada fila es una observación y cada columna una variable.
    • Una imagen es una matriz de píxeles, y si es en color, es una matriz 3D , también llamado Tensor.
    • Una serie temporal puede representarse como una matriz con las variables en columnas y el tiempo en filas.

    Por ejemplo, una imagen en blanco y negro de 3×3 se puede representar así:

    $$ I =\begin{bmatrix}0 & 255 & 0 \\ 255 & 0 & 255 \\ 0 & 255 & 0\end{bmatrix}$$

    donde cada número representa la intensidad del color.

    Matrices como funciones

    También llamada Matrices Transformadoras, son matrices que actuan como una función que transforma datos.

    Una transformación lineal es una función que toma vectores como entrada y devuelve otros vectores como salida. Las transformaciones lineales pueden:

    • Estirar o encoger figuras (cambio de escala)
    • Girarlas (rotación)
    • Reflejarlas (simetría)
    • Aplanarlas (proyección)
    • Combinarlas (rotar + escalar, por ejemplo)

    Pero no pueden doblar, curvar, ni mover los puntos de forma no proporcional (eso sería una transformación no lineal).

    Por ejemplo, en geometría o visión por computador, una matriz de rotación de un ángulo \((\theta)\) es:

    $$R(\theta) = \begin{bmatrix}\cos \theta & -\sin \theta \\ sin \theta & \cos \theta \end{bmatrix}$$

    Aplicar esta matriz a un vector rota el punto alrededor del origen.

    Operaciones con Matrices

    Suma y resta de matrices

    Dos matrices se pueden sumar o restar solo si tienen el mismo tamaño. Se suman los elementos correspondientes:

    $$ A + B = \begin{bmatrix} a_11​+b_11 & a_12​+b_12​ \\ ​a_22​+b_22​​ & a_21​+b_21​​ \end{bmatrix}$$

    Multiplicación por un scalar

    Cada elemento de la matriz se multiplica por el número (escalar):

    $$ 2A = \begin{bmatrix} 2a_{11} & 2a_{12}​ \\ ​2a_{22}​​​ & 2a_{21​​​} \end{bmatrix}$$

    Producto de matrices

    El producto \(A \times B\) no se hace elemento a elemento. Se multiplica cada fila de \(A \) por cada columna de \(\)B \(\), y se suman los productos.

    $$(A \times B)_{ij} = \begin{bmatrix} 1 & 2 \\ 3 & 4 \end{bmatrix} \begin{bmatrix} 5 & 6 \\ 7 & 8 \end{bmatrix}$$

    $$ = \begin{bmatrix} 1 \cdot 5 + 2 \cdot 7 & 1 \cdot 6 + 2 \cdot 8 \\ 3 \cdot 5 + 4 \cdot 7 & 3 \cdot 6 + 4 \cdot 8\end{bmatrix} $$

    $$ = \begin{bmatrix} 19 & 22 \\ 43 & 50 \end{bmatrix} $$

    Traspuesta de una matriz

    Se obtiene intercambiando filas por columnas:

    $$ A = \begin{bmatrix} 1 & 2 \\ 3 & 4 \end{bmatrix} $$

    $$ A^T= \begin{bmatrix} 1 & 3 \\ 2 & 4 \end{bmatrix} $$

    Matriz identidad

    $$I = \begin{bmatrix} 1 & 0 \\ 0 & 1 \end{bmatrix} \quad \Rightarrow \quad A \cdot I = A$$


    Operaciones de Matrices con Python

    • Crear matrices con funciones convenientes, Numpy ofrece varias funciones para crear matrices comunes rapidamente:
    A = np.ones((3, 4))   # Matriz 3x4 llena de unos
    B = np.zeros((3, 3))  # Matriz 3x3 llena de ceros
    C = np.ones((2, 2)) * 4  # Matriz 2x2 llena de cuatros
    
    print("A:\n", A)
    print("B:\n", B)
    print("C:\n", C)
    A:
     [[1. 1. 1. 1.]
     [1. 1. 1. 1.]
     [1. 1. 1. 1.]]
    B:
     [[0. 0. 0.]
     [0. 0. 0.]
     [0. 0. 0.]]
    C:
     [[4. 4.]
     [4. 4.]]
    • Propiedad .shape: conocer las dimensiones de la matriz
    print(A.shape)
    (3, 4)
    • Indexación: acceder a elementos, fila y columnas
    M = np.array([[1, 2, 3],
                  [4, 5, 6]
                  [7, 8, 9]])
                  
    valor = M[4, 5]  # valor en la fila 5, columna 6 (Python indexa desde 0)
    fila = M[1, :]  # acceder a una fila completa
    columna = M[:, 2]  # acceder a una columna completa
    
    print(valor)
    print(fila)
    print(columna)
    6
    [4 5 6]
    [3 6 9]
    • Suma y resta de matrices
    C = A + B
    D = B - A
    • Multiplicación por escalar
    E = 3 * A
    • Producto de matrices
    C = A @ B
    # tambien se puede usar:
    np.dot(A, B)
    • Transpuesta de una matriz
    print("A^T =\n", A.T)
    • Matriz identidad
    I = np.eye(2)
    print("Matriz identidad:\n", I)
    
    print("A @ I =\n", A @ I)
    • Determinante y matriz inversa
    det_A = np.linalg.det(A)
    inv_A = np.linalg.inv(A)

    6. En resumen

    • Las matrices son la base del álgebra lineal y de los modelos de datos.
    • En Machine Learning, cada conjunto de entrenamiento es una gran matriz.
    • En visión por computador, las imágenes son matrices.
    • En análisis estadístico, las transformaciones de los datos se hacen con multiplicaciones matriciales.

    Por eso, entender cómo funcionan es esencial: todo modelo, por complejo que parezca, se reduce a operaciones con vectores y matrices.

  • Vectores: la brújula del álgebra lineal y la ciencia de datos

    Imagina que los datos son como puntos en un mapa. Un vector es la flecha que describe dónde está ese punto y cómo llegar a él. En data science, los vectores son la forma más básica y poderosa de representar datos, desde características de un cliente hasta píxeles en una imagen.

    El vector es el elemento fundamental y raíz de toda el algebra lineal.

    Los vectores no son solo un concepto matemático para escribir ecuaciones de forma concisa.
    También son herramientas fundamentales para codificar información compleja, desde posiciones y velocidades hasta fuerzas y movimientos en varias dimensiones.


    ¿Qué es un vector?

    Más allá de ser una lista ordenada de números, un vector puede pensarse como: cualquier cosa que tenga una dirección y una magnitud.

    Es una lista ordenada de números que describe una posición o característica en un espacio. En data science, cada vector representa un punto de datos y cada fila de tu dataset es un vector.

    Esta definición es la que usan los físicos. Por ejemplo:

    • Dirección: hacia dónde apunta el vector.
    • Magnitud: qué tan grande es, también llamada norma del vector.

    Ejemplos

    Supongamos que describes a una persona por su edad y salario:

    • Vector: \([25, 50000]\)
      • 25: Edad (en años)
      • 50000: Salario (en euros)

    Visualmente:

    • Un vector es una flecha en un plano:
      • Origen: \((0,0)\)
      • Punta: \((25, 50000)\)
    • En 2D, se ve como una línea desde el origen al punto.

    Dimensiones

    • 2D: \([x, y]\) (ej: edad, salario)
    • 3D: \([x, y, z]\) (ej: edad, salario, experiencia)
    • n-D: \([x₁, x₂, …, xₙ]\) (datasets con muchas columnas)

    De la Ecuación al Movimiento

    Imaginemos una pelota lanzada desde el origen que en términos de vectores seria la posición \((0,0)\) en un espacio bidimensional. La posición de la pelota en cada instante se puede codificar como un vector \( \mathbf{p} = (p_1, p_2) \), donde:

    • \(p_1 = 5\) representa la posición horizontal \(x\)
    • \(p_2 = 4\) representa la posición vertical \(y\).

    Así, en lugar de seguir las coordenadas de los ejes por separado, podemos usar un solo vector para describir la posición de la pelota.

    $$ \vec{p} = \begin{bmatrix}5\\4\end{bmatrix}$$

    Si representamos \(\vec{p}\)​ en un plano cartesiano, se vería como una flecha que parte del origen (0,0) y termina en (5,4). La flecha tiene una dirección (hacia dónde apunta) y una longitud, que nos dice qué tan lejos está el punto final del origen. Para graficar podemos utilizar ax.arrow() en Matplotlib.

    Código de la grafica

    Código en Python Matplotlib

    import matplotlib.pyplot as plt
    
    # Crear figura y ejes
    fig, ax = plt.subplots(figsize=(8, 8))
    
    # Dibujar el vector desde (0,0) hasta (5,4)
    ax.arrow(0, 0, 5, 4, head_width=0.3, head_length=0.4, fc='blue', ec='blue', linewidth=2)
    
    # Marcar el punto final del vector
    ax.plot(5, 4, 'o', markersize=6, color='blue')
    ax.plot(0, 0, 'o', markersize=6, color='blue')
    ax.text(5.6, 4, r"$\vec{v} = [5,\, 4]$", fontsize=14, color='blue')
    
    # Ejes centrados
    ax.spines['left'].set_position('zero')
    ax.spines['bottom'].set_position('zero')
    
    # Quitar bordes superior y derecho
    ax.spines['top'].set_visible(False)
    ax.spines['right'].set_visible(False)
    
    # Color y grosor de los ejes
    for spine in ['left', 'bottom']:
        ax.spines[spine].set_color('gray')
        ax.spines[spine].set_linewidth(1)
    
    # Límites y cuadrícula
    ax.set_xlim(-6, 8)
    ax.set_ylim(-6, 8)
    ax.grid(False)
    
    # Tamaño de los números de los ejes
    ax.tick_params(axis='both', which='major', labelsize=10)
    
    # Etiquetas y título
    ax.set_xlabel(r"$x$", fontsize=14, loc="right")
    ax.set_ylabel(r"$y$", fontsize=14, loc="top", rotation=0)
    ax.set_title("Vector", pad=20)
    
    # Guardar y mostrar
    plt.savefig("vector.png", transparent=True, dpi=300)
    plt.show()
    

    La norma (longitud del vector): cuánto ha viajado la pelota

    Esa longitud, también llamada norma, nos dice qué tan grande es el vector.
    Se denota con dos barras verticales, así: \( ||\mathbf{p}|| \) Para saber qué tan lejos está la pelota desde el origen, usamos la norma del vector:

    $$||\mathbf{p}|| = \sqrt{p_1^2 + p_2^2}$$

    Esta ecuación se deriva directamente del teorema de Pitágoras: la hipotenusa de un triángulo rectángulo es la raíz cuadrada de la suma de los cuadrados de sus catetos. Por ejemplo, si \(p_1 = 5\) y \(p_2 = 4\), la norma es:

    $$||\mathbf{p}|| = \sqrt{5^2 + 4^2} \approx 6.40$$

    La norma siempre da como resultado un número positivo: la distancia desde el origen hasta el punto final del vector.

    Vectores en dimensiones superiores

    Si la pelota se moviera en un espacio tridimensional, solo agregamos un componente más:

    $$\mathbf{p} = (p_1, p_2, p_3), \quad $$

    $$||\mathbf{p}|| = \sqrt{p_1^2 + p_2^2 + p_3^2}$$

    Y si tuviéramos un vector en \(N\) dimensiones, simplemente añadimos cada componente al cálculo de la norma:

    $$||\mathbf{p}|| = \sqrt{p_1^2 + p_2^2 + \dots + p_N^2}$$

    Esto hace que los vectores sean muy poderosos para manejar información compleja de manera compacta.

    Aplicaciones de los vectores en física

    Los vectores nos permiten representar de manera eficiente:

    • Posición: dónde se encuentra un objeto.
    • Velocidad: dirección y rapidez del movimiento.
    • Fuerza: hacia dónde actúa y cuán intensa es.

    Además, con operaciones como suma, resta, multiplicación por escalar o producto punto, podemos combinar vectores y calcular efectos resultantes de manera simple.

    Por ejemplo, en nuestra pelota de béisbol, un vector nos permite:

    • Conocer simultáneamente su posición en \(x\) y \( y\) ,
    • Medir su distancia desde el punto de lanzamiento con la norma,
    • Y si quisiéramos incluir velocidad o aceleración, usar vectores de mayor dimensión para mantener todo compacto y manejable.

    Dos propiedades clave de un vector

    1. Dirección: hacia dónde apunta.
    2. Magnitud: cuán grande es, calculable con la norma.

    En cualquier número de dimensiones, esta regla sigue siendo válida, lo que convierte a los vectores en herramientas universales para describir información física y multidimensional.

    Operaciones con Vectores

    Los vectores son poderosos porque puedes operarlos para descubrir patrones. Aquí las operaciones más importantes:

    Suma de Vectores

    si tenemos dos vectores de la misma dimensión:

    $$ \vec{u} = \begin{bmatrix}u_1\\u_2\\u_3\end{bmatrix}, \vec{v} = \begin{bmatrix}v_1\\v_2\\v_3\end{bmatrix}$$

    La suma es simplemente sumar cada componente correspondiente:

    $$ \vec{u} + \vec{v}= \begin{bmatrix}u_1+v_1\\u_2+v_2\\u_3+v_3\end{bmatrix}$$

    Esto es útil porque cuando sumamos vectores estamos combinando información de manera ordenada, igual que antes combinábamos cantidades de manzanas, naranjas y pan. La suma de vectores es la primera forma de “agrupar información” en un vector.

    Multiplicación por Escalar

    Si tenemos un número \(k\) y un vector \(\vec{v}\), multiplicamos cada componente por ese número:

    $$ k \cdot \vec{v}= k \cdot \begin{bmatrix}v_1\\v_2\\v_3\end{bmatrix} = \begin{bmatrix}kv_1\\kv_2\\kv_3\end{bmatrix}$$

    Esto sirve para escalar vectores, como cuando queremos “duplicar” o “reducir” una cantidad.

    Producto Escalar (Dot Product)

    Dot Product: Mide la similitud entre dos vectores.

    El producto escalar es una operación entre dos vectores que produce un número, a diferencia de la suma o resta de vectores, que produce otro vector.

    Si tenemos dos vectores de la misma dimensión:

    $$ \vec{a} = \begin{bmatrix}a_1\\a_2\\.\\.\\.\\a_n\end{bmatrix}, \vec{b} = \begin{bmatrix}b_1\\b_2\\.\\.\\.\\b_n\end{bmatrix}$$

    el producto punto se define como:

    $$ \vec{a} \cdot \vec{b} = a_1b_1 + a_2b_2 + . . . + a_nb_n$$

    O, lo que es lo mismo:

    $$ \vec{a} \cdot \vec{b} = \sum ^{n} _ {i=1} a_ib_i$$

    Cada componente se multiplica componente por componente, y luego se suman los resultados.

    Ejemplo:

    Supongamos que tienes un presupuesto de $30 y quieres comprar: manzanas, naranjas y peras.

    Definimos:

    • Vector de cantidades compradas

    $$ \vec{g} = \begin{bmatrix}g_1\\g_2\\g_3\end{bmatrix} = \begin{bmatrix}4\\3\\2\end{bmatrix} $$

    • Vector de precios de productos:

    $$ \vec{c} = \begin{bmatrix}c_1\\c_2\\c_3\end{bmatrix} = \begin{bmatrix}2\\3\\5\end{bmatrix}$$

    Entonces, el total gastado se puede escribir como:

    $$ Total= \vec{c} \cdot \vec{g} $$

    $$ T= c_1g_1 + c_2g_2 + c_3g_3 $$

    $$ T = 2⋅4+3⋅3+5⋅2$$

    $$ T =8+9+10=27$$

    Interpretación geométrica

    Geométricamente, el producto punto mide cuánto se parecen o se alinean dos vectores en dirección:

    $$\vec{a} \cdot \vec{b} = ||\vec{a}|| ||\vec{b}||cos⁡(θ)$$

    • Si \(θ=0°\): los vectores están en la misma dirección → producto punto positivo y máximo.
    • Si \(θ=90°\): son perpendiculares → producto punto = 0.
    • Si \(θ>90°\): apuntan en direcciones opuestas → producto punto negativo.

    Esto significa que el producto punto mide cuánto “apuntan en la misma dirección” dos vectores.

    Usos del producto escalar el data science

    • Similitud de vectores (cosine similarity): En NLP, sistemas de recomendación o embeddings de palabras. Cuanto mayor sea este valor, más similares son los vectores.
    • Regresión lineal / Neuronas : Calcula la combinación lineal de las variables
    • Similitud del coseno : Mide cuánto se parecen dos vectores
    • PCA / Proyecciones : Proyecta un vector sobre una dirección
    • Distancias : Base para métricas vectoriales
    • Álgebra de matrices : Operación elemental en multiplicación de matrices

    Operaciones de vectores con Python

    Los vectores en Python manejan con Numpy y se representan como listas:

    A = np.array([1, 2, 3, 4])
    B = np.arange(6, 10)

    Suma de vectores

    C = A + B
    print(C)

    Producto punto

    np.dot(A, B)

    Norma del vector

    np.linalg.norm(A)