0Pricing
Pandas & NumPy Academy · Lezione

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

  1. Moltiplicazione di matrici con np.matmul e @
  2. Determinanti, inverse e trasposte
  3. Risoluzione di sistemi lineari
  4. Panoramica su autovalori e SVD
← Torna a Pandas & NumPy Academy