Valeurs propres et vecteurs propres
Calculez les décompositions en valeurs propres avec eigen() et interprétez les résultats.
Valeurs propres et vecteurs propres est une leçon R Academy gratuite sur CoddyKit. Ceci est la leçon 3 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 R Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours R Academy comprend 4 leçons au total.
Que sont les valeurs propres ?
Un vecteur propre v de la matrice A est un vecteur non nul qui subit uniquement un changement d’échelle, et non une rotation, lorsqu’il est multiplié par A : Av = λv. Le scalaire λ est la valeur propre. Les vecteurs propres révèlent les directions intrinsèques d’étirement d’une matrice.
# Intuition: A simple scaling matrix
A <- matrix(c(3, 0,
0, 2), nrow = 2, byrow = TRUE)
# The eigenvectors are the standard basis vectors
# A * c(1,0) = 3 * c(1,0) -> eigenvalue 3
# A * c(0,1) = 2 * c(0,1) -> eigenvalue 2
v1 <- c(1, 0)
A %*% v1 # c(3, 0) = 3 * v1
v2 <- c(0, 1)
A %*% v2 # c(0, 2) = 2 * v2
cat('Eigenvalues of a diagonal matrix are its diagonal entries')eigen() : calcul des valeurs propres
eigen(A) renvoie une liste contenant $values (les valeurs propres triées par module décroissant) et $vectors (la matrice dont les colonnes sont les vecteurs propres). Les vecteurs propres sont normalisés à une longueur unitaire.
A <- matrix(c(4, 1,
2, 3), nrow = 2, byrow = TRUE)
# Compute eigendecomposition
eig <- eigen(A)
# Eigenvalues
eig$values
# [1] 5 2 (descending order)
# Eigenvectors (columns)
eig$vectors
# [,1] [,2]
# [1,] 0.7071068 -0.4472136
# [2,] 0.7071068 0.8944272
cat('Each column is one eigenvector (unit length)')Vérification de Av = lambda * v
Pour vérifier le résultat, assurez-vous que A %*% v - lambda * v est essentiellement nul. En raison des calculs en virgule flottante, utilisez max(abs(...)) et vérifiez que la valeur est proche de l’epsilon machine plutôt que de tester une égalité exacte.
A <- matrix(c(4, 1,
2, 3), nrow = 2, byrow = TRUE)
eig <- eigen(A)
lambda1 <- eig$values[1] # 5
v1 <- eig$vectors[, 1]
# Verify: Av - lambda*v should be ~0
residual <- A %*% v1 - lambda1 * v1
max(abs(residual)) # ~ 1e-16
# Check all eigenpairs at once
# A V = V diag(lambda) where V = eigenvectors matrix
V <- eig$vectors
Lambda <- diag(eig$values)
err <- A %*% V - V %*% Lambda
max(abs(err)) # near zeroMatrices symétriques : valeurs propres réelles
Les matrices symétriques (A = t(A)) ont toujours des valeurs propres réelles et des vecteurs propres orthogonaux. C’est le théorème spectral, essentiel en statistique (les matrices de covariance sont symétriques semi-définies positives).
# Symmetric matrix
S <- matrix(c(4, 2, 2,
2, 3, 1,
2, 1, 5), nrow = 3, byrow = TRUE)
# All symmetric: A = t(A)
all.equal(S, t(S)) # TRUE
# Eigenvalues are real
eig <- eigen(S)
eig$values # All real numbers
Im(eig$values) # All zero
# Eigenvectors are orthogonal: V'V = I
V <- eig$vectors
round(t(V) %*% V, 10) # Identity matrix
cat('Symmetric -> real eigenvalues, orthogonal eigenvectors')Matrices asymétriques : valeurs propres complexes
Les matrices non symétriques peuvent avoir des valeurs propres complexes (par paires de conjuguées complexes). R les renvoie sous forme de nombres complexes. La partie réelle régit la croissance ou la décroissance ; la partie imaginaire régit la rotation ou l’oscillation.
# Rotation-like matrix -> complex eigenvalues
A <- matrix(c(0, -1,
1, 0), nrow = 2, byrow = TRUE)
# This is a 90-degree rotation matrix
eig <- eigen(A)
eig$values
# [1] 0+1i 0-1i (pure imaginary!)
# Real part: zero -> neither grows nor decays
Re(eig$values) # 0 0
# Imaginary part: indicates rotation
Im(eig$values) # 1 -1
# Another example: stable spiral
B <- matrix(c(-1, -2,
2, -1), nrow = 2, byrow = TRUE)
eigen(B)$values # -1 +/- 2iDécomposition en valeurs propres A = VLV^-1
Une matrice diagonalisable A peut s’écrire A = V Λ V⁻¹, où V est la matrice des vecteurs propres et Λ = diag(eigenvalues). Cette décomposition permet de calculer les puissances matricielles : A^n = V Λ^n V⁻¹.
A <- matrix(c(4, 1,
2, 3), nrow = 2, byrow = TRUE)
eig <- eigen(A)
V <- eig$vectors
Lambda <- diag(eig$values)
# Reconstruct A = V %*% Lambda %*% solve(V)
A_reconstructed <- V %*% Lambda %*% solve(V)
all.equal(A, A_reconstructed) # TRUE
# Matrix power A^3 using eigendecomposition
A_cubed_eig <- V %*% diag(eig$values^3) %*% solve(V)
A_cubed_direct <- A %*% A %*% A
all.equal(Re(A_cubed_eig), A_cubed_direct) # TRUEPrincipe de la PCA par les valeurs propres de la covariance
L’analyse en composantes principales (PCA) utilise la décomposition en valeurs propres de la matrice de covariance. Les vecteurs propres donnent les directions de variance maximale (les composantes principales) ; les valeurs propres donnent la variance dans chaque direction.
set.seed(42)
# Correlated 2D data
x1 <- rnorm(100)
x2 <- 0.8 * x1 + 0.6 * rnorm(100)
X <- cbind(x1, x2)
# Covariance matrix
C <- cov(X)
print(round(C, 3))
# Eigendecomposition of covariance matrix
eig <- eigen(C)
cat('Eigenvalues (variance explained):\n')
print(eig$values)
cat('PC1 direction:\n')
print(eig$vectors[, 1])
# Variance explained by PC1
prop_var <- eig$values[1] / sum(eig$values)
cat('PC1 explains:', round(100 * prop_var, 1), '%')Rayon spectral
Le rayon spectral ρ(A) = max|λᵢ| est la plus grande valeur propre en valeur absolue. Il détermine la stabilité des algorithmes itératifs : si ρ < 1, les itérations convergent ; si ρ > 1, elles divergent.
spectral_radius <- function(A) {
max(Mod(eigen(A)$values))
}
# Convergent matrix: spectral radius < 1
A_conv <- matrix(c(0.5, 0.2,
0.1, 0.3), nrow = 2, byrow = TRUE)
spectral_radius(A_conv) # < 1 -> iterations converge
# Divergent matrix: spectral radius > 1
A_div <- matrix(c(2, 0.5,
0.3, 1.5), nrow = 2, byrow = TRUE)
spectral_radius(A_div) # > 1 -> iterations diverge
# For positive definite A, spectral radius = max eigenvalue
cat('Spectral radius determines iterative stability')Déterminant et trace par les valeurs propres
Le déterminant est égal au produit des valeurs propres ; la trace est égale à leur somme. Ces relations relient les propriétés algébriques aux valeurs propres et fournissent des contrôles de cohérence pour vos résultats de eigen().
A <- matrix(c(5, 2,
1, 4), nrow = 2, byrow = TRUE)
eig_vals <- eigen(A)$values
# det(A) = product of eigenvalues
det(A)
prod(eig_vals) # Same!
# trace = sum of eigenvalues
sum(diag(A))
sum(eig_vals) # Same!
# For numeric precision, use Re() on complex
A2 <- matrix(c(3, -1, 2, 5), nrow = 2, byrow = TRUE)
ev <- eigen(A2)$values
all.equal(det(A2), prod(Re(ev)), tolerance = 1e-10)
all.equal(sum(diag(A2)), sum(Re(ev)), tolerance = 1e-10)Matrices définies positives
Une matrice symétrique est définie positive (PD) si toutes ses valeurs propres sont positives. Les matrices de covariance sont semi-définies positives (valeurs propres ≥ 0). Les matrices PD sont inversibles et admettent des décompositions de Cholesky.
# Check positive definiteness
is_positive_definite <- function(A) {
# Symmetric check
if (!isTRUE(all.equal(A, t(A)))) return(FALSE)
all(eigen(A)$values > 0)
}
# Positive definite covariance matrix
S <- matrix(c(4, 2,
2, 3), nrow = 2, byrow = TRUE)
is_positive_definite(S) # TRUE
eigen(S)$values # Both positive
# Not PD (one negative eigenvalue)
Q <- matrix(c(1, 3,
3, 2), nrow = 2, byrow = TRUE)
is_positive_definite(Q) # FALSE
eigen(Q)$values # One negativeItération de puissance pour la valeur propre dominante
Pour les grandes matrices, le calcul de toutes les valeurs propres est coûteux. L’itération de puissance trouve itérativement la plus grande valeur propre : elle est à la base de l’algorithme PageRank de Google. Multipliez plusieurs fois par A, puis normalisez.
# Power iteration: finds dominant eigenvalue
power_iteration <- function(A, tol = 1e-10, max_iter = 1000) {
n <- nrow(A)
v <- rnorm(n); v <- v / sqrt(sum(v^2)) # random unit vector
lambda_old <- 0
for (i in seq_len(max_iter)) {
w <- A %*% v
lambda <- max(abs(w))
v <- w / lambda
if (abs(lambda - lambda_old) < tol) break
lambda_old <- lambda
}
list(value = lambda, vector = v)
}
A <- matrix(c(4, 1, 2, 3), nrow = 2, byrow = TRUE)
result <- power_iteration(A)
result$value # Should be ~5 (dominant eigenvalue)
eigen(A)$values[1] # CompareVérification rapide
Testez votre compréhension des valeurs propres et des vecteurs propres dans R.
Récapitulatif : valeurs propres et vecteurs propres
Points essentiels : eigen(A) renvoie $values et $vectors. Vérifiez avec A %*% v - lambda*v ≈ 0. Les matrices symétriques ont des valeurs propres réelles et des vecteurs propres orthogonaux. Les matrices non symétriques peuvent avoir des valeurs propres complexes. det(A) = produit des valeurs propres ; trace = somme. La PCA décompose la matrice de covariance. Définie positive ↔ toutes les valeurs propres > 0.
A <- matrix(c(6, 2, 2, 3), nrow = 2)
eig <- eigen(A)
# Key eigen operations:
eig$values # eigenvalues
eig$vectors # eigenvectors (columns)
# Verify Av = lambda*v
v1 <- eig$vectors[, 1]
max(abs(A %*% v1 - eig$values[1] * v1)) # ~0
# Properties
all.equal(det(A), prod(eig$values)) # TRUE
all.equal(sum(diag(A)), sum(eig$values)) # TRUE
# Reconstruct A = V Lambda V^{-1}
V <- eig$vectors
all.equal(A, Re(V %*% diag(eig$values) %*% solve(V)))Questions Fréquemment Posées
La leçon « Valeurs propres et vecteurs propres » est-elle gratuite ?
Oui — le texte complet de « Valeurs propres et vecteurs propres » 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 R Academy, passe à CoddyKit PRO. Le cours R Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Valeurs propres et vecteurs propres » ?
Calculez les décompositions en valeurs propres avec eigen() et interprétez les résultats. Tu pratiques R 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 R Academy ?
Aucune expérience préalable n'est requise. R 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 3 sur 4.
Combien de temps prend la leçon « Valeurs propres et vecteurs propres » ?
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 R Academy ?
Oui. Chaque leçon R 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
- Multiplication matricielle et déterminants
- Résoudre des systèmes linéaires avec solve()
- Valeurs propres et vecteurs propres
- Décompositions SVD, QR et de Cholesky