Pandas & NumPy Academy · Aula

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.

Aula 4 de 413 etapas

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.

Grátis para começar

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

  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