0Pricing
R Academy · Pelajaran

Dekomposisi SVD, QR, dan Cholesky

Terapkan svd(), qr(), dan chol() untuk reduksi dimensi dan faktorisasi.

Dekomposisi SVD, QR, dan Cholesky adalah pelajaran R Academy gratis di CoddyKit. Ini adalah pelajaran 4 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar R Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus R Academy mencakup 4 pelajaran total.

Mengapa Dekomposisi Matriks?

Dekomposisi matriks memfaktorkan A menjadi hasil kali matriks yang lebih sederhana. Dekomposisi ini mengungkap struktur tersembunyi (rank, kondisi), memungkinkan perhitungan yang efisien, dan menjadi dasar PCA, regresi, serta optimisasi dalam statistika dan pembelajaran mesin.

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

Singular Value Decomposition (SVD) memfaktorkan setiap matriks m×n A = U D V', dengan U dan V ortogonal serta D diagonal dengan nilai singular non-negatif dalam urutan menurun.

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

Rekonstruksi SVD

Rekonstruksi A dari SVD sebagai A = U %*% diag(d) %*% t(V). Aproksimasi rank rendah hanya mempertahankan k nilai atau vektor singular teratas — ini menjadi dasar kompresi citra dan pengurangan derau.

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: Pseudoinvers dan Rank

SVD menghasilkan pseudoinvers A⁺ = V D⁺ U', dengan D⁺ mengganti setiap nilai singular tak nol dengan kebalikannya. Pseudoinvers ini menyelesaikan Ax = b dalam arti kuadrat terkecil, bahkan ketika A bukan matriks persegi atau tidak memiliki rank penuh.

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

Dekomposisi QR: qr()

Dekomposisi QR memfaktorkan A = QR dengan Q ortogonal (Q'Q = I) dan R segitiga atas. Dekomposisi ini digunakan dalam regresi linear, penghitungan nilai eigen (algoritme QR), dan ortogonalisasi 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 untuk Regresi

Menyelesaikan persamaan normal regresi linear melalui QR lebih unggul secara numerik. Karena Q'Q = I, persamaan normal A'Ax = A'b menjadi R'Q'QRx = R'Q'b, yang menyederhana menjadi Rx = Q'b dan diselesaikan dengan substitusi mundur.

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

Dekomposisi Cholesky: chol()

Cholesky memfaktorkan matriks definit positif simetris A = L L', dengan L berupa matriks segitiga bawah. chol() milik R mengembalikan faktor segitiga atas U (sehingga 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)
)

Menyelesaikan dengan Cholesky

Untuk sistem definit positif simetris (seperti matriks kovarians), penyelesaian berbasis Cholesky dua kali lebih cepat daripada LU. Gunakan chol2inv() untuk menghitung invers, atau gunakan backsolve/forwardsolve dengan faktor 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 dalam PCA

PCA melalui SVD: pusatkan matriks data X, lalu hitung SVD dari X yang telah dipusatkan. Vektor singular kanan V adalah arah komponen utama; nilai singular d berkaitan dengan varians yang dijelaskan (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))

Rank Matriks melalui SVD

Rank suatu matriks sama dengan jumlah nilai singular yang tidak dapat diabaikan. SVD memberikan cara yang paling andal secara numerik untuk menentukan rank — cukup hitung nilai d yang berada di atas ambang (biasanya 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 untuk Pengambilan Sampel Normal Multivariat

Untuk mengambil sampel dari N(μ, Σ) normal multivariat, hitung faktor Cholesky U dari Σ, lalu transformasikan normal standar: X = μ + Z %*% U. Inilah cara MASS::mvrnorm() bekerja secara internal.

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

Pemeriksaan Singkat

Uji pemahaman Anda tentang dekomposisi SVD, QR, dan Cholesky di R.

Ringkasan: SVD, QR, dan Cholesky

Hal-hal penting: SVD (svd()) menghasilkan d, u, v — digunakan untuk PCA, rank, pseudoinvers, dan aproksimasi rank rendah. QR (qr()) menghasilkan Q ortogonal dan R segitiga atas — digunakan untuk regresi dan stabilitas. Cholesky (chol()) menghasilkan U segitiga atas dengan A = t(U)%*%U — paling cepat untuk sistem SPD. Semuanya dapat merekonstruksi A secara tepat dan digunakan untuk tujuan komputasi yang berbeda.

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

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Dekomposisi SVD, QR, dan Cholesky” gratis?

Ya — teks lengkap “Dekomposisi SVD, QR, dan Cholesky” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus R Academy, upgrade ke CoddyKit PRO. Kursus R Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Dekomposisi SVD, QR, dan Cholesky”?

Terapkan svd(), qr(), dan chol() untuk reduksi dimensi dan faktorisasi. Kamu berlatih R Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai R Academy?

Tidak diperlukan pengalaman sebelumnya. R Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 4 dari 4.

Berapa lama pelajaran “Dekomposisi SVD, QR, dan Cholesky” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran R Academy ini?

Ya. Setiap pelajaran R Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Perkalian Matriks dan Determinan
  2. Menyelesaikan Sistem Linear dengan solve()
  3. Nilai Eigen dan Vektor Eigen
  4. Dekomposisi SVD, QR, dan Cholesky
← Kembali ke R Academy