正交投影与内积空间：机器学习的几何基础

前言

本文隶属于专栏《机器学习数学通关指南》，该专栏为笔者原创，引用请注明来源，不足和错误之处请在评论区帮忙指出，谢谢！

本专栏目录结构和参考文献请见《机器学习数学通关指南》

正文

在这里插入图片描述

🔍 1. 内积空间的数学定义

1.1 代数定义 ✏️

两个维度相同的向量 $\mathbf{a} = [a_1, \dots, a_n]$ 和 $\mathbf{b} = [b_1, \dots, b_n]$ ，其内积为：

$\mathbf{a} \cdot \mathbf{b} = \sum_{i=1}^n a_i b_i$

内积结果为标量，是后续投影和正交性的计算基础。在Python中可以这样实现：

import numpy as np

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
dot_product = np.dot(a, b)  # 或简写为 a.dot(b) 或 a @ b
print(f"内积结果: {dot_product}")  # 输出: 内积结果: 32

1.2 几何定义 📐

从几何角度，向量 $\mathbf{a}$ 与向量 $\mathbf{b}$ 的内积为：

$\mathbf{a} \cdot \mathbf{b} = \|\mathbf{a}\| \|\mathbf{b}\| \cos\theta$

其中 $\theta$ 是两个向量的夹角。这一性质直接关联到正交投影的计算，并表明：

当 $\theta = 90°$ 时，内积为0（正交向量）
当 $\theta = 0°$ 时，内积最大（同向向量）
当 $\theta = 180°$ 时，内积为负（反向向量）

🚀 2. 正交投影的核心思想

2.1 投影的物理意义 💡

向量 $\mathbf{a}$ 在向量 $\mathbf{b}$ 上的正交投影反映了前者在后者方向上的"影子长度"（即分解到该方向的分量）：

$\text{投影长度} = \|\mathbf{a}\| \cos\theta = \frac{\mathbf{a} \cdot \mathbf{b}}{\|\mathbf{b}\|}$

投影向量则为：

$\text{投影向量} = \frac{\mathbf{a} \cdot \mathbf{b}}{\|\mathbf{b}\|^2} \mathbf{b}$

2.2 正交基与坐标表示 📊

在标准正交基下（如二维空间的基向量 $\mathbf{e}_1, \mathbf{e}_2$ ），向量 $\mathbf{v} = [v_1, v_2]^T$ 的坐标值实际上是其在基向量上的投影：

$v_1 = \mathbf{v} \cdot \mathbf{e}_1, \quad v_2 = \mathbf{v} \cdot \mathbf{e}_2$

这揭示了一个重要概念：内积空间的坐标系本质上建立在投影关系上。

🧩 3. 正交基的构造方法（Gram-Schmidt过程）

3.1 算法步骤 🔄

Gram-Schmidt正交化是将一组线性无关向量转换为正交基（甚至标准正交基）的经典方法：

从第一个向量开始，标准化得到第一个正交基向量
计算下一个向量在已有正交基上的投影
从原向量中减去这些投影分量，得到正交分量
标准化正交分量得到新的正交基向量
重复步骤2-4直到处理完所有向量

3.2 二维空间实例实现 🔨

如何将非正交基 $\{\mathbf{a}_1, \mathbf{a}_2\}$ 转化为正交基 $\{\mathbf{q}_1, \mathbf{q}_2\}$ ：

赋值 $\mathbf{q}_1 = \frac{\mathbf{a}_1}{\|\mathbf{a}_1\|}$
计算 $\mathbf{a}_2$ 到 $\mathbf{q}_1$ 的投影分量：
$\text{投影向量} = (\mathbf{a}_2 \cdot \mathbf{q}_1) \mathbf{q}_1$
去除投影分量后的正交向量：
$\mathbf{v}_2 = \mathbf{a}_2 - (\mathbf{a}_2 \cdot \mathbf{q}_1) \mathbf{q}_1$
标准化得：
$\mathbf{q}_2 = \frac{\mathbf{v}_2}{\|\mathbf{v}_2\|}$

生成的 $\{\mathbf{q}_1, \mathbf{q}_2\}$ 是标准正交基。

Python实现 🐍

def gram_schmidt(vectors):
    """将一组线性无关向量正交化"""
    basis = []
    for v in vectors:
        w = v.copy()  # 从原始向量开始
        for b in basis:
            # 减去在已有基向量上的投影
            w = w - np.dot(w, b) / np.dot(b, b) * b
        
        # 如果剩余向量不为零，则标准化并添加到基向量集
        if np.linalg.norm(w) > 1e-10:
            basis.append(w / np.linalg.norm(w))
            
    return np.array(basis)

# 示例
vectors = np.array([[1, 1], [1, 0]])
orthonormal_basis = gram_schmidt(vectors)
print("正交基:\n", orthonormal_basis)

