0Pricing
Machine Learning Academy · 강의

데이터 투영 및 성분을 이용한 재구성

학습자는 데이터셋을 주성분 공간으로 변환하고 2차원 투영을 시각화한 뒤, 원래 특성을 재구성하여 정보 손실을 정량화합니다.

데이터 투영 및 성분을 이용한 재구성은(는) CoddyKit의 무료 Machine Learning Academy 강의입니다. 이것은 4개 중 2번째 강의입니다. 아래에서 전체 강의를 무료로 읽을 수 있으며, 내장 코드 에디터와 24/7 AI 튜터와 함께 브라우저에서 직접 실습할 수 있습니다. 이 강의는 Machine Learning Academy 학습 경로의 일부이며, 진행 상황이 웹과 CoddyKit 앱에 동기화됩니다. Machine Learning Academy 강의에는 총 4개의 강의가 포함되어 있습니다.

이 강의의 일부는 아직 번역되지 않았으며 영어로 표시됩니다.

Projection: From High-D to Low-D

After PCA finds the principal components, projection transforms each data point into the new component space. The projected coordinates are called scores. If you keep only 2 components from 64 original features, each 64-dimensional point becomes a 2-dimensional score. This is achieved by multiplying the centred data matrix by the matrix of eigenvectors (the loadings matrix).

The transform Method in sklearn

In scikit-learn, pca.fit(X) learns the components and pca.transform(X) projects the data. The convenience method pca.fit_transform(X) does both in one call. The result is a matrix of shape (n_samples, n_components) — each row is a point in the reduced space.

from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_digits

X, y = load_digits(return_X_y=True)  # 1797 x 64
X_scaled = StandardScaler().fit_transform(X)

pca = PCA(n_components=10)
X_reduced = pca.fit_transform(X_scaled)

print('Original shape:', X_scaled.shape)
print('Reduced shape:', X_reduced.shape)
print('Variance retained:', pca.explained_variance_ratio_.sum().round(4))

Visualising the 2D Projection

Projecting to 2 components gives a scatter plot where class separation is often visible even though labels were never used during PCA. This is an important exploratory tool: if classes are well-separated in 2D PCA space, a simple linear classifier may perform well in the full-dimensional space.

import matplotlib.pyplot as plt
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_digits

X, y = load_digits(return_X_y=True)
X_scaled = StandardScaler().fit_transform(X)

pca2 = PCA(n_components=2)
X_2d = pca2.fit_transform(X_scaled)

plt.figure(figsize=(8, 6))
for digit in range(10):
    mask = y == digit
    plt.scatter(X_2d[mask, 0], X_2d[mask, 1], label=str(digit), s=10, alpha=0.6)
plt.legend(title='Digit', bbox_to_anchor=(1, 1))
plt.title('MNIST digits in 2D PCA space')
plt.tight_layout()
plt.show()

Reconstruction: Going Back to Original Space

Reconstruction reverses the projection: multiply the reduced scores by the transpose of the loadings matrix and add back the mean. The result is an approximation of the original data in the original feature space. Perfect reconstruction is only possible if you kept all components; retaining fewer introduces reconstruction error.

from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_digits
import numpy as np

X, _ = load_digits(return_X_y=True)
X_scaled = StandardScaler().fit_transform(X)

pca = PCA(n_components=20)
X_reduced = pca.fit_transform(X_scaled)

# Reconstruct back to 64 dimensions
X_reconstructed = pca.inverse_transform(X_reduced)
print('Reconstruction shape:', X_reconstructed.shape)

# Mean squared reconstruction error
mse = np.mean((X_scaled - X_reconstructed) ** 2)
print(f'MSE: {mse:.4f}')

Visualising Reconstruction Quality

For image data, you can plot original and reconstructed images side by side. With more components retained, the reconstruction looks sharper. With very few components, digits become blurry blobs. This visual comparison is a powerful communication tool for showing stakeholders the trade-off between compression and information loss.

import matplotlib.pyplot as plt
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_digits

