Panoramica su autovalori e SVD
Calcoli autovalori e autovettori con np.linalg.eig e comprenda come la SVD sia alla base della riduzione della dimensionalità tramite PCA.
Panoramica su autovalori e SVD è una lezione Pandas & NumPy Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Pandas & NumPy Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Pandas & NumPy Academy include 4 lezioni in totale.
Che cosa sono gli autovalori e gli autovettori?
Un autovettore di una matrice quadrata A è un vettore non nullo v tale che A @ v = lambda * v: la moltiplicazione per A scala soltanto v, senza modificarne la direzione. Lo scalare lambda è detto autovalore corrispondente a v. Gli autovalori rivelano i «fattori di dilatazione» intrinseci di una trasformazione lineare: un autovalore pari a 2 significa che la matrice raddoppia le lunghezze nella direzione dell'autovettore; un autovalore negativo inverte la direzione.
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)Calcolo degli autovalori con np.linalg.eig()
np.linalg.eig(A) restituisce una tupla (eigenvalues, eigenvectors). Gli autovalori sono un array 1D; gli autovettori sono un array 2D in cui ogni colonna è un autovettore. Per le matrici simmetriche reali, come le matrici di covarianza, gli autovalori sono sempre reali e gli autovettori sono ortogonali: utilizzi np.linalg.eigh(A) per le matrici simmetriche, poiché è più veloce e garantisce risultati reali.
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))Autovalori e proprietà delle matrici
Gli autovalori codificano importanti proprietà delle matrici. Il determinante è uguale al prodotto di tutti gli autovalori: det(A) = product(eigenvalues). La traccia (la somma degli elementi diagonali) è uguale alla somma degli autovalori: trace(A) = sum(eigenvalues). Una matrice è definita positiva (tutti gli autovalori > 0) se e solo se tutti gli autovalori sono positivi: una proprietà fondamentale per le matrici di covarianza valide e per i problemi di ottimizzazione convessa.
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))Panoramica della decomposizione ai valori singolari (SVD)
La decomposizione ai valori singolari (SVD) scompone qualsiasi matrice A, non solo quelle quadrate, come A = U @ S @ V.T, dove U e V sono matrici ortogonali e S è diagonale, con valori singolari non negativi sulla diagonale. La SVD è la fattorizzazione di matrici più generale e numericamente stabile. È alla base della PCA, della compressione delle immagini, dei sistemi di raccomandazione e del calcolo della pseudoinversa. np.linalg.svd(A) restituisce U, s (i valori singolari in un array 1D) e Vh (la trasposta di V).
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))Valori singolari e rango della matrice
I valori singolari (sulla diagonale di S) sono sempre non negativi e, per convenzione, sono elencati in ordine decrescente. Il numero di valori singolari non nulli è uguale al rango della matrice. Valori singolari prossimi a zero indicano una quasi dipendenza lineare tra righe o colonne. Il valore singolare più grande fornisce la norma spettrale della matrice, mentre il rapporto tra il valore più grande e il più piccolo valore singolare non nullo è il numero di condizionamento utilizzato per misurare la stabilità numerica.
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: il collegamento
L'analisi delle componenti principali (PCA) può essere implementata direttamente tramite la SVD. Dopo aver centrato la matrice dei dati X (sottraendo le medie delle colonne), i vettori singolari destri in Vh sono le componenti principali e i quadrati dei valori singolari, divisi per n-1, sono le varianze spiegate. La PCA di Sklearn utilizza esattamente questo approccio. Comprendere questo collegamento consente di implementare o personalizzare la PCA da zero per la riduzione della dimensionalità.
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)Approssimazione a basso rango con la SVD
La SVD consente l'approssimazione a basso rango di una matrice: mantenga soltanto i k valori e vettori singolari principali e ricostruisca un'approssimazione della matrice originale. Questo costituisce la base della compressione delle immagini e del collaborative filtering per i sistemi di raccomandazione. La SVD troncata U[:, :k] @ np.diag(s[:k]) @ Vh[:k, :] fornisce la migliore approssimazione di rango k nel senso dei minimi quadrati (teorema di 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')Decomposizione spettrale e SVD: quale utilizzare e quando
Utilizzi la decomposizione spettrale (np.linalg.eig o eigh) quando dispone di una matrice quadrata e simmetrica e desidera comprenderne gli assi principali, ad esempio per la matrice di covarianza nella PCA o per le matrici di transizione di Markov. Utilizzi la SVD (np.linalg.svd) quando la matrice è rettangolare o quando ha bisogno della massima stabilità numerica. La SVD esiste sempre; la decomposizione spettrale può produrre numeri complessi per le matrici non simmetriche.
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 spettrale per le matrici simmetriche
Il teorema spettrale afferma che ogni matrice simmetrica reale A può essere decomposta come A = Q @ diag(eigenvalues) @ Q.T, dove Q è ortogonale (Q.T = Q⁻¹). Ciò significa che le matrici simmetriche sono sempre diagonalizzabili, con autovalori reali e autovettori ortogonali. Le matrici di covarianza, le matrici kernel nelle SVM e la matrice hessiana nell'ottimizzazione sono tutte simmetriche, rendendo questo teorema universalmente utile nella teoria del machine learning.
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)))Pratica: iterazione delle potenze per l'autovalore dominante
Quando ha bisogno soltanto del massimo autovalore e del relativo autovettore, l'iterazione delle potenze è molto più efficiente del calcolo di tutti gli autovalori. Inizi con un vettore casuale, lo moltiplichi ripetutamente per A e lo normalizzi: il procedimento converge verso l'autovettore dominante. È così che funzionava l'algoritmo PageRank originale di Google. NumPy rende ogni iterazione una singola moltiplicazione matrice-vettore con @.
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))Utilizzo di np.linalg.svd nei flussi di lavoro reali
In un vero flusso di lavoro sui dati, la SVD viene utilizzata per la riduzione del rumore e la compressione dei dati. Dopo aver adattato la SVD ai dati di addestramento, mantenga soltanto le k componenti principali che catturano il 95% della varianza. In questo modo riduce la dimensionalità dei nuovi dati prima di passarli a un classificatore o a un regressore, velocizzando l'addestramento e migliorando spesso la capacità di generalizzazione grazie alla rimozione delle dimensioni rumorose. Adatti sempre la SVD esclusivamente ai dati di addestramento e applichi la stessa trasformazione ai dati di test.
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 rapida
Verifichi la sua comprensione dei concetti di analisi dei dati trattati in questa lezione.
Riepilogo della lezione
In questa lezione ha imparato che: np.linalg.eig()/eigh() calcolano autovalori e autovettori che rivelano le direzioni di dilatazione intrinseche di una matrice, np.linalg.svd() scompone qualsiasi matrice in U, valori singolari e Vh, consentendo la PCA e l'approssimazione a basso rango, e i valori singolari quantificano la varianza catturata da ciascuna componente e determinano il rango della matrice. Ora affronteremo la gestione di grandi dataset eseguendo lo streaming di file CSV in blocchi.
Domande Frequenti
La lezione «Panoramica su autovalori e SVD» è gratuita?
Sì — il testo completo di «Panoramica su autovalori e SVD» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Pandas & NumPy Academy, passa a CoddyKit PRO. Il corso Pandas & NumPy Academy include 4 lezioni in totale.
Cosa imparerò in «Panoramica su autovalori e SVD»?
Calcoli autovalori e autovettori con np.linalg.eig e comprenda come la SVD sia alla base della riduzione della dimensionalità tramite PCA. Eserciti Pandas & NumPy Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Pandas & NumPy Academy?
Non è richiesta alcuna esperienza precedente. Pandas & NumPy Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.
Quanto tempo richiede la lezione «Panoramica su autovalori e SVD»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Pandas & NumPy Academy?
Sì. Ogni lezione Pandas & NumPy Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Moltiplicazione di matrici con np.matmul e @
- Determinanti, inverse e trasposte
- Risoluzione di sistemi lineari
- Panoramica su autovalori e SVD