PCA: Varians, Vektor Eigen, dan Komponen Utama
Peserta akan menyesuaikan PCA pada dataset berdimensi tinggi, memeriksa rasio varians yang dijelaskan, dan memilih jumlah komponen yang mempertahankan 95% total varians.
PCA: Varians, Vektor Eigen, dan Komponen Utama adalah pelajaran Machine Learning Academy gratis di CoddyKit. Ini adalah pelajaran 1 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 Machine Learning Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Machine Learning Academy mencakup 4 pelajaran total.
Bagian dari pelajaran ini belum diterjemahkan dan ditampilkan dalam bahasa Inggris.
The Problem with High-Dimensional Data
As feature count grows, datasets become increasingly sparse — the curse of dimensionality. Many features are redundant or correlated, carrying overlapping information. Principal Component Analysis (PCA) solves this by finding a new, smaller set of axes (principal components) that capture the maximum variance in the data with the fewest dimensions.
Variance: What PCA Maximises
PCA seeks directions in feature space along which the data varies the most. A direction with high variance captures rich information; a direction with near-zero variance is essentially noise. The first principal component (PC1) is the direction of maximum variance, PC2 is orthogonal to PC1 with the next highest variance, and so on.
Covariance Matrix and Eigenvectors
PCA operates on the covariance matrix of the centred data. The eigenvectors of this matrix point in the directions of maximum variance, and the corresponding eigenvalues measure how much variance each direction captures. The eigenvectors are the principal components; sorting them by eigenvalue in descending order gives PC1, PC2, ... PCn.
import numpy as np
X = np.array([[2.5, 2.4], [0.5, 0.7], [2.2, 2.9],
[1.9, 2.2], [3.1, 3.0], [2.3, 2.7]])
# Centre the data
X_centered = X - X.mean(axis=0)
# Compute covariance matrix
cov = np.cov(X_centered.T)
print('Covariance matrix:\n', cov)
# Eigenvectors and eigenvalues
eigenvalues, eigenvectors = np.linalg.eigh(cov)
idx = np.argsort(eigenvalues)[::-1]
print('Eigenvalues:', eigenvalues[idx])
print('PC1 direction:', eigenvectors[:, idx[0]])Explained Variance Ratio
The explained variance ratio of each component is its eigenvalue divided by the sum of all eigenvalues. If PC1 explains 90% of variance and PC2 explains 8%, the first two components together retain 98% of all information. This ratio guides how many components to keep — a common threshold is 95%.
from sklearn.decomposition import PCA
from sklearn.datasets import load_digits
X, _ = load_digits(return_X_y=True) # 64 features
pca = PCA()
pca.fit(X)
cumulative_variance = pca.explained_variance_ratio_.cumsum()
n_95 = (cumulative_variance < 0.95).sum() + 1
print(f'Components to retain 95% variance: {n_95}')
print(f'Explained by first 10 components: {cumulative_variance[9]:.3f}')Choosing n_components
Set n_components as an integer (e.g., PCA(n_components=10)) to keep exactly 10 components, or as a float between 0 and 1 (e.g., PCA(n_components=0.95)) to automatically keep enough components to explain that fraction of variance. The latter is the cleanest approach for pipelines where you want variance-based truncation without knowing the count upfront.
from sklearn.decomposition import PCA
from sklearn.datasets import load_digits
X, _ = load_digits(return_X_y=True)
# Retain 95% of variance automatically
pca = PCA(n_components=0.95)
pca.fit(X)
print('Number of components chosen:', pca.n_components_)
print('Total variance retained:', pca.explained_variance_ratio_.sum().round(4))The Scree Plot
A scree plot shows explained variance ratio (or eigenvalue) on the y-axis and component index on the x-axis. The plot typically shows a steep drop then a flat plateau. The elbow — where the drop becomes gradual — is another heuristic for the number of components to retain, similar to the elbow method in K-Means.
import matplotlib.pyplot as plt
from sklearn.decomposition import PCA
from sklearn.datasets import load_wine
X, _ = load_wine(return_X_y=True)
pca = PCA()
pca.fit(X)
plt.figure(figsize=(8, 4))
plt.subplot(1, 2, 1)
plt.bar(range(1, 14), pca.explained_variance_ratio_)
plt.xlabel('Component')
plt.ylabel('Explained variance ratio')
plt.title('Scree Plot')
plt.subplot(1, 2, 2)
plt.plot(pca.explained_variance_ratio_.cumsum(), marker='o')
plt.axhline(0.95, color='red', linestyle='--')
plt.xlabel('Number of components')
plt.ylabel('Cumulative variance')
plt.tight_layout()
plt.show()Centering and Scaling Before PCA
PCA is sensitive to feature scale. A feature measured in thousands will dominate the covariance matrix. Always standardise with StandardScaler before PCA to give each feature unit variance. Centring (zero mean) is essential — PCA implicitly does this, but if you use a Pipeline, the scaler should come first so PCA operates on already-centred, equal-scale features.
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.datasets import load_wine
X, _ = load_wine(return_X_y=True)
pipe = Pipeline([
('scaler', StandardScaler()),
('pca', PCA(n_components=0.95))
])
pipe.fit(X)
print('Original shape:', X.shape)
print('Reduced shape:', pipe.transform(X).shape)What Do Principal Components Represent?
Each principal component is a linear combination of the original features — a weighted sum. Inspecting the component loadings (the coefficients) reveals which original features contribute most to each PC. However, components are often not directly interpretable because they mix features together. PCA is primarily a compression tool, not a feature selection tool.
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_wine
import pandas as pd
X, _ = load_wine(return_X_y=True)
X_scaled = StandardScaler().fit_transform(X)
pca = PCA(n_components=2)
pca.fit(X_scaled)
feature_names = load_wine().feature_names
loadings = pd.DataFrame(pca.components_.T, index=feature_names,
columns=['PC1', 'PC2'])
print(loadings.round(2))SVD: The Efficient Implementation
In practice, scikit-learn computes PCA via Singular Value Decomposition (SVD) rather than explicit eigendecomposition of the covariance matrix, because SVD is numerically more stable and works directly on the data matrix without forming the covariance matrix. The result is mathematically identical. For very large datasets, PCA(svd_solver='randomized') uses an approximate randomised SVD for speed.
PCA Is Linear and Orthogonal
Important limitations: PCA finds only linear relationships between features. If the meaningful structure in your data lies on a curved manifold (e.g., a Swiss roll), PCA will not discover it effectively — kernel PCA or t-SNE are better alternatives. Also, PCA components are orthogonal by construction, which can be a mismatch if your underlying factors are correlated.
PCA on a Real Dataset: Quick End-to-End
Here is the full workflow: scale, PCA to 2D, and scatter-plot with class colour to check if the reduced space still separates classes visually. This is a standard exploratory step before training a classifier on the full feature set.
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_iris
import matplotlib.pyplot as plt
X, y = load_iris(return_X_y=True)
X_scaled = StandardScaler().fit_transform(X)
pca = PCA(n_components=2)
X_2d = pca.fit_transform(X_scaled)
plt.scatter(X_2d[:, 0], X_2d[:, 1], c=y, cmap='Set1', s=30)
plt.xlabel(f'PC1 ({pca.explained_variance_ratio_[0]:.1%} var)')
plt.ylabel(f'PC2 ({pca.explained_variance_ratio_[1]:.1%} var)')
plt.title('Iris in PCA space')
plt.colorbar(label='Class')
plt.show()Quick Check
Test your understanding of PCA from this lesson.
Lesson Recap
In this lesson you learned: PCA finds directions of maximum variance via the covariance matrix eigenvectors, explained variance ratio guides how many components to keep (typically aim for 95%), and always standardise features before PCA so scale differences do not bias the components. Next up we project data into principal-component space and reconstruct it to quantify information loss.
Belajar Python dengan tutor AI — gratis
Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.
- Kursus
- 30
- Pelajaran
- 120
Pertanyaan yang Sering Diajukan
Apakah pelajaran “PCA: Varians, Vektor Eigen, dan Komponen Utama” gratis?
Ya — teks lengkap “PCA: Varians, Vektor Eigen, dan Komponen Utama” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Machine Learning Academy, upgrade ke CoddyKit PRO. Kursus Machine Learning Academy mencakup 4 pelajaran total.
Apa yang akan aku pelajari di “PCA: Varians, Vektor Eigen, dan Komponen Utama”?
Peserta akan menyesuaikan PCA pada dataset berdimensi tinggi, memeriksa rasio varians yang dijelaskan, dan memilih jumlah komponen yang mempertahankan 95% total varians. Kamu berlatih Machine Learning 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 Machine Learning Academy?
Tidak diperlukan pengalaman sebelumnya. Machine Learning 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 1 dari 4.
Berapa lama pelajaran “PCA: Varians, Vektor Eigen, dan Komponen Utama” 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 Machine Learning Academy ini?
Ya. Setiap pelajaran Machine Learning 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
- PCA: Varians, Vektor Eigen, dan Komponen Utama
- Memproyeksikan Data dan Merekonstruksinya dari Komponen
- t-SNE: Mempertahankan Ketetanggaan untuk Visualisasi
- PCA sebagai Prapemrosesan: Kecepatan dan Pengurangan Derau dalam Pipeline