X, _ = load_digits(return_X_y=True)
X_scaled = StandardScaler().fit_transform(X)

fig, axes = plt.subplots(3, 5, figsize=(12, 7))
component_counts = [1, 2, 5, 10, 30]

for col, nc in enumerate(component_counts):
    pca = PCA(n_components=nc)
    X_r = pca.inverse_transform(pca.fit_transform(X_scaled))
    # Un-standardise for display (approximate)
    axes[0, col].imshow(X[0].reshape(8, 8), cmap='gray')
    axes[0, col].set_title(f'Original' if col == 0 else '')
    axes[1, col].imshow(X_r[0].reshape(8, 8), cmap='gray')
    axes[1, col].set_title(f'n={nc}')

plt.tight_layout()
plt.show()

Reconstruction Error vs Number of Components

Plot reconstruction MSE against the number of components to see the information-loss curve. This is the quantitative version of the visual comparison. A sharp decrease in MSE as you add the first few components mirrors the scree plot, confirming that most information lives in a small subspace.

import matplotlib.pyplot as plt
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_digits
import numpy as np

X, _ = load_digits(return_X_y=True)
X_scaled = StandardScaler().fit_transform(X)

components = [1, 2, 5, 10, 20, 30, 40, 50, 64]
mse_values = []
for nc in components:
    pca = PCA(n_components=nc)
    X_r = pca.inverse_transform(pca.fit_transform(X_scaled))
    mse_values.append(np.mean((X_scaled - X_r) ** 2))

plt.plot(components, mse_values, marker='o')
plt.xlabel('Number of components')
plt.ylabel('Reconstruction MSE')
plt.title('Information Loss vs Compression')
plt.show()

Interpretting Reconstruction Error

At zero components, reconstruction error equals the total variance of the data. At full components, error is zero. The ratio 1 - explained_variance_ratio.sum() tells you the fraction of variance discarded. For most practical ML pipelines, keeping 95–99% of variance (and discarding 1–5%) loses very little predictive signal while significantly reducing feature count and training time.

from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_digits

X, _ = load_digits(return_X_y=True)
X_scaled = StandardScaler().fit_transform(X)

for nc in [5, 10, 20, 30, 40]:
    pca = PCA(n_components=nc)
    pca.fit(X_scaled)
    retained = pca.explained_variance_ratio_.sum()
    print(f'n_components={nc:2d}  retained={retained:.3f}  discarded={1-retained:.3f}')

Using inverse_transform in Practice

pca.inverse_transform(X_reduced) is a method on the fitted PCA object. It returns the data in the original feature space but with the information from discarded components zeroed out. This is useful for anomaly detection: reconstruct training data and flag points with high reconstruction error as outliers that the PCA model could not represent well.

from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
import numpy as np

# Simulated normal vs anomalous points
X_normal = np.random.randn(100, 10)
X_anomaly = np.random.randn(5, 10) * 10  # far from origin

X_all = np.vstack([X_normal, X_anomaly])
X_scaled = StandardScaler().fit_transform(X_all)

pca = PCA(n_components=5)
X_r = pca.inverse_transform(pca.fit_transform(X_scaled))
errors = np.mean((X_scaled - X_r) ** 2, axis=1)

print('Max error index:', np.argmax(errors), '(anomalies start at index 100)')

Whitening: Decorrelated Components with Unit Variance

Setting PCA(whiten=True) scales the projected scores so each component has unit variance. This removes correlations between components and can improve the performance of algorithms like SVMs or neural networks that are sensitive to feature scale. Whitening is standard preprocessing before training on PCA-reduced features.

from sklearn.decomposition import PCA
from sklearn.datasets import load_iris
from sklearn.preprocessing import StandardScaler
import numpy as np

X, _ = load_iris(return_X_y=True)
X_scaled = StandardScaler().fit_transform(X)

pca_white = PCA(n_components=3, whiten=True)
X_w = pca_white.fit_transform(X_scaled)

print('Component variances (should be 1.0):', np.var(X_w, axis=0).round(4))

