0Pricing
R Academy · Leçon

Décompositions SVD, QR et de Cholesky

Appliquez svd(), qr() et chol() pour réduire la dimension et factoriser les matrices.

Décompositions SVD, QR et de Cholesky est une leçon R 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 R Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours R Academy comprend 4 leçons au total.

Pourquoi décomposer les matrices ?

Les décompositions matricielles factorisent A en produits de matrices plus simples. Elles révèlent une structure cachée (rang, conditionnement), permettent des calculs efficaces et sont au cœur de la PCA, de la régression et de l’optimisation en statistique et en apprentissage automatique.

# Three fundamental decompositions:
# 1. SVD: A = U D V'  (any matrix)
# 2. QR:  A = Q R    (any matrix)
# 3. Cholesky: A = L L'  (symmetric positive definite)

# Each serves a purpose:
# SVD -> PCA, pseudoinverse, rank, image compression
# QR  -> linear regression, Gram-Schmidt, eigenvalues
# Cholesky -> fast solve for SPD systems, simulation

A <- matrix(c(4, 3, 2,
              3, 6, 1,
              2, 1, 5), nrow = 3, byrow = TRUE)
cat('Matrix ready for decomposition')
print(A)

SVD : fonction svd()

La décomposition en valeurs singulières (SVD) factorise toute matrice m×n A = U D V', où U et V sont orthogonales et D est diagonale, avec des valeurs singulières non négatives classées par ordre décroissant.

A <- matrix(c(1, 2, 3,
              4, 5, 6), nrow = 2, byrow = TRUE)

# Compute SVD
svd_result <- svd(A)

# Components:
svd_result$d  # singular values (decreasing)
svd_result$u  # left singular vectors  (2x2)
svd_result$v  # right singular vectors (3x2)

cat('Singular values:', svd_result$d, '\n')
cat('Rank of A:', sum(svd_result$d > 1e-10), '\n')

Reconstruction par SVD

Reconstruisez A à partir de sa SVD avec A = U %*% diag(d) %*% t(V). Les approximations de rang faible ne conservent que les k premières valeurs singulières et les vecteurs correspondants : c’est la base de la compression d’images et de la réduction du bruit.

A <- matrix(c(1, 2, 3,
              4, 5, 6,
              7, 8, 9), nrow = 3, byrow = TRUE)

res <- svd(A)
U <- res$u; d <- res$d; V <- res$v

# Full reconstruction: A = U diag(d) V'
A_reconstructed <- U %*% diag(d) %*% t(V)
all.equal(A, A_reconstructed)  # TRUE

# Rank-1 approximation (best rank-1 approx by Eckart-Young)
A_rank1 <- d[1] * U[, 1] %*% t(V[, 1])
print(round(A_rank1, 2))

# Frobenius error of rank-1 approx
sqrt(sum((A - A_rank1)^2))

SVD : pseudo-inverse et rang

La SVD fournit le pseudo-inverse A⁺ = V D⁺ U', où D⁺ remplace chaque valeur singulière non nulle par son inverse. Elle résout Ax = b au sens des moindres carrés, même lorsque A n’est pas carrée ou n’est pas de rang plein.

A <- matrix(c(1, 2, 3,
              4, 5, 6), nrow = 2, byrow = TRUE)

# Pseudoinverse via SVD
svd_res <- svd(A)
tol <- 1e-10
# Invert nonzero singular values
d_inv <- ifelse(svd_res$d > tol, 1/svd_res$d, 0)
A_pinv <- svd_res$v %*% diag(d_inv) %*% t(svd_res$u)
print(A_pinv)  # 3x2 pseudoinverse

# Least-squares solution: x = A+ b
b <- c(7, 8)
x_ls <- A_pinv %*% b
print(x_ls)

# Compare with MASS::ginv
# MASS::ginv(A) should give the same result

Décomposition QR : qr()

