Visão geral de autovalores e SVD
Calcule autovalores e autovetores com np.linalg.eig e entenda como SVD fundamenta a redução de dimensionalidade do PCA.
Visão geral de autovalores e SVD é uma aula grátis de Pandas & NumPy Academy no CoddyKit. Esta é a aula 4 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.
O que são autovalores e autovetores?
Um autovetor de uma matriz quadrada A é um vetor não nulo v tal que A @ v = lambda * v — multiplicar por A apenas redimensiona v; não altera sua direção. O escalar lambda é chamado de autovalor correspondente a v. Os autovalores revelam os “fatores de alongamento” intrínsecos de uma transformação linear: um autovalor igual a 2 significa que a matriz duplica os comprimentos na direção do autovetor; um autovalor negativo inverte a direção.
import numpy as np
A = np.array([[3.0, 1.0],
[0.0, 2.0]])
eigenvalues, eigenvectors = np.linalg.eig(A)
print('Eigenvalues:', eigenvalues)
print('Eigenvectors (columns):')
print(eigenvectors)Calculando autovalores com np.linalg.eig()
np.linalg.eig(A) retorna uma tupla (eigenvalues, eigenvectors). Os autovalores são um vetor 1-D; os autovetores são uma matriz 2-D em que cada coluna é um autovetor. Para matrizes simétricas reais, como matrizes de covariância, os autovalores são sempre reais e os autovetores são ortogonais — use np.linalg.eigh(A) para matrizes simétricas, pois essa função é mais rápida e garante resultados reais.
import numpy as np
# Symmetric matrix -> use eigh for efficiency and real eigenvalues
A = np.array([[4.0, 2.0],
[2.0, 3.0]])
vals, vecs = np.linalg.eigh(A)
print('Eigenvalues (real):', vals)
print('Eigenvectors (orthonormal columns):')
print(vecs)
# Verify: A @ v = lambda * v for each eigenvector
for i in range(len(vals)):
lhs = A @ vecs[:, i]
rhs = vals[i] * vecs[:, i]
print(f'v{i} check:', np.allclose(lhs, rhs))Autovalores e propriedades das matrizes
Os autovalores codificam propriedades importantes das matrizes. O determinante é igual ao produto de todos os autovalores: det(A) = product(eigenvalues). O traço (soma dos elementos diagonais) é igual à soma dos autovalores: trace(A) = sum(eigenvalues). Uma matriz é positiva definida (todos os autovalores > 0) somente se todos os autovalores forem positivos — uma propriedade essencial para matrizes de covariância válidas e problemas de otimização convexa.
import numpy as np
A = np.array([[4.0, 2.0],
[2.0, 3.0]])
vals, _ = np.linalg.eigh(A)
print('Eigenvalues:', vals)
print('Product (should = det):', np.prod(vals))
print('np.linalg.det:', np.linalg.det(A))
print('Sum (should = trace):', np.sum(vals))
print('np.trace:', np.trace(A))
print('Positive definite:', np.all(vals > 0))Visão geral da decomposição em valores singulares (SVD)
A decomposição em valores singulares (SVD) decompõe qualquer matriz A, e não apenas matrizes quadradas, como A = U @ S @ V.T, em que U e V são matrizes ortogonais e S é diagonal, com valores singulares não negativos na diagonal. O SVD é a fatoração de matrizes mais geral e numericamente estável. Ele fundamenta o PCA, a compressão de imagens, os sistemas de recomendação e o cálculo da pseudoinversa. np.linalg.svd(A) retorna U, s (valores singulares 1-D) e Vh (V transposta).
import numpy as np
A = np.array([[1.0, 2.0, 3.0],
[4.0, 5.0, 6.0]])
U, s, Vh = np.linalg.svd(A, full_matrices=False)
print('U shape:', U.shape)
print('s (singular values):', s)
print('Vh shape:', Vh.shape)
# Reconstruct A
A_reconstructed = U @ np.diag(s) @ Vh
print('Reconstruction correct:', np.allclose(A, A_reconstructed))Valores singulares e posto da matriz
Os valores singulares (a diagonal de S) são sempre não negativos e, por convenção, são listados em ordem decrescente. A quantidade de valores singulares não nulos é igual ao posto da matriz. Valores singulares próximos de zero indicam quase dependência linear entre linhas ou colunas. O maior valor singular fornece a norma espectral da matriz, e a razão entre o maior e o menor valor singular não nulo é o número de condição usado para medir a estabilidade numérica.
import numpy as np
# Full-rank matrix
A = np.random.rand(5, 3)
U, s, Vh = np.linalg.svd(A, full_matrices=False)
print('Singular values:', np.round(s, 4))
print('Rank (non-zero sv):', np.linalg.matrix_rank(A))
print('Condition number:', s[0] / s[-1])
# Rank-deficient matrix
B = np.array([[1.0, 2.0], [2.0, 4.0], [3.0, 6.0]])
_, sb, _ = np.linalg.svd(B, full_matrices=False)
print('Rank-deficient sv:', np.round(sb, 8))SVD e PCA: a conexão
A análise de componentes principais (PCA) pode ser implementada diretamente por meio do SVD. Depois de centralizar sua matriz de dados X (subtraindo as médias das colunas), os vetores singulares à direita em Vh são os componentes principais, e os quadrados dos valores singulares (divididos por n-1) são as variâncias explicadas. O PCA do Sklearn usa exatamente essa abordagem. Compreender essa conexão permite implementar ou personalizar o PCA do zero para redução de dimensionalidade.
import numpy as np
np.random.seed(0)
X = np.random.randn(100, 4)
# Center the data
X_centered = X - X.mean(axis=0)
# SVD-based PCA
U, s, Vh = np.linalg.svd(X_centered, full_matrices=False)
# Variance explained by each component
var_explained = (s ** 2) / (X.shape[0] - 1)
total_var = var_explained.sum()
print('Variance explained ratio:', np.round(var_explained / total_var, 3))
# Project onto top 2 principal components
X_pca = X_centered @ Vh[:2].T
print('Reduced shape:', X_pca.shape)Aproximação de baixo posto com SVD
O SVD permite a aproximação de matrizes de baixo posto: mantenha apenas os k maiores valores singulares e seus vetores e reconstrua uma aproximação da matriz original. Essa é a base da compressão de imagens e da filtragem colaborativa para recomendações. O SVD truncado U[:, :k] @ np.diag(s[:k]) @ Vh[:k, :] fornece a melhor aproximação de posto k no sentido dos mínimos quadrados (teorema de Eckart-Young).
import numpy as np
np.random.seed(1)
A = np.random.rand(20, 15)
U, s, Vh = np.linalg.svd(A, full_matrices=False)
# Rank-3 approximation
k = 3
A_approx = U[:, :k] @ np.diag(s[:k]) @ Vh[:k, :]
error = np.linalg.norm(A - A_approx, 'fro')
total = np.linalg.norm(A, 'fro')
print(f'Approximation error: {error/total:.3f} (fraction of total)')
print(f'Top-3 singular values capture {(s[:3]**2).sum()/(s**2).sum():.1%} of variance')Decomposição espectral versus SVD: quando usar cada uma
Use a decomposição espectral (np.linalg.eig ou eigh) quando tiver uma matriz quadrada e simétrica e quiser compreender seus eixos principais — por exemplo, a matriz de covariância no PCA ou matrizes de transição de Markov. Use o SVD (np.linalg.svd) quando sua matriz for retangular ou quando precisar de máxima estabilidade numérica. O SVD sempre existe; a decomposição espectral pode produzir números complexos para matrizes não simétricas.
import numpy as np
# Non-symmetric matrix: eigenvalues may be complex
A = np.array([[0.0, -1.0],
[1.0, 0.0]])
vals, _ = np.linalg.eig(A)
print('Eigenvalues (complex for rotation):', vals)
# SVD always gives real singular values
_, s, _ = np.linalg.svd(A)
print('Singular values (always real):', s)Teorema espectral para matrizes simétricas
O teorema espectral afirma que toda matriz simétrica real A pode ser decomposta como A = Q @ diag(eigenvalues) @ Q.T, em que Q é ortogonal (Q.T = Q⁻¹). Isso significa que matrizes simétricas sempre podem ser diagonalizadas com autovalores reais e autovetores ortogonais. Matrizes de covariância, matrizes de núcleo em SVMs e a matriz Hessiana em otimização são todas simétricas, o que torna esse teorema universalmente útil na teoria do aprendizado de máquina.
import numpy as np
A = np.array([[5.0, 2.0, 1.0],
[2.0, 3.0, 0.0],
[1.0, 0.0, 4.0]])
vals, Q = np.linalg.eigh(A)
print('Eigenvalues:', np.round(vals, 4))
# Reconstruct A = Q @ diag(vals) @ Q.T
A_reconstructed = Q @ np.diag(vals) @ Q.T
print('Reconstruction correct:', np.allclose(A, A_reconstructed))
print('Q is orthogonal:', np.allclose(Q.T @ Q, np.eye(3)))Prática: iteração de potência para o autovalor dominante
Quando você precisa apenas do maior autovalor e de seu autovetor, a iteração de potência é muito mais eficiente do que calcular todos os autovalores. Comece com um vetor aleatório, multiplique-o repetidamente por A e normalize-o; ele convergirá para o autovetor dominante. Foi assim que funcionou o algoritmo PageRank original do Google. O NumPy transforma cada iteração em uma única multiplicação de matriz por vetor com @.
import numpy as np
A = np.array([[4.0, 1.0, 2.0],
[1.0, 3.0, 0.0],
[2.0, 0.0, 2.0]])
v = np.random.rand(3)
for _ in range(50):
v = A @ v
v = v / np.linalg.norm(v)
eigenvalue_approx = v @ A @ v
print('Dominant eigenvector:', np.round(v, 4))
print('Approx eigenvalue:', round(eigenvalue_approx, 4))
# Verify with eigh
vals, vecs = np.linalg.eigh(A)
print('True max eigenvalue:', round(vals[-1], 4))Usando np.linalg.svd em fluxos de dados reais
Em um fluxo de dados real, o SVD é usado para redução de ruído e compressão de dados. Depois de ajustar o SVD aos dados de treinamento, mantenha apenas os k componentes principais que capturam 95% da variância. Isso reduz a dimensionalidade dos novos dados antes de fornecê-los a um classificador ou regressor, acelerando o treinamento e frequentemente melhorando a generalização ao remover dimensões ruidosas. Ajuste sempre o SVD apenas aos dados de treinamento e aplique a mesma transformação aos dados de teste.
import numpy as np
np.random.seed(7)
X_train = np.random.randn(200, 50)
X_test = np.random.randn(40, 50)
# Fit on training data
X_mean = X_train.mean(axis=0)
X_centered = X_train - X_mean
U, s, Vh = np.linalg.svd(X_centered, full_matrices=False)
# Choose k to capture 90% variance
cumvar = np.cumsum(s**2) / (s**2).sum()
k = np.searchsorted(cumvar, 0.9) + 1
print(f'Components to capture 90% variance: {k}')
# Transform test data using the same Vh
X_test_reduced = (X_test - X_mean) @ Vh[:k].T
print('Reduced test shape:', X_test_reduced.shape)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 np.linalg.eig()/eigh() calcula autovalores e autovetores que revelam as direções intrínsecas de alongamento de uma matriz, que np.linalg.svd() decompõe qualquer matriz em U, valores singulares e Vh, possibilitando o PCA e a aproximação de baixo posto, e que os valores singulares quantificam a variância capturada por cada componente e determinam o posto da matriz. A seguir, veremos como lidar com grandes conjuntos de dados transmitindo arquivos CSV em blocos.
Aprenda Python com um tutor de IA — grátis
Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.
- Cursos
- 30
- Aulas
- 120
Perguntas Frequentes
A aula “Visão geral de autovalores e SVD” é grátis?
Sim — o texto completo de “Visão geral de autovalores e SVD” é 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 “Visão geral de autovalores e SVD”?
Calcule autovalores e autovetores com np.linalg.eig e entenda como SVD fundamenta a redução de dimensionalidade do PCA. 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 4 de 4.
Quanto tempo leva a aula “Visão geral de autovalores e SVD”?
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
- Multiplicação de matrizes com np.matmul e @
- Determinantes, inversas e transpostas
- Resolução de sistemas lineares
- Visão geral de autovalores e SVD