0Pricing
Pandas & NumPy Academy · Lección

Determinantes, inversas y transpuestas

Calcule determinantes de matrices con np.linalg.det, inversas con np.linalg.inv y transpuestas con .T.

Determinantes, inversas y transpuestas es una lección gratuita de Pandas & NumPy Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Pandas & NumPy Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Pandas & NumPy Academy incluye 4 lecciones en total.

La transpuesta de una matriz

La transpuesta de una matriz la voltea sobre su diagonal: las filas se convierten en columnas y las columnas, en filas. Si A tiene dimensión (m, n), entonces A.T tiene dimensión (n, m). Las transpuestas aparecen en todas partes del álgebra lineal: al calcular matrices de covarianza, implementar la retropropagación del gradiente y convertir entre las convenciones de vector fila y vector columna. NumPy accede a la transpuesta mediante el atributo .T; no se realiza ninguna copia, sino que se trata simplemente de una vista con los strides reordenados.

import numpy as np

A = np.array([[1, 2, 3],
              [4, 5, 6]])
print('A shape:', A.shape)       # (2, 3)
print('A.T shape:', A.T.shape)   # (3, 2)
print(A.T)

La transpuesta en la práctica

Un patrón frecuente es calcular A.T @ A, lo que produce una matriz cuadrada simétrica que aparece en la regresión por mínimos cuadrados, el PCA y las ecuaciones normales. Si A tiene dimensión (n, p), entonces A.T @ A tiene dimensión (p, p). El resultado siempre es simétrico porque (A.T @ A)[i,j] == (A.T @ A)[j,i]. Muchos solucionadores numéricos aprovechan esta propiedad para mejorar la eficiencia.

import numpy as np

A = np.array([[1.0, 2.0],
              [3.0, 4.0],
              [5.0, 6.0]])  # shape (3, 2)

ATA = A.T @ A   # shape (2, 2), symmetric
print('A.T @ A:')
print(ATA)
print('Is symmetric:', np.allclose(ATA, ATA.T))

El determinante: qué significa

El determinante de una matriz cuadrada es un valor escalar que contiene información geométrica: mide el factor por el que la matriz escala las áreas (en 2D) o los volúmenes (en dimensiones superiores). Un determinante igual a cero significa que la matriz es singular: colapsa el espacio sobre un subespacio de menor dimensión y no tiene inversa. Un determinante distinto de cero garantiza que la matriz es invertible. NumPy lo calcula con np.linalg.det().

import numpy as np

# Non-singular matrix
A = np.array([[3.0, 1.0],
              [2.0, 4.0]])
print('det(A):', np.linalg.det(A))   # 3*4 - 1*2 = 10

# Singular matrix (row 2 = 2 * row 1)
B = np.array([[1.0, 2.0],
              [2.0, 4.0]])
print('det(B):', np.linalg.det(B))   # ~0

Calcular la inversa con np.linalg.inv()

La inversa de una matriz A, escrita como A⁻¹, cumple A @ A⁻¹ = I, donde I es la matriz identidad. Las inversas solo existen para matrices cuadradas y no singulares. np.linalg.inv(A) calcula la inversa numéricamente. En la práctica, rara vez debería calcular las inversas de forma explícita, porque es numéricamente inestable; en su lugar, prefiera np.linalg.solve() para resolver sistemas de ecuaciones. Sin embargo, comprender conceptualmente las inversas es fundamental.

import numpy as np

A = np.array([[3.0, 1.0],
              [2.0, 4.0]])

A_inv = np.linalg.inv(A)
print('Inverse:')
print(A_inv)

# Verify: A @ A_inv should be identity
I = A @ A_inv
print('A @ A_inv (should be I):')
print(np.round(I, 10))

Inestabilidad numérica de la inversión directa

