0Pricing
Pandas & NumPy Academy · Aula

Determinantes, inversas e transpostas

Calcule determinantes de matrizes com np.linalg.det, inversas com np.linalg.inv e transpostas com .T.

Determinantes, inversas e transpostas é uma aula grátis de Pandas & NumPy Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Pandas & NumPy Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Pandas & NumPy Academy inclui 4 aulas no total.

A transposta de uma matriz

A transposta de uma matriz a inverte em relação à sua diagonal: as linhas tornam-se colunas e as colunas tornam-se linhas. Se A tiver dimensão (m, n), então A.T terá dimensão (n, m). As transpostas aparecem em toda parte na álgebra linear: no cálculo de matrizes de covariância, na implementação da retropropagação do gradiente e na conversão entre as convenções de vetor linha e vetor coluna. O NumPy acessa a transposta com o atributo .T — nenhuma cópia é criada; trata-se apenas de uma visualização com passos 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)

Transposta na prática

Um padrão frequente é calcular A.T @ A, que produz uma matriz quadrada simétrica presente na regressão por mínimos quadrados, na PCA e nas equações normais. Se A tiver dimensão (n, p), então A.T @ A terá dimensão (p, p). O resultado é sempre simétrico porque (A.T @ A)[i,j] == (A.T @ A)[j,i]. Muitos solucionadores numéricos aproveitam essa propriedade para obter mais eficiência.

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

O determinante: o que ele significa

O determinante de uma matriz quadrada é um valor escalar que codifica informações geométricas: ele mede o fator pelo qual a matriz amplia ou reduz áreas (em 2 dimensões) ou volumes (em dimensões superiores). Um determinante igual a zero significa que a matriz é singular — ela comprime o espaço em um subespaço de dimensão inferior e não tem inversa. Um determinante diferente de zero garante que a matriz é invertível. O NumPy calcula o determinante com 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

Calculando a inversa com np.linalg.inv()

A inversa de uma matriz A, escrita como A⁻¹, satisfaz A @ A⁻¹ = I, em que I é a matriz identidade. As inversas só existem para matrizes quadradas e não singulares. np.linalg.inv(A) calcula a inversa numericamente. Na prática, raramente você deve calcular inversas explicitamente, pois isso é numericamente instável; prefira np.linalg.solve() para sistemas de equações. No entanto, compreender as inversas conceitualmente é essencial.

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

Instabilidade numérica da inversão direta

Calcular a inversa de uma matriz e depois fazer uma multiplicação introduz erros de ponto flutuante que se acumulam. Por exemplo, resolver A_inv @ b é menos preciso do que chamar diretamente np.linalg.solve(A, b). Uma matriz bem condicionada (com determinante distante de zero) é menos sensível a esses erros. O número de condição (np.linalg.cond(A)) quantifica quão próxima uma matriz está de ser singular — números de condição altos indicam 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))

Matrizes ortogonais e suas transpostas

Uma classe especial de matrizes são as matrizes ortogonais, para as quais A.T @ A = I. Isso significa que a transposta IS a inversa, tornando as matrizes ortogonais extremamente fáceis de inverter. Matrizes de rotação e o fator Q da decomposição QR são ortogonais. As colunas de uma matriz ortogonal formam uma base ortonormal — cada coluna tem comprimento unitário e é perpendicular a todas as outras colunas.

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

A pseudoinversa para matrizes não quadradas

Uma inversa comum só existe para matrizes quadradas, mas a pseudoinversa de Moore-Penrose generaliza a inversão para qualquer matriz. np.linalg.pinv(A) calcula-a usando SVD. Ela é a base da solução de mínimos quadrados para sistemas sobredeterminados (com mais equações do que incógnitas), exatamente o que a regressão linear resolve. Se A for quadrada e invertível, pinv(A) será 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)

Sinal do determinante e escala de volume

O sinal do determinante indica se a transformação preserva ou inverte a orientação. Um determinante positivo significa que a orientação é preservada (como em uma rotação); um determinante negativo significa que a orientação é invertida (como em uma reflexão). O valor absoluto fornece o fator de escala do volume. Para uma matriz 2×2 [[a,b],[c,d]], det = a*d - b*c. O NumPy trata eficientemente matrizes quadradas de qualquer dimensã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))

Usando np.linalg.slogdet() para obter estabilidade

Para matrizes grandes, o determinante pode estourar ou sofrer subfluxo até chegar a zero, mesmo quando a matriz não é singular. np.linalg.slogdet(A) retorna (sign, log_abs_det) — o sinal e o logaritmo natural do determinante absoluto —, evitando o estouro numérico. Isso é amplamente usado em modelos probabilísticos (verossimilhanças gaussianas), nos quais se trabalha no espaço logarítmico para manter os números controláveis.

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ática: resolvendo 2x2 à mão e com NumPy

Para uma matriz 2×2 [[a, b], [c, d]], a inversa é (1/det) * [[d, -b], [-c, a]], em que det = ad - bc. Conhecer essa fórmula ajuda você a verificar pontualmente o resultado do NumPy. Para matrizes maiores, calcular a inversa analiticamente é impraticável — é precisamente por isso que usamos np.linalg.inv(). Sempre verifique os resultados numéricos com 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)))

Combinando transposta e inversa em pipelines

Um padrão comum de álgebra linear combina transposta e inversa: calcular (A.T @ A)⁻¹ @ A.T fornece a matriz de projeção usada nos mínimos quadrados ordinários. No NumPy, isso pode ser escrito como np.linalg.inv(A.T @ A) @ A.T, mas, novamente, np.linalg.lstsq é numericamente preferível. Conhecer o padrão subjacente ajuda você a entender o que o solucionador está fazendo e a depurar problemas quando as matrizes estão próximas 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))

Verificação rápida

Teste sua compreensão dos conceitos de análise de dados desta lição.

Recapitulação da lição

Nesta lição, você aprendeu que: A.T é a transposta que troca linhas e colunas, np.linalg.inv() calcula a inversa da matriz, mas raramente deve ser usado diretamente (prefira solve ou lstsq), e np.linalg.det() retorna o determinante, que é zero para matrizes singulares. A seguir, exploraremos a resolução direta de sistemas lineares com np.linalg.solve.

Perguntas Frequentes

A aula “Determinantes, inversas e transpostas” é grátis?

Sim — o texto completo de “Determinantes, inversas e transpostas” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Pandas & NumPy Academy, atualize para CoddyKit PRO. O curso de Pandas & NumPy Academy inclui 4 aulas no total.

O que vou aprender em “Determinantes, inversas e transpostas”?

Calcule determinantes de matrizes com np.linalg.det, inversas com np.linalg.inv e transpostas com .T. Você pratica Pandas & NumPy Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Pandas & NumPy Academy?

Nenhuma experiência prévia é necessária. Pandas & NumPy Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Determinantes, inversas e transpostas”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Pandas & NumPy Academy?

Sim. Cada aula de Pandas & NumPy Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Multiplicação de matrizes com np.matmul e @
  2. Determinantes, inversas e transpostas
  3. Resolução de sistemas lineares
  4. Visão geral de autovalores e SVD
← Voltar para Pandas & NumPy Academy