PCA: Dimensionality Reduction Explained

Juan Luis Ramirez10 min read
Machine LearningPCADimensionality ReductionPython

If you've ever worked with datasets containing dozens or hundreds of features, you've likely encountered the "curse of dimensionality"—where training times skyrocket, models overfit, and visualization becomes an impossible task. Fortunately, Principal Component Analysis (PCA) offers a mathematically elegant and practically powerful escape route.

The Curse of Dimensionality

As the number of features in your dataset grows, several problems emerge:

  • Sparse data: Data points become increasingly distant from each other in high-dimensional space
  • Computational cost: Training time and memory usage grow exponentially
  • Overfitting: Models struggle to generalize when features outnumber samples
  • Visualization: You can't plot 50 dimensions on a 2D screen

The curse of dimensionality isn't just a theoretical concern. It's a practical bottleneck that affects real-world machine learning pipelines every day.

What is PCA and Why Is It Useful?

Principal Component Analysis is a technique that transforms your original features into a new set of uncorrelated variables called principal components. These components are ordered by how much variance they capture from the original data.

The key insight is that many features in real datasets are correlated. PCA exploits these correlations to represent the same information with fewer dimensions, keeping only the components that matter most.

Why use PCA?

  1. Reduce computational cost: Fewer features mean faster training
  2. Combat overfitting: Remove noise and redundant information
  3. Enable visualization: Project high-dimensional data to 2D or 3D
  4. Improve model performance: Sometimes simpler is better
  5. Feature extraction: Discover latent patterns in your data

The Math Behind PCA

Don't worry, we'll keep this intuitive. But understanding the fundamentals will help you use PCA more effectively.

Variance and Covariance

Variance measures how spread out a single variable is. Covariance measures how two variables change together. If two features have high covariance, they contain redundant information.

import numpy as np
 
# Sample data: height (cm) and weight (kg)
height = np.array([170, 175, 180, 165, 190])
weight = np.array([70, 75, 80, 65, 90])
 
# Variance
var_height = np.var(height)  # How spread out heights are
var_weight = np.var(weight)  # How spread out weights are
 
# Covariance
cov_matrix = np.cov(height, weight)
print(f"Covariance matrix:\n{cov_matrix}")

The covariance matrix is the foundation of PCA. It tells us which features vary together.

Eigenvectors and Eigenvalues

Here's where the magic happens. When we compute the eigenvectors and eigenvalues of the covariance matrix:

  • Eigenvectors point in the directions of maximum variance (the principal components)
  • Eigenvalues tell us how much variance exists in each direction

Think of it like this: if your data forms an elongated cloud, the first eigenvector points along the longest axis of that cloud.

# Compute eigenvectors and eigenvalues
eigenvalues, eigenvectors = np.linalg.eig(cov_matrix)
 
print(f"Eigenvalues: {eigenvalues}")
print(f"Eigenvectors:\n{eigenvectors}")

Principal Components

The principal components are simply our original data projected onto the eigenvectors. The first principal component captures the most variance, the second captures the most remaining variance while being orthogonal to the first, and so on.

# Center the data
X = np.column_stack([height, weight])
X_centered = X - X.mean(axis=0)
 
# Project onto principal components
principal_components = X_centered @ eigenvectors
 
print(f"Original shape: {X.shape}")
print(f"Principal components shape: {principal_components.shape}")

How to Choose the Number of Components

This is one of the most common questions when applying PCA. There are several approaches:

1. Explained Variance Threshold

Keep enough components to explain a certain percentage of variance (commonly 95% or 99%):

from sklearn.decomposition import PCA
from sklearn.datasets import load_digits
 
# Load a real dataset
digits = load_digits()
X = digits.data  # 64 features (8x8 pixel images)
 
# Fit PCA with all components
pca_full = PCA()
pca_full.fit(X)
 
# Calculate cumulative explained variance
cumulative_variance = np.cumsum(pca_full.explained_variance_ratio_)
 
# Find number of components for 95% variance
n_components_95 = np.argmax(cumulative_variance >= 0.95) + 1
print(f"Components needed for 95% variance: {n_components_95}")

2. The Elbow Method

Plot explained variance vs. number of components and look for an "elbow" where adding more components provides diminishing returns.

3. Domain Knowledge

Sometimes the task dictates the number: 2 or 3 for visualization, or a specific number based on prior knowledge about your data.

Explained Variance Ratio

