R Academy · Oppitunti

SVD-, QR- ja Cholesky-hajotelmat

Soveltakaa svd()-, qr()- ja chol()-funktioita ulottuvuuden pienentämiseen ja tekijähajotelmiin.

Oppitunti 4/413 vaihetta

SVD-, QR- ja Cholesky-hajotelmat on ilmainen R Academy-oppitunti CoddyKitissä. Tämä on oppitunti 4/4. Voit lukea tästä oppimispolusta kokonaan mitkä tahansa 3 oppituntia ilmaiseksi — sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä käytännön harjoittelun sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. Oppitunti kuuluu R Academy-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. R Academy-kurssilla on yhteensä 4 oppituntia.

Miksi matriisihajotelmia käytetään?

Matriisihajotelmissa A jaetaan yksinkertaisempien matriisien tuloksi. Ne paljastavat piilevän rakenteen (asteen ja kuntoisuuden), mahdollistavat tehokkaan laskennan ja muodostavat tilastotieteen sekä koneoppimisen PCA:n, regression ja optimoinnin perustan.

# 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: svd()-funktio

Singulaariarvohajotelmassa (SVD) mikä tahansa m×n-matriisi A hajotetaan muotoon A = U D V', jossa U ja V ovat ortogonaalisia ja D diagonaalinen matriisi, jonka singulaariarvot ovat epänegatiivisia ja laskevassa järjestyksessä.

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

SVD:n avulla rekonstruointi

Rekonstruoikaa A SVD:stä muodossa A = U %*% diag(d) %*% t(V). Alhaisen asteen approksimaatioissa säilytetään vain k suurinta singulaariarvoa ja vastaavat vektorit — tämä on kuvien pakkauksen ja kohinan vähentämisen perusta.

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: pseudokäänteismatriisi ja aste

SVD antaa pseudokäänteismatriisin A⁺ = V D⁺ U', jossa D⁺ korvaa jokaisen nollasta poikkeavan singulaariarvon sen käänteisluvulla. Sen avulla Ax = b ratkaistaan pienimmän neliösumman mielessä myös silloin, kun A ei ole neliömatriisi tai sen aste ei ole täysi.

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

QR-hajotelma: qr()

QR-hajotelmassa A = QR, jossa Q on ortogonaalinen (Q'Q = I) ja R yläkolmiomatriisi. Sitä käytetään lineaarisessa regressiossa, ominaisarvojen laskemisessa (QR-algoritmi) ja Gram–Schmidtin ortogonalisaatiossa.

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 regressiossa

Lineaarisen regression normaalien yhtälöiden ratkaiseminen QR-hajotelman avulla on numeerisesti parempi. Koska Q'Q = I, normaalit yhtälöt A'Ax = A'b muuttuvat muotoon R'Q'QRx = R'Q'b ja yksinkertaistuvat muotoon Rx = Q'b, joka ratkaistaan takaisinsijoituksella.

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

Cholesky-hajotelma: chol()

Cholesky-hajotelmassa symmetrinen positiivisesti definiitti matriisi A hajotetaan muotoon A = L L', jossa L on alakolmiomatriisi. R:n chol()-funktio palauttaa yläkolmiotekijän U (siis 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)
)

Ratkaiseminen Cholesky-hajotelman avulla

Symmetrisille positiivisesti definiiteille yhtälöryhmille, kuten kovarianssimatriiseille, Choleskyyn perustuva ratkaisu on kaksi kertaa LU-menetelmää nopeampi. Käyttäkää chol2inv()-funktiota käänteismatriisin laskemiseen tai käyttäkää Cholesky-tekijän kanssa funktioita backsolve/forwardsolve.

# 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 PCA:ssa

PCA SVD:n avulla: keskittäkää datamatriisi X ja laskekaa sitten keskitetyn X:n SVD. Oikeat singulaarivektorit V ovat pääkomponenttien suunnat, ja singulaariarvot d liittyvät selitettyyn varianssiin (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))

Matriisin asteen laskeminen SVD:n avulla

Matriisin aste on merkityksellisten singulaariarvojen lukumäärä. SVD tarjoaa numeerisesti luotettavimman tavan määrittää aste — laskekaa yksinkertaisesti d-arvot, jotka ylittävät kynnysarvon (yleensä 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 monimuuttujaisen normaalijakauman otantaan

Kun haluatte poimia otoksen monimuuttujaisesta normaalijakaumasta N(μ, Σ), laskekaa Σ:n Cholesky-tekijä U ja muuntakaa standardinormaalit: X = μ + Z %*% U. Näin MASS::mvrnorm() toimii sisäisesti.

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

Pikatarkistus

Testatkaa SVD-, QR- ja Cholesky-hajotelmien ymmärtämistänne R:ssä.

Vastaa interaktiivisessa oppitunnissa

Kertaus: SVD, QR ja Cholesky

Keskeiset asiat: SVD (svd()) palauttaa arvot d, u ja v — sitä käytetään PCA:ssa, asteen ja pseudokäänteismatriisin laskemiseen sekä alhaisen asteen approksimaatioihin. QR (qr()) palauttaa ortogonaalisen Q:n ja yläkolmiomatriisin R:n — sitä käytetään regressiossa ja vakauden parantamiseen. Cholesky (chol()) palauttaa yläkolmiomatriisin U, jolle A = t(U)%*%U — se on nopein SPD-yhtälöryhmille. Kaikki hajotelmat rekonstruoivat A:n täsmällisesti, mutta palvelevat eri laskennallisia tarkoituksia.

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

Aloita maksutta

Opi R tekoälytuutorin avulla — ilmaiseksi

Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.

Kurssit: 43
Oppitunnit: 159

Aloita opiskelu maksutta Näytä koko kurssi

Usein kysytyt kysymykset

Onko oppitunti ”SVD-, QR- ja Cholesky-hajotelmat” ilmainen?

Kyllä — voit lukea täällä verkossa kokonaan ilmaiseksi mitkä tahansa R Academy-oppimispolun 3 oppituntia, myös oppitunnin “SVD-, QR- ja Cholesky-hajotelmat”. Sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä interaktiiviset harjoitukset sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. R Academy-kurssilla on yhteensä 4 oppituntia.

Mitä opin oppitunnilla ”SVD-, QR- ja Cholesky-hajotelmat”?

Soveltakaa svd()-, qr()- ja chol()-funktioita ulottuvuuden pienentämiseen ja tekijähajotelmiin. Harjoittelet R Academy-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.

Tarvitsenko kokemusta aloittaakseni R Academy-opiskelun?

Aiempi kokemus ei ole tarpeen. CoddyKitin R Academy-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 4/4.

Kuinka kauan ”SVD-, QR- ja Cholesky-hajotelmat”-oppitunnin suorittaminen kestää?

Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.

Voinko kirjoittaa ja suorittaa koodia tällä R Academy-oppitunnilla?

Kyllä. Jokainen R Academy-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.

Kaikki tämän kurssin oppitunnit

Matriisikertolasku ja determinantit
Lineaaristen yhtälöryhmien ratkaiseminen solve()-funktiolla
Ominaisarvot ja ominaisvektorit
SVD-, QR- ja Cholesky-hajotelmat

← Takaisin: R Academy