Nilai Eigen dan Vektor Eigen

Arah yang dipertahankan sebuah matriks.

Daftar isi

Nilai eigen dan vektor eigen menangkap arah istimewa sebuah matriks, yaitu arah yang tidak diputar oleh transformasinya, melainkan hanya diregangkan. Topik ini membahas definisi $A v = \lambda v$ , cara mencarinya melalui persamaan karakteristik, perhitungannya dengan np.linalg.eig, dan taksirannya melalui iterasi pangkat. Demo interaktif pada bagian akhir memperlihatkan perilaku tersebut secara langsung. Setelah topik ini dipahami, inti dari PCA dan PageRank dapat dibaca sebagai pencarian nilai dan vektor eigen.

Arah yang tidak berubah#

Transformasi linear umumnya memutar sekaligus meregangkan vektor yang diterimanya. Pada arah-arah tertentu, efek transformasi menyusut menjadi peregangan murni, dan arah itulah yang dicari. Definisinya berbunyi berikut.

A v = \lambda v

Vektor tak nol $v$ yang memenuhi persamaan itu disebut vektor eigen (eigenvector), sedangkan skala $\lambda$ disebut nilai eigen (eigenvalue). Matriks contoh sepanjang topik ini adalah matriks segitiga berikut.

A = \begin{pmatrix} 3 & 1 \\ 0 & 2 \end{pmatrix}

Arah horizontal memenuhi sifat itu, yaitu $A (1, 0) = (3, 0) = 3 \times (1, 0)$ , sehingga $(1, 0)$ adalah vektor eigen dengan nilai eigen 3. Arah diagonal $(1, -1)$ juga memenuhinya, yaitu $A (1, -1) = (2, -2) = 2 \times (1, -1)$ , sehingga nilai eigennya 2. Setiap kelipatan vektor eigen tetap menjadi vektor eigen karena skala pada persamaan boleh dipindahkan, sehingga yang istimewa adalah arahnya, bukan panjangnya.

Persamaan karakteristik#

Nilai eigen dicari dengan menyusun ulang definisi menjadi $(A - \lambda I) v = 0$ . Persamaan ini memiliki solusi vektor tak nol hanya bila matriks $A - \lambda I$ singular, dan syaratnya dinyatakan sebagai persamaan karakteristik berikut.

\det(A - \lambda I) = 0

Pada contoh, persamaan karakteristiknya dihitung sebagai berikut.

\det \begin{pmatrix} 3-\lambda & 1 \\ 0 & 2-\lambda \end{pmatrix} = (3-\lambda)(2-\lambda) = 0

Persamaan itu terpenuhi pada $\lambda = 3$ dan $\lambda = 2$ , sama dengan hasil pemeriksaan arah di atas. Vektor eigennya kemudian dicari satu per satu dengan menyelesaikan $(A - \lambda I) v = 0$ untuk setiap $\lambda$ , yaitu tugas penyelesaian sistem yang sudah dikenal. Matriks dua kali dua paling banyak memiliki dua nilai eigen, dan matriks berukuran $n$ memiliki polinomial karakteristik berderajat $n$ yang akarnya adalah nilai eigennya.

Menghitung dengan np.linalg.eig#

Fungsi np.linalg.eig mengembalikan sepasang array, yaitu nilai-nilai eigen dan vektor eigennya yang dinormalkan berpanjang satu. Berkas berikut menghitung keduanya untuk matriks contoh.

python nilai_eigen.py

import numpy as np

A = np.array([[3.0, 1.0],
              [0.0, 2.0]])
nilai, vektor = np.linalg.eig(A)

print("nilai eigen :", np.round(nilai, 4))
print("vektor eigen:")
print(np.round(vektor, 4))

text Keluaran

nilai eigen : [3. 2.]
vektor eigen:
[[ 1.     -0.7071]
 [ 0.      0.7071]]

Nilai eigennya muncul sebagai array [3. 2.], dan setiap kolom pada array kedua adalah vektor eigen untuk nilai sebaris dengannya. Kolom pertama $(1, 0)$ cocok dengan perhitungan manual, sedangkan kolom kedua $(-0.7071, 0.7071)$ berpanjang satu dan arahnya sama dengan $(1, -1)$ karena $-0.7071 \approx -1/\sqrt{2}$ . Kelipatan skalar, termasuk yang negatif, tidak mengubah arah dalam pengertian eigen. Verifikasi berikut mengembalikan pasangan tersebut ke definisinya.