# 验证正交性
dot_product = np.dot(orthonormal_basis[0], orthonormal_basis)
print(f"内积结果（应接近0）: {dot_product:.10f}")

🔬 4. 正交投影与矩阵表示

4.1 矩阵向量乘法的几何解释 📈

在标准正交基下，向量 $\mathbf{v}$ 的坐标可表示为：

$\mathbf{v}_{\text{投影}} = \begin{bmatrix} \mathbf{v} \cdot \mathbf{e}_1 \\ \mathbf{v} \cdot \mathbf{e}_2 \end{bmatrix}$

它等价于基向量组成的变换矩阵 $\mathbf{Q} = [\mathbf{e}_1 \quad \mathbf{e}_2]$ 的转置与向量的乘积：

$\mathbf{v}_{\text{投影}} = \mathbf{Q}^T \mathbf{v}$

4.2 投影矩阵 🔄

向量 $\mathbf{v}$ 投影到子空间 $W$ 上的投影矩阵为：

$\mathbf{P}_W = \mathbf{Q}(\mathbf{Q}^T\mathbf{Q})^{-1}\mathbf{Q}^T$

当 $\mathbf{Q}$ 是标准正交基时，简化为：

$\mathbf{P}_W = \mathbf{Q}\mathbf{Q}^T$

🌟 5. 机器学习中的应用实例

5.1 主成分分析 (PCA) 🧠

PCA是最常见的降维技术，其核心就是寻找数据最大方差方向的正交基，并在该基上投影：

import numpy as np
import matplotlib.pyplot as plt
from sklearn.decomposition import PCA

# 生成有相关性的二维数据
np.random.seed(42)
cov = [[2, 1.5], [1.5, 1]]
data = np.random.multivariate_normal([0, 0], cov, 500)

# 应用PCA
pca = PCA(n_components=2)
pca.fit(data)
transformed = pca.transform(data)

# 可视化
plt.figure(figsize=(12, 5))

# 原始数据
plt.subplot(1, 2, 1)
plt.scatter(data[:, 0], data[:, 1], alpha=0.5)
plt.title('原始数据')
plt.grid(True)

# PCA转换后的数据
plt.subplot(1, 2, 2)
plt.scatter(transformed[:, 0], transformed[:, 1], alpha=0.5)
for i, (comp, var) in enumerate(zip(pca.components_, pca.explained_variance_)):
    plt.quiver(0, 0, comp[0], comp, scale=var*3, color='r',
               label=f'PC{i+1}: {var:.2f}')
plt.title('PCA转换后数据')
plt.grid(True)
plt.legend()

plt.tight_layout()
plt.show()

print(f"主成分方差比例: {pca.explained_variance_ratio_}")
print(f"主成分方向: {pca.components_}")

5.2 QR分解与矩阵求解 🧮

QR分解是Gram-Schmidt正交化的矩阵形式，广泛用于线性方程组求解和最小二乘法问题：

import numpy as np

# 用于求解线性方程组 Ax = b
A = np.array([[2, 1], [1, 3]])
b = np.array([5, 4])

# QR分解
Q, R = np.linalg.qr(A)

# 求解方程 Rx = Q^T b
y = Q.T @ b
x = np.linalg.solve(R, y)

print("QR分解求解的解: ", x)
print("直接求解的解: ", np.linalg.solve(A, b))
print("误差: ", np.linalg.norm(A @ x - b))

5.3 核方法与支持向量机 🔍

在支持向量机(SVM)中，核函数实质上定义了特征空间中的内积，使我们能在高维空间中执行计算而无需显式映射：

from sklearn import svm
from sklearn.datasets import make_circles
from sklearn.model_selection import train_test_split
import numpy as np
import matplotlib.pyplot as plt

# 生成非线性可分数据
X, y = make_circles(n_samples=500, noise=0.1, factor=0.3, random_state=42)

# 分割数据集
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42)

# 训练RBF核SVM（本质是在高维空间中寻找正交超平面）
clf = svm.SVC(kernel='rbf', gamma=10)
clf.fit(X_train, y_train)

# 预测与评估
accuracy = clf.score(X_test, y_test)

# 绘制决策边界
h = 0.02
x_min, x_max = X[:, 0].min() - 0.1, X[:, 0].max() + 0.1
y_min, y_max = X[:, 1].min() - 0.1, X[:, 1].max() + 0.1
xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
                     np.arange(y_min, y_max, h))
Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)

plt.figure(figsize=(8, 6))
plt.contourf(xx, yy, Z, alpha=0.3, cmap=plt.cm.Paired)
plt.scatter(X[:, 0], X[:, 1], c=y, edgecolors='k', cmap=plt.cm.Paired)
plt.scatter(clf.support_vectors_[:, 0], clf.support_vectors_[:, 1],
            s=80, facecolors='none', edgecolors='k')
