0Pricing
Pandas & NumPy Academy · Leçon

Valeurs propres et présentation de la SVD

Calculez les valeurs et vecteurs propres avec np.linalg.eig et comprenez comment la SVD sous-tend la réduction dimensionnelle par PCA.

Valeurs propres et présentation de la SVD est une leçon Pandas & NumPy Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Pandas & NumPy Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Pandas & NumPy Academy comprend 4 leçons au total.

Que sont les valeurs propres et les vecteurs propres ?

Un vecteur propre d'une matrice carrée A est un vecteur non nul v tel que A @ v = lambda * v — la multiplication par A ne fait que redimensionner v, sans modifier sa direction. Le scalaire lambda est appelé la valeur propre correspondant à v. Les valeurs propres révèlent les « facteurs d'étirement » intrinsèques d'une transformation linéaire : une valeur propre égale à 2 signifie que la matrice double les longueurs dans la direction du vecteur propre ; une valeur propre négative inverse la direction.

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)

Calcul des valeurs propres avec np.linalg.eig()

np.linalg.eig(A) renvoie un tuple (eigenvalues, eigenvectors). Les valeurs propres forment un tableau à 1 dimension ; les vecteurs propres forment un tableau à 2 dimensions dont chaque colonne est un vecteur propre. Pour les matrices symétriques réelles, comme les matrices de covariance, les valeurs propres sont toujours réelles et les vecteurs propres sont orthogonaux — utilisez np.linalg.eigh(A) pour les matrices symétriques, car cette fonction est plus rapide et garantit des résultats réels.

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

Valeurs propres et propriétés des matrices

Les valeurs propres encodent des propriétés importantes des matrices. Le déterminant est égal au produit de toutes les valeurs propres : det(A) = product(eigenvalues). La trace (somme des éléments diagonaux) est égale à la somme des valeurs propres : trace(A) = sum(eigenvalues). Une matrice est définie positive (toutes ses valeurs propres sont > 0) si et seulement si toutes ses valeurs propres sont positives — une propriété essentielle pour les matrices de covariance valides et les problèmes d'optimisation convexe.

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

Présentation de la décomposition en valeurs singulières (SVD)

La décomposition en valeurs singulières (SVD) décompose toute matrice A, et pas seulement les matrices carrées, sous la forme A = U @ S @ V.T, où U et V sont des matrices orthogonales et S est une matrice diagonale dont la diagonale contient des valeurs singulières non négatives. La SVD est la factorisation matricielle la plus générale et la plus stable numériquement. Elle est à la base de la PCA, de la compression d'images, des systèmes de recommandation et du calcul de la pseudo-inverse. np.linalg.svd(A) renvoie U, s (les valeurs singulières à 1 dimension) et Vh (la transposée de 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))

Valeurs singulières et rang d'une matrice

Les valeurs singulières (sur la diagonale de S) sont toujours non négatives et sont généralement présentées dans l'ordre décroissant. Le nombre de valeurs singulières non nulles est égal au rang de la matrice. Des valeurs singulières proches de zéro indiquent une quasi-dépendance linéaire entre les lignes ou les colonnes. La plus grande valeur singulière donne la norme spectrale de la matrice, et le rapport entre la plus grande valeur singulière et la plus petite valeur singulière non nulle est le nombre de conditionnement utilisé pour mesurer la stabilité numérique.

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 et PCA : le lien

L'analyse en composantes principales (PCA) peut être implémentée directement à l'aide de la SVD. Après avoir centré votre matrice de données X (en soustrayant les moyennes des colonnes), les vecteurs singuliers droits de Vh sont les composantes principales, et les carrés des valeurs singulières (divisés par n-1) sont les variances expliquées. La PCA de Sklearn utilise exactement cette approche. Comprendre ce lien vous permet d'implémenter ou de personnaliser la PCA à partir de zéro pour réduire la dimensionnalité.

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)

Approximation de faible rang avec la SVD

La SVD permet d'obtenir une approximation matricielle de faible rang : conservez uniquement les k plus grandes valeurs singulières et les vecteurs associés, puis reconstruisez une approximation de la matrice d'origine. C'est le principe de la compression d'images et du filtrage collaboratif utilisé pour les recommandations. La SVD tronquée U[:, :k] @ np.diag(s[:k]) @ Vh[:k, :] fournit la meilleure approximation de rang k au sens des moindres carrés (théorème d'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')