Calcular la inversa de una matriz y después multiplicarla introduce errores de coma flotante que se acumulan. Por ejemplo, resolver A_inv @ b es menos preciso que llamar directamente a np.linalg.solve(A, b). Una matriz bien condicionada (cuyo determinante está lejos de cero) es menos sensible a estos errores. El número de condición (np.linalg.cond(A)) cuantifica lo cerca que está una matriz de ser singular; los números de condición altos indican problemas numéricos.

import numpy as np

A = np.array([[1.0, 2.0],
              [1.0001, 2.0]])
print('Condition number:', np.linalg.cond(A))
# Very high condition number -> near-singular, unstable inversion

b = np.array([3.0, 3.0001])
# Prefer solve over inv @ b
print('Solution via solve:', np.linalg.solve(A, b))

Matrices ortogonales y sus transpuestas

Una clase especial de matrices son las matrices ortogonales, para las que A.T @ A = I. Esto significa que la transpuesta ES la inversa, por lo que las matrices ortogonales son extremadamente fáciles de invertir. Las matrices de rotación y el factor Q de la descomposición QR son ortogonales. Las columnas de una matriz ortogonal forman una base ortonormal: cada columna tiene longitud unitaria y es perpendicular a todas las demás.

import numpy as np

# 90-degree rotation matrix is orthogonal
theta = np.pi / 2
R = np.array([[np.cos(theta), -np.sin(theta)],
              [np.sin(theta),  np.cos(theta)]])

print('R.T @ R (should be identity):')
print(np.round(R.T @ R, 10))
print('Is orthogonal:', np.allclose(R.T @ R, np.eye(2)))

La pseudoinversa para matrices no cuadradas

Una inversa convencional solo existe para matrices cuadradas, pero la pseudoinversa de Moore-Penrose generaliza la inversión a cualquier matriz. np.linalg.pinv(A) la calcula mediante SVD. Es la base de la solución de mínimos cuadrados para sistemas sobredeterminados (con más ecuaciones que incógnitas), que es exactamente lo que resuelve la regresión lineal. Si A es cuadrada e invertible, pinv(A) es igual a inv(A).

import numpy as np

# Over-determined system: 3 equations, 2 unknowns
A = np.array([[1.0, 1.0],
              [1.0, 2.0],
              [1.0, 3.0]])
b = np.array([2.0, 3.0, 5.0])

# Least-squares solution using pseudo-inverse
x = np.linalg.pinv(A) @ b
print('Best-fit solution:', x)
# Or use lstsq directly
x2, _, _, _ = np.linalg.lstsq(A, b, rcond=None)
print('lstsq solution:', x2)

El signo del determinante y la escala del volumen

El signo del determinante indica si la transformación conserva o invierte la orientación. Un determinante positivo significa que se conserva la orientación (como en una rotación); uno negativo significa que la orientación se invierte (como en una reflexión). El valor absoluto proporciona el factor de escala del volumen. Para una matriz 2×2 [[a,b],[c,d]], det = a*d - b*c. NumPy gestiona eficazmente matrices cuadradas de cualquier tamaño.

import numpy as np

# Identity: det = 1 (no scaling, no flip)
I = np.eye(3)
print('det(I):', np.linalg.det(I))    # 1.0

# Scaling by 2 in all directions: det = 8 = 2^3
S = 2 * np.eye(3)
print('det(2I):', np.linalg.det(S))   # 8.0

# Reflection: det = -1
F = np.array([[-1.0, 0.0],
              [ 0.0, 1.0]])
print('det(reflection):', np.linalg.det(F))

Usar np.linalg.slogdet() para obtener estabilidad

En matrices grandes, el determinante puede desbordarse o reducirse por debajo del rango hasta convertirse en cero, incluso cuando la matriz no es singular. np.linalg.slogdet(A) devuelve (sign, log_abs_det): el signo y el logaritmo natural del determinante absoluto, lo que evita el desbordamiento numérico. Se utiliza ampliamente en modelos probabilísticos (verosimilitudes gaussianas), donde se trabaja en el espacio logarítmico para mantener los números dentro de un rango manejable.

import numpy as np