python periksa_eigen.py

import numpy as np

A = np.array([[3.0, 1.0],
              [0.0, 2.0]])
v = np.array([1.0, -1.0])

print("A @ v  :", A @ v)
print("2 * v  :", 2 * v)
print("Av = 2v:", np.allclose(A @ v, 2 * v))

text Keluaran

A @ v  : [ 2. -2.]
2 * v  : [ 2. -2.]
Av = 2v: True

Hasil $A v$ identik dengan $2 v$ , sehingga definisi terpenuhi dan pemilihan nilai eigen 2 untuk arah itu terkonfirmasi. Pemeriksaan semacam ini murah dan sebaiknya dilakukan setiap kali vektor eigen digunakan pada perhitungan lanjutan.

Taksiran lewat iterasi pangkat#

Aplikasi berukuran besar sering hanya membutuhkan nilai eigen terbesar nilai mutlaknya, yang disebut nilai eigen dominan. Nilai itu dapat ditaksir tanpa menyelesaikan polinomial karakteristik, yaitu dengan mengalikan suatu vektor awal berulang kali dengan $A$ . Setiap perkalian memperkuat sumbangan arah dominan dibandingkan arah lainnya, sehingga hasilnya mendekati vektor eigen dominan. Berkas berikut menerapkannya pada matriks simetris dengan nilai eigen 3 dan 1.

python iterasi_pangkat.py

import numpy as np

A = np.array([[2.0, 1.0],
              [1.0, 2.0]])
v = np.array([1.0, 0.0])

# taksiran nilai eigen dominan lewat suku Rayleigh v @ A @ v
for k in range(1, 7):
    v = A @ v
    v = v / np.linalg.norm(v)
    lam = v @ A @ v
    print(f"iterasi {k}: taksiran lambda = {lam:.4f}")

text Keluaran

iterasi 1: taksiran lambda = 2.8000
iterasi 2: taksiran lambda = 2.9756
iterasi 3: taksiran lambda = 2.9973
iterasi 4: taksiran lambda = 2.9997
iterasi 5: taksiran lambda = 3.0000
iterasi 6: taksiran lambda = 3.0000

Taksiran nilai eigen naik dari 2.8000 menuju 3.0000 dalam enam iterasi, dan vektor v yang terakhir mendekati arah $(1, 1)$ yang dinormalkan. Besaran lam dihitung dengan suku Rayleigh $v^T A v$ , yaitu nilai yang konstan sebesar $\lambda$ persis ketika v sudah menjadi vektor eigen. Normalisasi setiap iterasi menjaga panjang v tetap satu sehingga perkalian berulang tidak menghasilkan bilangan raksasa, sedangkan arahnya terus condong ke arah dominan. Konvergensinya lambat apabila dua nilai eigen terkuat memiliki nilai yang berdekatan, tetapi pola iterasinya tetap sederhana dan hanya memerlukan perkalian matriks-vektor.

Melihat arah eigen pada gambar#

Untuk matriks simetris, perilaku eigennya dapat dilukiskan dengan lingkaran satuan. Transformasi $A$ membentuk lingkaran menjadi elips, dan sumbu-sumbu elips itu tepat berada pada arah vektor eigennya. Gambar berikut menggunakan matriks yang sama dengan contoh iterasi pangkat, yaitu sumbu miring dengan $\lambda = 3$ dan sumbu tegak lurusnya dengan $\lambda = 1$ .

Lingkaran satuan menjadi elips dengan sumbu pada arah vektor eigen

Demo berikut menggambar vektor masukan $v$ dan keluaran $A v$ untuk matriks segitiga pada awal topik. Geser penggeser sudut sambil mengamati kedua panah, kemudian cari posisi ketika panah keluaran terletak pada garis putus-putus arah eigen, yaitu sekitar 0 dan 315 derajat. Pada posisi itu, panel status menyatakan arah dipertahankan, dan faktor peregangannya sama dengan nilai eigennya. Posisi 135 dan 180 derajat memberikan perilaku yang sama pada arah yang berlawanan, karena kelipatan negatif tetap merupakan vektor eigen.

Kode sumber demo