The explained variance ratio tells you what fraction of the total variance each principal component captures:

import matplotlib.pyplot as plt
 
# Visualize explained variance
fig, axes = plt.subplots(1, 2, figsize=(14, 5))
 
# Individual explained variance
axes[0].bar(range(1, 21), pca_full.explained_variance_ratio_[:20])
axes[0].set_xlabel('Principal Component')
axes[0].set_ylabel('Explained Variance Ratio')
axes[0].set_title('Variance Explained by Each Component')
 
# Cumulative explained variance
axes[1].plot(range(1, 65), cumulative_variance, 'b-o', markersize=4)
axes[1].axhline(y=0.95, color='r', linestyle='--', label='95% threshold')
axes[1].axvline(x=n_components_95, color='g', linestyle='--',
                label=f'{n_components_95} components')
axes[1].set_xlabel('Number of Components')
axes[1].set_ylabel('Cumulative Explained Variance')
axes[1].set_title('Cumulative Variance Explained')
axes[1].legend()
 
plt.tight_layout()
plt.savefig('pca_variance_explained.png', dpi=150)
plt.show()

Python Implementation with Scikit-Learn

Let's put it all together with a complete, runnable example:

import numpy as np
import matplotlib.pyplot as plt
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_iris
 
# Load the Iris dataset
iris = load_iris()
X = iris.data  # 4 features
y = iris.target
feature_names = iris.feature_names
target_names = iris.target_names
 
print(f"Original shape: {X.shape}")
print(f"Features: {feature_names}")
 
# Step 1: Standardize the data (crucial for PCA!)
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
 
# Step 2: Apply PCA
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X_scaled)
 
print(f"Reduced shape: {X_pca.shape}")
print(f"Explained variance ratio: {pca.explained_variance_ratio_}")
print(f"Total variance explained: {sum(pca.explained_variance_ratio_):.2%}")
 
# Step 3: Visualize the results
plt.figure(figsize=(10, 8))
 
colors = ['navy', 'turquoise', 'darkorange']
for color, i, target_name in zip(colors, [0, 1, 2], target_names):
    plt.scatter(X_pca[y == i, 0], X_pca[y == i, 1],
                color=color, alpha=0.8, lw=2,
                label=target_name, s=60)
 
plt.xlabel(f'PC1 ({pca.explained_variance_ratio_[0]:.1%} variance)')
plt.ylabel(f'PC2 ({pca.explained_variance_ratio_[1]:.1%} variance)')
plt.title('PCA of Iris Dataset')
plt.legend(loc='best', shadow=False, scatterpoints=1)
plt.grid(True, alpha=0.3)
 
plt.tight_layout()
plt.savefig('pca_iris_visualization.png', dpi=150)
plt.show()

Visualizing High-Dimensional Data in 2D/3D

PCA shines when you need to visualize complex datasets. Here's how to create both 2D and 3D visualizations:

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_digits
 
# Load digits dataset (64 dimensions)
digits = load_digits()
X = digits.data
y = digits.target
 
print(f"Original dimensions: {X.shape[1]}")
 
# Standardize
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
 
# PCA to 2D and 3D
pca_2d = PCA(n_components=2)
pca_3d = PCA(n_components=3)
 
X_2d = pca_2d.fit_transform(X_scaled)
X_3d = pca_3d.fit_transform(X_scaled)
 
# Create visualizations
fig = plt.figure(figsize=(16, 6))
 
# 2D Plot
ax1 = fig.add_subplot(121)
scatter = ax1.scatter(X_2d[:, 0], X_2d[:, 1], c=y, cmap='tab10',
                      alpha=0.6, s=10)
ax1.set_xlabel(f'PC1 ({pca_2d.explained_variance_ratio_[0]:.1%})')
ax1.set_ylabel(f'PC2 ({pca_2d.explained_variance_ratio_[1]:.1%})')
ax1.set_title('Digits Dataset - 2D PCA')
plt.colorbar(scatter, ax=ax1, label='Digit')
 
# 3D Plot
ax2 = fig.add_subplot(122, projection='3d')
scatter3d = ax2.scatter(X_3d[:, 0], X_3d[:, 1], X_3d[:, 2],
                        c=y, cmap='tab10', alpha=0.6, s=10)
ax2.set_xlabel('PC1')
ax2.set_ylabel('PC2')
ax2.set_zlabel('PC3')
ax2.set_title('Digits Dataset - 3D PCA')
 