A = np.random.rand(100, 100)

# Direct det might underflow for large matrices
sign, logdet = np.linalg.slogdet(A)
print('Sign:', sign)
print('Log|det|:', logdet)
print('Actual det (may be ~0 due to float):', np.linalg.det(A))
print('Reconstructed |det|:', np.exp(logdet))

Práctica: resolver una matriz 2x2 a mano frente a NumPy

Para una matriz 2×2 [[a, b], [c, d]], la inversa es (1/det) * [[d, -b], [-c, a]], donde det = ad - bc. Conocer esta fórmula le ayuda a comprobar rápidamente el resultado de NumPy. Para matrices mayores, calcular la inversa analíticamente no es práctico; precisamente por eso usamos np.linalg.inv(). Verifique siempre los resultados numéricos con np.allclose(A @ A_inv, np.eye(n)).

import numpy as np

a, b, c, d = 3.0, 1.0, 2.0, 4.0
A = np.array([[a, b], [c, d]])
det = a*d - b*c

# Manual inverse
A_inv_manual = (1/det) * np.array([[d, -b], [-c, a]])
print('Manual inv:')
print(A_inv_manual)

# NumPy inverse
print('np.linalg.inv:')
print(np.linalg.inv(A))
print('Match:', np.allclose(A_inv_manual, np.linalg.inv(A)))

Combinar la transpuesta y la inversa en procesos

Un patrón habitual del álgebra lineal combina la transpuesta y la inversa: calcular (A.T @ A)⁻¹ @ A.T proporciona la matriz de proyección utilizada en los mínimos cuadrados ordinarios. En NumPy, esto se puede escribir como np.linalg.inv(A.T @ A) @ A.T, pero, una vez más, np.linalg.lstsq es numéricamente preferible. Conocer el patrón subyacente le ayuda a entender qué hace el solucionador y a depurar problemas cuando las matrices están cerca de ser singulares.

import numpy as np

# Design matrix for simple linear regression (with bias)
X = np.column_stack([np.ones(5), np.array([1., 2., 3., 4., 5.])])
y = np.array([2.1, 3.9, 6.2, 8.1, 9.8])

# OLS via normal equations: beta = (X.T @ X)^-1 @ X.T @ y
beta = np.linalg.inv(X.T @ X) @ X.T @ y
print('Coefficients (intercept, slope):', np.round(beta, 3))

# Verify with lstsq
beta2, _, _, _ = np.linalg.lstsq(X, y, rcond=None)
print('lstsq result:', np.round(beta2, 3))

Comprobación rápida

Compruebe sus conocimientos sobre los conceptos de análisis de datos de esta lección.

Resumen de la lección

En esta lección ha aprendido que A.T es la transpuesta que intercambia filas y columnas, que np.linalg.inv() calcula la inversa de una matriz, pero rara vez debería utilizarse directamente (prefiera solve o lstsq), y que np.linalg.det() devuelve el determinante, que es cero para las matrices singulares. A continuación exploraremos cómo resolver directamente sistemas lineales con np.linalg.solve.

Preguntas frecuentes

¿La lección «Determinantes, inversas y transpuestas» es gratis?

Sí — el texto completo de «Determinantes, inversas y transpuestas» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Pandas & NumPy Academy, actualiza a CoddyKit PRO. El curso de Pandas & NumPy Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Determinantes, inversas y transpuestas»?

Calcule determinantes de matrices con np.linalg.det, inversas con np.linalg.inv y transpuestas con .T. Practicas Pandas & NumPy Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Pandas & NumPy Academy?

No se requiere experiencia previa. Pandas & NumPy Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Determinantes, inversas y transpuestas»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Pandas & NumPy Academy?

Sí. Cada lección de Pandas & NumPy Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Multiplicación de matrices con np.matmul y @
  2. Determinantes, inversas y transpuestas
  3. Resolución de sistemas lineales
  4. Introducción a valores propios y SVD
← Volver a Pandas & NumPy Academy