plt.title(f'RBF核SVM (准确率: {accuracy:.2f})')
plt.xlabel('特征1')
plt.ylabel('特征2')
plt.tight_layout()
plt.show()

5.4 正交化在神经网络中的应用 🧠

正交初始化和正交约束可以提高神经网络的训练稳定性和泛化能力：

import torch
import torch.nn as nn
import numpy as np

class OrthogonalRegularization(nn.Module):
    """实现权重正交化的正则项"""
    def __init__(self):
        super(OrthogonalRegularization, self).__init__()
    
    def forward(self, model, strength=1e-4):
        reg_loss = 0.0
        for name, param in model.named_parameters():
            if 'weight' in name:
                if param.ndimension() > 1:
                    # 计算 WW^T - I 的范数，鼓励权重矩阵正交
                    mat = param.view(param.shape[0], -1)
                    sym = torch.mm(mat, mat.t())
                    sym -= torch.eye(sym.shape[0]).to(param.device)
                    reg_loss += torch.sum(sym * sym)
        
        return strength * reg_loss

# 在训练循环中使用:
optimizer.zero_grad()
outputs = model(inputs)
loss = criterion(outputs, labels) + ortho_reg(model)
loss.backward()
optimizer.step()

🧮 6. 正交投影和内积空间的进阶应用

6.1 最小二乘法与线性回归 📊

最小二乘法是机器学习中最基础的模型之一，其解可以通过正交投影来理解：

$\hat{\beta} = (X^TX)^{-1}X^Ty$

这个公式本质上是将目标向量 $y$ 投影到 $X$ 的列空间上：

import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression

# 生成带噪声的线性数据
np.random.seed(42)
X = 2 * np.random.rand(100, 1)
y = 3 * X.squeeze() + 2 + np.random.randn(100) * 0.5

# 正交投影方法（手动实现最小二乘）
X_b = np.c_[np.ones((100, 1)), X]  # 添加偏置项
theta_best = np.linalg.inv(X_b.T @ X_b) @ X_b.T @ y
print(f"手动计算的系数: {theta_best}")

# 使用sklearn实现
reg = LinearRegression()
reg.fit(X, y)
print(f"sklearn系数: [{reg.intercept_}, {reg.coef_[0]}]")

# 绘制结果
plt.figure(figsize=(10, 6))
plt.scatter(X, y, alpha=0.7)
X_test = np.array([[0], ])
X_test_b = np.c_[np.ones((2, 1)), X_test]
y_pred = X_test_b @ theta_best
plt.plot(X_test, y_pred, 'r-', linewidth=2, label='预测线')
plt.xlabel('X')
plt.ylabel('y')
plt.title('通过正交投影实现的最小二乘法')
plt.grid(True)
plt.legend()
plt.show()

6.2 特征值分解与谱理论 🔮

正交性在特征值分解中表现为正交特征向量，这是许多算法的理论基础：

import numpy as np
import matplotlib.pyplot as plt

# 创建一个对称矩阵
A = np.array([[4, 2], [2, 3]])

# 特征值分解
eigenvalues, eigenvectors = np.linalg.eig(A)
print("特征值:", eigenvalues)
print("特征向量:\n", eigenvectors)

# 验证正交性
dot_product = np.dot(eigenvectors[:, 0], eigenvectors[:, 1])
print(f"特征向量内积（应接近0）: {dot_product:.10f}")

# 验证 Av = λv
for i in range(len(eigenvalues)):
    v = eigenvectors[:, i]
    lhs = A @ v
    rhs = eigenvalues[i] * v
    print(f"特征向量{i+1}的验证误差: {np.linalg.norm(lhs - rhs):.10f}")

# 可视化
plt.figure(figsize=(7, 7))
plt.axhline(y=0, color='k', linestyle='-', alpha=0.3)
plt.axvline(x=0, color='k', linestyle='-', alpha=0.3)
plt.grid(alpha=0.3)

# 绘制原始矩阵的作用
for i in range(-2, 3):
    for j in range(-2, 3):
        v = np.array([i, j]) * 0.5
        Av = A @ v
        plt.arrow(v[0], v, Av[0]-v[0], Av-v, 
                 head_width=0.1, head_length=0.2, fc='b', ec='b', alpha=0.3)

# 绘制特征向量
colors = ['red', 'green']
for i in range(len(eigenvalues)):
    v = eigenvectors[:, i] * eigenvalues[i]
    plt.arrow(0, 0, v[0], v, head_width=0.2, head_length=0.3, 
              fc=colors[i], ec=colors[i], label=f'特征向量{i+1} (λ={eigenvalues[i]:.2f})')

plt.xlim(-4, 4)
plt.ylim(-4, 4)
plt.title('特征向量与矩阵变换')
plt.legend()
plt.axis('equal')
plt.show()