Décomposition spectrale ou SVD : laquelle utiliser ?

Utilisez la décomposition spectrale (np.linalg.eig ou eigh) lorsque vous avez une matrice carrée symétrique et que vous souhaitez comprendre ses axes principaux — par exemple, la matrice de covariance dans la PCA ou les matrices de transition de Markov. Utilisez la SVD (np.linalg.svd) lorsque votre matrice est rectangulaire ou lorsque vous avez besoin d'une stabilité numérique maximale. La SVD existe toujours ; la décomposition spectrale peut produire des nombres complexes pour les matrices non symétriques.

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)

Théorème spectral pour les matrices symétriques

Le théorème spectral affirme que toute matrice symétrique réelle A peut être décomposée sous la forme A = Q @ diag(eigenvalues) @ Q.T, où Q est orthogonale (Q.T = Q⁻¹). Cela signifie que les matrices symétriques sont toujours diagonalisables, avec des valeurs propres réelles et des vecteurs propres orthogonaux. Les matrices de covariance, les matrices de noyau des SVM et la matrice hessienne en optimisation sont toutes symétriques, ce qui rend ce théorème particulièrement utile en théorie de l'apprentissage automatique.

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

Mise en pratique : itération de puissance pour la valeur propre dominante

Lorsque vous n'avez besoin que de la plus grande valeur propre et de son vecteur propre, l'itération de puissance est bien plus efficace que le calcul de toutes les valeurs propres. Commencez par un vecteur aléatoire, multipliez-le à plusieurs reprises par A et normalisez-le : il converge vers le vecteur propre dominant. C'est ainsi que fonctionnait l'algorithme PageRank original de Google. NumPy réduit chaque itération à une seule multiplication matrice-vecteur avec @.

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

Utiliser np.linalg.svd dans des pipelines réels

Dans un pipeline de données réel, la SVD est utilisée pour la réduction du bruit et la compression des données. Après avoir ajusté la SVD sur les données d'entraînement, vous ne conservez que les k premières composantes qui représentent 95 % de la variance. Cela réduit la dimensionnalité des nouvelles données avant de les transmettre à un classificateur ou à un modèle de régression, accélère l'entraînement et améliore souvent la capacité de généralisation en supprimant les dimensions bruitées. Ajustez toujours la SVD uniquement sur les données d'entraînement et appliquez la même transformation aux données de 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)

Vérification rapide

Testez votre compréhension des concepts d'analyse de données présentés dans cette leçon.

Récapitulatif de la leçon

Dans cette leçon, vous avez appris que np.linalg.eig()/eigh() calculent les valeurs propres et les vecteurs propres qui révèlent les directions d'étirement intrinsèques d'une matrice, que np.linalg.svd() décompose toute matrice en U, valeurs singulières et Vh, ce qui permet la PCA et l'approximation de faible rang, et que les valeurs singulières quantifient la variance capturée par chaque composante et déterminent le rang de la matrice. Nous allons maintenant voir comment traiter de grands jeux de données en lisant les fichiers CSV par blocs.

Questions Fréquemment Posées

La leçon « Valeurs propres et présentation de la SVD » est-elle gratuite ?

Oui — le texte complet de « Valeurs propres et présentation de la SVD » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Pandas & NumPy Academy, passe à CoddyKit PRO. Le cours Pandas & NumPy Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Valeurs propres et présentation de la SVD » ?

Calculez les valeurs et vecteurs propres avec np.linalg.eig et comprenez comment la SVD sous-tend la réduction dimensionnelle par PCA. Tu pratiques Pandas & NumPy Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Pandas & NumPy Academy ?

Aucune expérience préalable n'est requise. Pandas & NumPy Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Valeurs propres et présentation de la SVD » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Pandas & NumPy Academy ?

Oui. Chaque leçon Pandas & NumPy Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Multiplication matricielle avec np.matmul et @
  2. Déterminants, inverses et transposées
  3. Résolution de systèmes linéaires
  4. Valeurs propres et présentation de la SVD
← Retour à Pandas & NumPy Academy