La décomposition QR factorise A = QR, où Q est orthogonale (Q'Q = I) et R est triangulaire supérieure. Elle est utilisée en régression linéaire, pour calculer les valeurs propres (algorithme QR) et pour l’orthogonalisation de Gram-Schmidt.

A <- matrix(c(1, 2,
              3, 4,
              5, 6), nrow = 3, byrow = TRUE)

# Compute QR decomposition
qr_res <- qr(A)

# Extract Q and R
Q <- qr.Q(qr_res)  # 3x2 orthogonal
R <- qr.R(qr_res)  # 2x2 upper triangular

cat('Q is orthogonal: Q\'Q = I\n')
print(round(t(Q) %*% Q, 10))  # Identity

cat('R is upper triangular:\n')
print(round(R, 6))

# Reconstruct A = Q %*% R
all.equal(A, Q %*% R)  # TRUE

QR pour la régression

Résoudre les équations normales de la régression linéaire par QR est numériquement préférable. Comme Q'Q = I, les équations normales A'Ax = A'b deviennent R'Q'QRx = R'Q'b, puis se simplifient en Rx = Q'b, qui se résout par substitution arrière.

# Generate regression data
set.seed(7)
n <- 20
x1 <- rnorm(n); x2 <- rnorm(n)
y <- 1 + 2*x1 - 0.5*x2 + rnorm(n, sd = 0.5)

# Design matrix
X <- cbind(intercept = 1, x1 = x1, x2 = x2)

# QR solve: numerically stable
beta_qr <- qr.solve(X, y)
print(beta_qr)  # ~c(1, 2, -0.5)

# Compare with lm()
beta_lm <- coef(lm(y ~ x1 + x2))
all.equal(beta_qr, beta_lm, check.names = FALSE)  # TRUE

# The qr.solve internals use backsolve on R
cat('QR regression is lm()\'s default method')

Décomposition de Cholesky : chol()

La décomposition de Cholesky factorise une matrice symétrique définie positive A = L L', où L est triangulaire inférieure. Le chol() de R renvoie le facteur triangulaire supérieur U (donc A = t(U) %*% U).

# Symmetric positive definite matrix
A <- matrix(c(4, 2,
              2, 3), nrow = 2, byrow = TRUE)

# Cholesky decomposition: A = t(U) %*% U
U <- chol(A)
print(U)
# Note: chol() returns UPPER triangular in R

# Reconstruct
all.equal(A, t(U) %*% U)  # TRUE

# Attempting Cholesky on non-PD matrix throws error
# Catch it:
result <- tryCatch(
  chol(matrix(c(1, 3, 3, 2), nrow = 2)),
  error = function(e) cat('Error:', e$message)
)

Résolution avec Cholesky

Pour les systèmes symétriques définis positifs (comme les matrices de covariance), la résolution fondée sur Cholesky est deux fois plus rapide que celle fondée sur LU. Utilisez chol2inv() pour calculer l’inverse, ou utilisez backsolve/forwardsolve avec le facteur de Cholesky.

# SPD system: typical in statistics (covariance matrices)
set.seed(1)
X <- matrix(rnorm(30), nrow = 10, ncol = 3)
A <- crossprod(X)  # X'X is always SPD
b <- c(1, 2, 3)

# Cholesky factor
U <- chol(A)  # Upper triangular

# Solve A x = b using two triangular solves
# A = t(U) %*% U -> solve t(U) y = b, then U x = y
y <- forwardsolve(t(U), b)
x <- backsolve(U, y)
print(x)

# Verify
all.equal(as.vector(A %*% x), b)

# Or: inverse via chol2inv
A_inv <- chol2inv(U)
all.equal(x, as.vector(A_inv %*% b))

SVD dans la PCA

PCA par SVD : centrez la matrice de données X, puis calculez la SVD de X centrée. Les vecteurs singuliers droits V sont les directions des composantes principales ; les valeurs singulières d sont liées à la variance expliquée (d²/(n-1)).

set.seed(42)
n <- 50; p <- 3
X <- matrix(rnorm(n * p), nrow = n)
# Add correlation
X[, 2] <- 0.8 * X[, 1] + 0.6 * X[, 2]

# Center
X_c <- scale(X, center = TRUE, scale = FALSE)

# SVD of centered data
svd_res <- svd(X_c)

# Variance explained by each PC
var_explained <- svd_res$d^2 / (n - 1)
prop_var <- var_explained / sum(var_explained)
cat('Proportion of variance explained:\n')
print(round(prop_var, 3))

# Compare with prcomp
pc <- prcomp(X)
all.equal(prop_var, pc$sdev^2 / sum(pc$sdev^2))

Rang d’une matrice par SVD

Le rang d’une matrice est égal au nombre de valeurs singulières non négligeables. La SVD fournit la méthode numériquement la plus fiable pour déterminer le rang : il suffit de compter les valeurs d supérieures à un seuil (généralement max(d) * tol).

# Full-rank matrix (rank 3)
A <- matrix(c(1, 0, 0,
              0, 2, 0,
              0, 0, 3), nrow = 3)
svd(A)$d  # c(3, 2, 1) - all nonzero -> rank 3

# Rank-deficient matrix (rank 2)
B <- matrix(c(1, 2, 3,
              2, 4, 6,   # row 2 = 2 * row 1
              0, 1, 1), nrow = 3, byrow = TRUE)
svd(B)$d  # Third value is ~0

# Rank function using SVD
matrix_rank <- function(M, tol = 1e-10) {
  d <- svd(M)$d
  sum(d > tol * d[1])  # relative tolerance
}
matrix_rank(B)  # 2

Cholesky pour l’échantillonnage normal multivarié

Pour échantillonner selon une loi normale multivariée N(μ, Σ), calculez le facteur de Cholesky U de Σ, puis transformez les normales centrées réduites : X = μ + Z %*% U. C’est ainsi que MASS::mvrnorm() fonctionne en interne.

set.seed(99)
# Covariance matrix
Sigma <- matrix(c(4, 2,
                  2, 3), nrow = 2)
mu <- c(1, 5)
n_samples <- 500

# Cholesky factor
U <- chol(Sigma)

# Sample standard normals
Z <- matrix(rnorm(n_samples * 2), nrow = n_samples)

# Transform: X ~ N(mu, Sigma)
X <- sweep(Z %*% U, 2, mu, FUN = '+')

# Check empirical covariance
print(round(cov(X), 2))  # Should be close to Sigma
print(round(colMeans(X), 2))  # Should be close to mu

Vérification rapide

Testez votre compréhension des décompositions SVD, QR et de Cholesky dans R.

Récapitulatif : SVD, QR et Cholesky

Points essentiels : la SVD (svd()) renvoie d, u et v ; elle sert à la PCA, au calcul du rang, du pseudo-inverse et des approximations de rang faible. QR (qr()) renvoie une matrice Q orthogonale et une matrice R triangulaire supérieure ; elle sert à la régression et à la stabilité numérique. Cholesky (chol()) renvoie une matrice U triangulaire supérieure telle que A = t(U)%*%U ; c’est la méthode la plus rapide pour les systèmes SPD. Toutes ces décompositions reconstruisent A exactement et répondent à des objectifs de calcul différents.

A <- matrix(c(4, 2, 2, 3), nrow = 2)

# SVD
res <- svd(A)
all.equal(A, res$u %*% diag(res$d) %*% t(res$v))  # TRUE

# QR (on a design matrix)
X <- cbind(1, c(1,2,3,4,5))
qr_res <- qr(X)
all.equal(X, qr.Q(qr_res) %*% qr.R(qr_res))  # TRUE

# Cholesky
U <- chol(A)
all.equal(A, t(U) %*% U)  # TRUE

# Use cases:
# svd() -> PCA, rank, pseudoinverse
# qr()  -> regression, stability
# chol()-> SPD solve, MVN sampling

Questions Fréquemment Posées

La leçon « Décompositions SVD, QR et de Cholesky » est-elle gratuite ?

Oui — le texte complet de « Décompositions SVD, QR et de Cholesky » 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 « Décompositions SVD, QR et de Cholesky » ?

Appliquez svd(), qr() et chol() pour réduire la dimension et factoriser les matrices. 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 4 sur 4.

Combien de temps prend la leçon « Décompositions SVD, QR et de Cholesky » ?

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

  1. Multiplication matricielle et déterminants
  2. Résoudre des systèmes linéaires avec solve()
  3. Valeurs propres et vecteurs propres
  4. Décompositions SVD, QR et de Cholesky
← Retour à R Academy