PCA Limitations on Non-Linear Data

PCA finds only linear projections. If data lies on a curved surface — like a Swiss roll — PCA projects onto a flat plane, destroying the manifold structure. In such cases, consider Kernel PCA with an RBF kernel or non-linear alternatives like t-SNE or UMAP for exploration. For model preprocessing, however, linear PCA is usually sufficient and much faster.

Project and Reconstruct: Complete Workflow

A clean PCA pipeline always follows the same pattern: standardise, fit PCA on training data, transform train and test separately, optionally reconstruct to inspect quality.

from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_digits
import numpy as np

X, y = load_digits(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)

scaler = StandardScaler()
X_train_s = scaler.fit_transform(X_train)
X_test_s = scaler.transform(X_test)  # use train scaler

pca = PCA(n_components=0.95)
X_train_r = pca.fit_transform(X_train_s)   # fit only on train
X_test_r = pca.transform(X_test_s)         # transform test

print(f'Reduced: {X_train_r.shape[1]} components from 64 features')

Quick Check

Test your understanding of PCA projection and reconstruction from this lesson.

Lesson Recap

In this lesson you learned: pca.transform projects data into component space with shape (n_samples, n_components), pca.inverse_transform reconstructs data in original feature space with information from discarded components lost, and reconstruction error quantifies information loss and can flag anomalies. Next up we explore t-SNE — a non-linear technique for 2D visualisation of high-dimensional data.

자주 묻는 질문

“데이터 투영 및 성분을 이용한 재구성” 강의는 무료인가요?

네 — “데이터 투영 및 성분을 이용한 재구성” 전체 내용을 이 웹사이트에서 무료로 읽을 수 있습니다. 인터랙티브하게 실습하려면(내장 코드 에디터와 24/7 AI 튜터), CoddyKit PRO로 업그레이드하면 Machine Learning Academy 강의 전체를 잠금 해제할 수 있습니다. Machine Learning Academy 강의에는 총 4개의 강의가 포함되어 있습니다.

“데이터 투영 및 성분을 이용한 재구성”에서 뭘 배우나요?

학습자는 데이터셋을 주성분 공간으로 변환하고 2차원 투영을 시각화한 뒤, 원래 특성을 재구성하여 정보 손실을 정량화합니다. 브라우저에서 직접 실행하는 실습 코드로 Machine Learning Academy을(를) 배우며, 24/7 AI 튜터가 강의를 진행하면서 질문에 답변해줍니다.

Machine Learning Academy을(를) 시작하는 데 경험이 필요한가요?

사전 경험은 필요하지 않습니다. CoddyKit의 Machine Learning Academy은(는) 초급자부터 고급 학습자까지를 위해 구성되어 있으므로, 여기서 시작하거나 처음부터 시작할 수 있으며 자신의 속도대로 진행할 수 있습니다. 이것은 4개 중 2번째 강의입니다.

“데이터 투영 및 성분을 이용한 재구성” 강의는 얼마나 걸리나요?

대부분의 CoddyKit 강의는 약 5~10분이 소요됩니다. 각 강의는 간결하고 인터랙티브하여 꾸준한 진행이 가능하며, 웹과 앱에서 중단한 부분부터 바로 시작할 수 있습니다.

이 Machine Learning Academy 강의에서 코드를 작성하고 실행할 수 있나요?

네. 모든 Machine Learning Academy 강의에는 내장 코드 에디터가 포함되어 있으므로, 브라우저에서 바로 실제 코드를 작성하고 실행한 후 즉시 AI 피드백을 받을 수 있습니다 — 로컬 설정이 필요 없습니다.

이 강의의 모든 강의

  1. PCA: 분산, 고유벡터 및 주성분
  2. 데이터 투영 및 성분을 이용한 재구성
  3. t-SNE: 시각화를 위한 이웃 구조 보존
  4. 전처리로서의 PCA: 파이프라인에서 속도 향상과 잡음 감소
← Machine Learning Academy(으)로 돌아가기