<!DOCTYPE html>
<html lang="id">
<head>
<meta charset="utf-8">
<title>Demo arah yang dipertahankan matriks</title>
<style>
  body { font-family: sans-serif; margin: 12px; color: #1a1a1a; }
  h1 { font-size: 15px; margin: 0 0 6px; }
  p { font-size: 13px; margin: 4px 0; }
  svg { width: 100%; height: auto; border: 1px solid #d0d0d0; background: #fafafa; }
  .kontrol { margin: 8px 0 4px; }
  .kontrol label { font-size: 13px; }
  .bacaan { font-size: 13px; margin: 4px 0; line-height: 1.5; }
  .status { font-size: 14px; font-weight: bold; margin: 6px 0 0; }
</style>
</head>
<body>
<h1>Arah yang dipertahankan matriks A = [[3, 1], [0, 2]]</h1>
<p>
  Panah biru: vektor masukan v (panjang satu). Panah oranye: keluaran A @ v.<br>
  Garis putus-putus: dua arah eigen matriksnya.
</p>
<svg id="kanvas" viewBox="0 0 440 330" aria-label="Grafik vektor v, keluaran A v, dan dua garis arah eigen"></svg>
<div class="kontrol">
  <label>sudut v (derajat):
    <input id="sudut" type="range" min="0" max="360" step="1" value="25">
  </label>
</div>
<p class="bacaan" id="bacaan"></p>
<p class="status" id="status"></p>
<script>
  // matriks contoh beserta arah eigennya
  const A = [[3, 1], [0, 2]];
  const svg = document.getElementById('kanvas');
  const NS = 'http://www.w3.org/2000/svg';

  // pemetaan koordinat matematis x (-4..4) dan y (-3..3) ke piksel
  const px = x => 20 + (x + 4) * 50;
  const py = y => 5 + (3 - y) * 50;

  function el(nama, attr) {
    const e = document.createElementNS(NS, nama);
    for (const k in attr) e.setAttribute(k, attr[k]);
    svg.appendChild(e);
    return e;
  }

  // kisi tipis setiap satu satuan
  for (let g = -4; g <= 4; g++) {
    el('line', {x1: px(g), y1: py(-3), x2: px(g), y2: py(3), stroke: '#e2e2e2'});
  }
  for (let g = -3; g <= 3; g++) {
    el('line', {x1: px(-4), y1: py(g), x2: px(4), y2: py(g), stroke: '#e2e2e2'});
  }
  el('line', {x1: px(-4), y1: py(0), x2: px(4), y2: py(0), stroke: '#909090'});
  el('line', {x1: px(0), y1: py(-3), x2: px(0), y2: py(3), stroke: '#909090'});

  // garis arah eigen: lambda = 3 pada arah (1, 0), lambda = 2 pada arah (1, -1)
  el('line', {x1: px(-4), y1: py(0), x2: px(4), y2: py(0),
              stroke: '#7a3e0a', 'stroke-dasharray': '6,4'});
  el('line', {x1: px(-3), y1: py(3), x2: px(3), y2: py(-3),
              stroke: '#7a3e0a', 'stroke-dasharray': '6,4'});
  const l1 = el('text', {x: px(2.6), y: py(0) - 8, 'font-size': 12, fill: '#7a3e0a'});
  l1.textContent = 'arah eigen \u03BB = 3';
  const l2 = el('text', {x: px(1.7), y: py(-1.7) + 26, 'font-size': 12, fill: '#7a3e0a'});
  l2.textContent = 'arah eigen \u03BB = 2';

  function panah(warna) {
    const g = el('g', {stroke: warna, fill: warna});
    const garis = el('line', {'stroke-width': 2.5, 'marker-end': 'url(#kepala' + warna.slice(1) + ')'});
    g.appendChild(garis);
    return garis;
  }
  const defs = el('defs', {});
  for (const c of ['#2171b5', '#e6550d']) {
    const m = document.createElementNS(NS, 'marker');
    m.setAttribute('id', 'kepala' + c.slice(1));
    m.setAttribute('markerWidth', '8');
    m.setAttribute('markerHeight', '8');
    m.setAttribute('refX', '6');
    m.setAttribute('refY', '3');
    m.setAttribute('orient', 'auto');
    const jalur = document.createElementNS(NS, 'path');
    jalur.setAttribute('d', 'M0,0 L7,3 L0,6 Z');
    jalur.setAttribute('fill', c);
    m.appendChild(jalur);
    defs.appendChild(m);
  }
  const panahV  = panah('#2171b5');
  const panahAv = panah('#e6550d');

  function fmt(v) {
    return v.toFixed(2).replace('.', ',').replace('-', '\u2212');
  }

  function gambar() {
    const derajat = parseFloat(document.getElementById('sudut').value);
    const rad = derajat * Math.PI / 180;
    const v = [Math.cos(rad), Math.sin(rad)];
    const av = [A[0][0] * v[0] + A[0][1] * v[1],
                A[1][0] * v[0] + A[1][1] * v[1]];
    panahV.setAttribute('x1', px(0));  panahV.setAttribute('y1', py(0));
    panahV.setAttribute('x2', px(v[0]));  panahV.setAttribute('y2', py(v[1]));
    panahAv.setAttribute('x1', px(0)); panahAv.setAttribute('y1', py(0));
    panahAv.setAttribute('x2', px(av[0])); panahAv.setAttribute('y2', py(av[1]));

    const faktor = Math.hypot(av[0], av[1]);
    document.getElementById('bacaan').textContent =
      'sudut: ' + derajat + '\u00B0   |   ' +
      'v = (' + fmt(v[0]) + ', ' + fmt(v[1]) + ')   |   ' +
      'A @ v = (' + fmt(av[0]) + ', ' + fmt(av[1]) + ')   |   ' +
      'faktor peregangan: ' + fmt(faktor);

    // searah bila keluaran tidak menyimpang dari arah masukannya
    const silang = Math.abs(v[0] * av[1] - v[1] * av[0]) / faktor;
    const sejajar = silang < 0.03 && (v[0] * av[0] + v[1] * av[1]) > 0;
    const status = document.getElementById('status');
    if (sejajar) {
      const lam = fmt(faktor);
      status.textContent = 'v terletak pada arah eigen: A @ v = ' + lam +
        ' \u00D7 v, arah dipertahankan.';
    } else {
      status.textContent = 'A @ v memutar arah v: arah belum dipertahankan.';
    }
  }
  document.getElementById('sudut').addEventListener('input', gambar);
  gambar();
</script>
</body>
</html>

Di mana hal ini ditemui dalam kode#

PCA pada machine learning bekerja dengan menghitung vektor eigen matriks kovarians data, yang arahnya menjadi sumbu komponen utama dan nilai eigennya menyatakan banyaknya variasi data pada tiap sumbu. PageRank menentukan pentingnya sebuah halaman dari vektor eigen dominan matriks tautan, dan perhitungannya menggunakan teknik iterasi pangkat pada matriks berukuran miliaran. Analisis getaran menilai kestabilan sebuah struktur dari nilai eigen matriks kekakuannya, sedangkan kompresi gambar berbasis singular value decomposition memanfaatkan nilai dan vektor eigen yang sama. Seluruh penerapan itu dapat diringkas menjadi satu kalimat inti, yaitu arah yang dipertahankan matriks menyimpan informasi paling padat tentangnya.

Ringkasan#

Vektor eigen adalah arah yang hanya diregangkan oleh transformasi, dengan hubungan $A v = \lambda v$ dan $\lambda$ sebagai faktor peregangannya.
Nilai eigen diperoleh dari persamaan karakteristik $\det(A - \lambda I) = 0$ , lalu vektornya dari sistem $(A - \lambda I) v = 0$ .
np.linalg.eig mengembalikan nilai eigen beserta vektor eigennya yang dinormalkan, dan hasilnya diverifikasi dengan np.allclose terhadap definisi.
Iterasi pangkat menaksir nilai eigen dominan dengan perkalian dan normalisasi berulang, pola yang sama dengan inti PageRank.

Referensi#

NumPy 2.1 documentation — NumPy — Dokumentasi np.linalg.eig dan np.linalg.eigh yang digunakan pada contoh perhitungan topik ini.
Mathematics for Machine Learning — Cambridge University Press — Buku terbuka yang menyusun nilai dan vektor eigen langsung menuju PCA pada machine learning.
MIT OpenCourseWare — Massachusetts Institute of Technology — Kuliah terbuka 18.06 Linear Algebra yang membahas nilai dan vektor eigen beserta penerapannya pada sistem dinamis.