plt.tight_layout()
plt.savefig('pca_digits_visualization.png', dpi=150)
plt.show()
 
print(f"2D: {sum(pca_2d.explained_variance_ratio_):.1%} variance explained")
print(f"3D: {sum(pca_3d.explained_variance_ratio_):.1%} variance explained")

PCA for Data Preprocessing

PCA is often used as a preprocessing step in machine learning pipelines. Here's a complete example showing how PCA can improve model training:

import numpy as np
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline
from sklearn.datasets import load_digits
import time
 
# Load data
digits = load_digits()
X, y = digits.data, digits.target
 
# Split data
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)
 
# Pipeline WITHOUT PCA
pipeline_no_pca = Pipeline([
    ('scaler', StandardScaler()),
    ('classifier', LogisticRegression(max_iter=1000, random_state=42))
])
 
# Pipeline WITH PCA (keeping 95% variance)
pipeline_pca = Pipeline([
    ('scaler', StandardScaler()),
    ('pca', PCA(n_components=0.95)),  # Keep 95% of variance
    ('classifier', LogisticRegression(max_iter=1000, random_state=42))
])
 
# Compare performance
print("=== Without PCA ===")
start = time.time()
scores_no_pca = cross_val_score(pipeline_no_pca, X_train, y_train, cv=5)
time_no_pca = time.time() - start
print(f"Accuracy: {scores_no_pca.mean():.4f} (+/- {scores_no_pca.std()*2:.4f})")
print(f"Training time: {time_no_pca:.2f}s")
print(f"Features: {X_train.shape[1]}")
 
print("\n=== With PCA (95% variance) ===")
start = time.time()
scores_pca = cross_val_score(pipeline_pca, X_train, y_train, cv=5)
time_pca = time.time() - start
 
# Fit to see how many components were kept
pipeline_pca.fit(X_train, y_train)
n_components = pipeline_pca.named_steps['pca'].n_components_
 
print(f"Accuracy: {scores_pca.mean():.4f} (+/- {scores_pca.std()*2:.4f})")
print(f"Training time: {time_pca:.2f}s")
print(f"Features after PCA: {n_components}")
print(f"Dimension reduction: {X_train.shape[1]} -> {n_components} "
      f"({(1-n_components/X_train.shape[1])*100:.1f}% reduction)")

When to Use PCA (and When Not To)

PCA is powerful, but it's not always the right choice. Here's a practical guide:

Use PCA When:

  • You have many correlated features: PCA thrives on redundancy
  • Visualization is needed: Project to 2D or 3D for exploration
  • Computational resources are limited: Reduce feature count before training
  • You suspect noise in your features: PCA can filter out low-variance noise
  • Building a preprocessing pipeline: Standard practice for many ML workflows

Avoid PCA When:

  • Features are already independent: PCA won't help much
  • Interpretability is crucial: Principal components lose feature meanings
  • You have categorical data: PCA is designed for continuous variables
  • Non-linear relationships dominate: Consider t-SNE or UMAP instead
  • Your dataset is small: PCA needs enough samples to estimate covariance reliably

Alternatives to Consider:

# For non-linear dimensionality reduction
from sklearn.manifold import TSNE
from sklearn.decomposition import KernelPCA
 
# t-SNE (great for visualization, not for preprocessing)
tsne = TSNE(n_components=2, random_state=42)
X_tsne = tsne.fit_transform(X_scaled)
 
# Kernel PCA (captures non-linear relationships)
kpca = KernelPCA(n_components=2, kernel='rbf')
X_kpca = kpca.fit_transform(X_scaled)

Conclusion

PCA is one of those fundamental techniques that every data scientist should master. It's mathematically elegant, computationally efficient, and surprisingly effective in practice.

Key takeaways:

  1. Always standardize your data before applying PCA
  2. Use explained variance to decide how many components to keep
  3. PCA is linear - for complex, non-linear relationships, consider alternatives
  4. Interpretability decreases as you move to principal component space
  5. Start simple - often 2-3 components are enough for visualization

The next time you're staring at a dataset with hundreds of features, remember that PCA might be the key to unlocking its secrets. Start with visualization, understand the variance structure, and let the principal components guide your analysis.

In future posts, we'll explore more advanced techniques like Independent Component Analysis (ICA) and autoencoders for non-linear dimensionality reduction.

Back to Blog