线性代数在AI中的应用：数据表示、降维

import numpy as np

# ==================== 图像的矩阵表示 ====================
# 一张 3x3 的灰度图像，每个像素值在 0~255 之间
# 0 表示黑色，255 表示白色，中间值表示灰色
gray_image = np.array([
    [  0, 128, 255],   # 第一行像素：黑、灰、白
    [ 64, 192,  32],   # 第二行像素：深灰、浅灰、深色
    [200, 100, 150]    # 第三行像素：浅灰、中灰、灰
], dtype=np.float32)   # 使用 float32 类型，AI 中常用

print("灰度图像矩阵形状:", gray_image.shape)  # (3, 3) 表示 3行3列
print("灰度图像矩阵:\n", gray_image)

# ==================== 彩色图像的张量表示 ====================
# 彩色图像有 RGB 三个通道，所以是三维张量
# 形状为 (高, 宽, 3)，3 代表 R/G/B 三个颜色通道
rgb_image = np.array([
    [[255, 0, 0], [0, 255, 0], [0, 0, 255]],       # 第一行：红、绿、蓝
    [[255, 255, 0], [255, 0, 255], [0, 255, 255]],  # 第二行：黄、品红、青
    [[128, 128, 128], [255, 255, 255], [0, 0, 0]]   # 第三行：灰、白、黑
], dtype=np.float32)

print("\n彩色图像张量形状:", rgb_image.shape)  # (3, 3, 3) 三维张量
print("第一个像素的RGB值:", rgb_image[0, 0])  # [255, 0, 0] 红色像素

# ==================== 文本的向量表示 ====================
# 最简单的方式：词袋模型（Bag of Words）
# 假设词汇表只有 5 个词：["我", "爱", "AI", "学习", "编程"]
vocabulary = ["我", "爱", "AI", "学习", "编程"]

# 句子 "我爱AI" 的向量表示
sentence1 = "我爱AI"
# 统计每个词出现的次数，生成向量
vec1 = np.array([1, 1, 1, 0, 0], dtype=np.float32)  # 我1次、爱1次、AI1次、学习0次、编程0次

# 句子 "我爱学习编程" 的向量表示
sentence2 = "我爱学习编程"
vec2 = np.array([1, 1, 0, 1, 1], dtype=np.float32)  # 我1次、爱1次、AI0次、学习1次、编程1次

print("\n句子1向量:", vec1)
print("句子2向量:", vec2)

# ==================== 用户画像的特征向量 ====================
# 一个用户可以用多个特征来描述
# 特征：[年龄归一化, 月消费额归一化, 登录频率归一化, 购买次数归一化]
user_a = np.array([0.25, 0.80, 0.60, 0.45], dtype=np.float32)  # 年轻、高消费、中等活跃
user_b = np.array([0.70, 0.30, 0.90, 0.85], dtype=np.float32)  # 年长、低消费、高活跃

print("\n用户A特征向量:", user_a)
print("用户B特征向量:", user_b)

# ==================== 计算两个用户的相似度（余弦相似度） ====================
# 余弦相似度衡量两个向量方向的相似程度，值域 [-1, 1]
# 1 表示完全相同方向，0 表示正交（无关），-1 表示完全相反
def cosine_similarity(a, b):
    """计算两个向量的余弦相似度"""
    # np.dot 计算点积，np.linalg.norm 计算向量的模（长度）
    dot_product = np.dot(a, b)           # 点积：对应位置相乘再求和
    norm_a = np.linalg.norm(a)           # 向量 a 的长度
    norm_b = np.linalg.norm(b)           # 向量 b 的长度
    similarity = dot_product / (norm_a * norm_b)  # 余弦相似度公式
    return similarity

sim = cosine_similarity(user_a, user_b)
print(f"\n用户A与B的余弦相似度: {sim:.4f}")
print("（值越接近1，两个用户越相似）")

import numpy as np

# ==================== 模拟词向量 ====================
# 实际中词向量由 Word2Vec/GloVe 等算法在大语料上训练得到
# 这里我们手动构造一个简化的 3 维词向量空间来理解概念
# 三个维度分别代表：[皇权程度, 性别男性度, 年龄成年度]

word_vectors = {
    "国王": np.array([0.95, 0.90, 0.85]),   # 高皇权、男性、成年
    "女王": np.array([0.95, 0.10, 0.85]),   # 高皇权、女性、成年
    "男人": np.array([0.10, 0.90, 0.80]),   # 低皇权、男性、成年
    "女人": np.array([0.10, 0.10, 0.80]),   # 低皇权、女性、成年
    "王子": np.array([0.60, 0.85, 0.30]),   # 中皇权、男性、年轻
    "公主": np.array([0.60, 0.15, 0.30]),   # 中皇权、女性、年轻
    "猫":   np.array([0.01, 0.50, 0.20]),   # 无皇权、性别中性、年轻
    "苹果": np.array([0.00, 0.00, 0.10]),   # 无皇权、无性别、无年龄
}

# ==================== 词向量的神奇运算：语义加减法 ====================
# 经典例子：国王 - 男人 + 女人 ≈ 女王
# 这说明词向量空间中存在"方向"的概念
# "男性→女性"是一个方向，"国王→女王"也沿着这个方向

result = word_vectors["国王"] - word_vectors["男人"] + word_vectors["女人"]
print("国王 - 男人 + 女人 =", result.round(2))

# 计算结果与"女王"的相似度
def cosine_similarity(a, b):
    """计算余弦相似度"""
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

# 找出与计算结果最相似的词
best_word = None
best_sim = -1
for word, vec in word_vectors.items():
    sim = cosine_similarity(result, vec)
    if sim > best_sim:
        best_sim = sim
        best_word = word

print(f"最接近的词是: '{best_word}'，相似度: {best_sim:.4f}")

# ==================== 词语相似度矩阵 ====================
# 计算所有词对之间的余弦相似度
words = list(word_vectors.keys())
n = len(words)
sim_matrix = np.zeros((n, n))

for i in range(n):
    for j in range(n):
        sim_matrix[i][j] = cosine_similarity(word_vectors[words[i]], word_vectors[words[j]])

print("\n词语相似度矩阵（部分）:")
print(f"{'':>6}", end="")
for w in words[:5]:
    print(f"{w:>8}", end="")
print()
for i in range(5):
    print(f"{words[i]:>6}", end="")
    for j in range(5):
        print(f"{sim_matrix[i][j]:>8.2f}", end="")
    print()

# ==================== 嵌入在AI中的实际应用 ====================
# 1. 文本分类：将整段文本的词向量平均，得到文本向量，送入分类器
# 2. 语义搜索：将查询和文档都转为向量，用余弦相似度匹配
# 3. 推荐系统：将用户行为和物品都嵌入到同一向量空间

# 示例：用词向量平均得到句子向量
def sentence_vector(sentence_words, word_vec_dict):
    """将句子中所有词的向量取平均，得到句子向量"""
    vectors = []
    for w in sentence_words:
        if w in word_vec_dict:
            vectors.append(word_vec_dict[w])
    if len(vectors) == 0:
        return np.zeros(3)  # 如果没有匹配的词，返回零向量
    return np.mean(vectors, axis=0)  # 取平均值

# 两个句子的语义相似度
sentence1_words = ["国王", "女王"]
sentence2_words = ["王子", "公主"]

sv1 = sentence_vector(sentence1_words, word_vectors)
sv2 = sentence_vector(sentence2_words, word_vectors)

sim = cosine_similarity(sv1, sv2)
print(f"\n'国王女王' 与 '王子公主' 的语义相似度: {sim:.4f}")
print("（都是皇室成员，语义相近，相似度高）")

import numpy as np

# ==================== PCA 的完整实现步骤 ====================

# 第一步：生成模拟数据（2维数据，方便可视化理解）
np.random.seed(42)  # 设置随机种子，确保结果可复现

# 生成一组沿着某个方向分布的 2D 数据点
n_samples = 100  # 样本数量
# 原始数据沿 45 度方向分布，有一定的散布
mean = [0, 0]  # 均值
# 协方差矩阵：控制数据的分布方向和散布程度
# [[3, 2], [2, 3]] 表示 x 和 y 正相关，数据沿 45 度方向拉伸
cov = [[3, 2], [2, 3]]
X = np.random.multivariate_normal(mean, cov, n_samples)  # 生成多元正态分布数据

print("原始数据形状:", X.shape)  # (100, 2) 100个样本，2个特征
print("原始数据前5个样本:\n", X[:5].round(2))

# 第二步：数据中心化（减去均值）
# PCA 要求先对每个特征减去其均值，使数据中心在原点
X_mean = np.mean(X, axis=0)  # 计算每个特征的均值，axis=0 按列求均值
X_centered = X - X_mean       # 每个样本减去均值

print("\n数据中心化后均值:", X_centered.mean(axis=0).round(10))  # 应该接近 [0, 0]

# 第三步：计算协方差矩阵
# 协方差矩阵衡量各特征之间的线性相关性
# 对角线元素是各特征的方差，非对角线元素是特征间的协方差
cov_matrix = np.cov(X_centered, rowvar=False)  # rowvar=False 表示每列是一个特征

print("\n协方差矩阵:\n", cov_matrix.round(4))

# 第四步：对协方差矩阵做特征值分解
# 特征值表示该方向上的方差大小（信息量）
# 特征向量表示该主成分的方向
eigenvalues, eigenvectors = np.linalg.eigh(cov_matrix)  # eigh 适用于对称矩阵

# 按特征值从大到小排序
idx = np.argsort(eigenvalues)[::-1]  # 降序排列的索引
eigenvalues = eigenvalues[idx]
eigenvectors = eigenvectors[:, idx]

print("\n特征值（从大到小）:", eigenvalues.round(4))
print("特征向量（每列是一个主成分方向）:\n", eigenvectors.round(4))

# 第五步：计算方差解释比例
# 每个主成分解释了多少比例的总方差
explained_variance_ratio = eigenvalues / np.sum(eigenvalues)
print("\n各主成分的方差解释比例:", explained_variance_ratio.round(4))
print(f"第一主成分解释了 {explained_variance_ratio[0]*100:.1f}% 的方差")
print(f"第二主成分解释了 {explained_variance_ratio[1]*100:.1f}% 的方差")

# 第六步：选择主成分并投影（降维）
# 如果我们降到 1 维，只保留第一主成分
n_components = 1  # 目标维度
W = eigenvectors[:, :n_components]  # 取前 n_components 个特征向量组成投影矩阵

print(f"\n投影矩阵 W 形状: {W.shape}")  # (2, 1)
print("投影矩阵 W:\n", W.round(4))

# 将原始数据投影到低维空间
X_pca = X_centered @ W  # 矩阵乘法完成投影

print(f"\n降维后数据形状: {X_pca.shape}")  # (100, 1)
print("降维后数据前5个样本:\n", X_pca[:5].round(4))

# 第七步：重建（从低维回到高维，会有信息损失）
X_reconstructed = X_pca @ W.T + X_mean  # 反投影并加回均值
reconstruction_error = np.mean((X - X_reconstructed) ** 2)  # 均方重建误差
print(f"\n重建均方误差: {reconstruction_error:.4f}")
print("（降到1维时，丢失了第二主成分的信息，所以有重建误差）")

import numpy as np

# ==================== 维度灾难的直观演示 ====================
# 在高维空间中，随机点之间的距离趋于相同，"近邻"概念失效

def avg_pairwise_distance(n_dims, n_points=1000, n_trials=5):
    """计算 n_dims 维空间中随机点对的平均距离"""
    distances = []
    for _ in range(n_trials):
        # 在 [0,1]^n_dims 超立方体中随机生成点
        points = np.random.rand(n_points, n_dims)
        # 计算所有点对之间的欧氏距离（采样部分点对以节省计算）
        for i in range(min(100, n_points)):
            for j in range(i+1, min(100, n_points)):
                dist = np.linalg.norm(points[i] - points[j])  # 欧氏距离
                distances.append(dist)
    return np.mean(distances), np.std(distances)

# 不同维度下的平均距离和标准差
print("维度 | 平均距离 | 距离标准差 | 标准差/均值")
print("-" * 55)
for dim in [2, 5, 10, 50, 100]:
    avg, std = avg_pairwise_distance(dim, n_points=500, n_trials=3)
    ratio = std / avg if avg > 0 else 0
    print(f"{dim:>4} | {avg:>8.4f} | {std:>9.4f} | {ratio:.4f}")

print("\n观察：随着维度增加，标准差/均值比越来越小")
print("这意味着高维空间中所有点对距离趋于相同，'近邻'概念失效！")

# ==================== 降维保留信息的衡量 ====================
# 用"重建误差"衡量降维损失了多少信息

np.random.seed(42)
# 生成 50 维数据，但只有 5 个维度真正有信息
n_samples = 200
n_features = 50
n_informative = 5  # 真正有信息的维度数

# 构造数据：前5维有较大方差，后45维只有微小噪声
informative_part = np.random.randn(n_samples, n_informative) * 10  # 信号强
noise_part = np.random.randn(n_samples, n_features - n_informative) * 0.1  # 噪声弱
X_high = np.hstack([informative_part, noise_part])  # 拼接成 50 维数据

# 中心化
X_centered = X_high - X_high.mean(axis=0)

# 计算协方差矩阵和特征值
cov_mat = np.cov(X_centered, rowvar=False)
eigenvalues, eigenvectors = np.linalg.eigh(cov_mat)
idx = np.argsort(eigenvalues)[::-1]
eigenvalues = eigenvalues[idx]

# 计算累积方差解释比例
cumulative_ratio = np.cumsum(eigenvalues) / np.sum(eigenvalues)

print("\n\n累积方差解释比例（前10个主成分）:")
for k in range(10):
    print(f"  前 {k+1} 个主成分: {cumulative_ratio[k]*100:.2f}%")

# 只需5个主成分就能解释几乎全部方差
print(f"\n前5个主成分解释了 {cumulative_ratio[4]*100:.2f}% 的方差")
print("这说明50维数据中只有5个'有效维度'，降维到5维几乎不损失信息")

# ==================== 不同降维维度的重建误差 ====================
print("\n不同降维维度的重建误差:")
print("目标维度 | 重建误差(MSE) | 方差解释比例")
print("-" * 50)

for k in [1, 3, 5, 10, 20, 50]:
    W_k = eigenvectors[:, idx][:, :k]  # 取前 k 个特征向量
    X_proj = X_centered @ W_k           # 投影到 k 维
    X_recon = X_proj @ W_k.T + X_high.mean(axis=0)  # 重建
    mse = np.mean((X_high - X_recon) ** 2)  # 均方误差
    var_ratio = cumulative_ratio[k-1]
    print(f"  {k:>4} 维 | {mse:>12.4f} | {var_ratio*100:.2f}%")

import numpy as np

# ==================== 用numpy实现一个简单的神经网络前向传播 ====================

def relu(x):
    """ReLU 激活函数：max(0, x)"""
    return np.maximum(0, x)

def softmax(x):
    """Softmax 函数：将向量转为概率分布"""
    # 减去最大值防止数值溢出
    exp_x = np.exp(x - np.max(x, axis=-1, keepdims=True))
    return exp_x / np.sum(exp_x, axis=-1, keepdims=True)

# ==================== 网络结构定义 ====================
# 一个简单的 3 层神经网络：输入4维 → 隐藏层8维 → 隐藏层6维 → 输出3维
# 可以理解为：4个特征 → 8个中间表示 → 6个中间表示 → 3个类别概率

np.random.seed(42)

# 第一层权重和偏置：4 → 8
W1 = np.random.randn(4, 8) * 0.1   # 权重矩阵，小随机值初始化
b1 = np.zeros(8)                     # 偏置向量，初始化为0

# 第二层权重和偏置：8 → 6
W2 = np.random.randn(8, 6) * 0.1
b2 = np.zeros(6)

# 第三层权重和偏置：6 → 3
W3 = np.random.randn(6, 3) * 0.1
b3 = np.zeros(3)

print("网络参数形状:")
print(f"  W1: {W1.shape}, b1: {b1.shape}")
print(f"  W2: {W2.shape}, b2: {b2.shape}")
print(f"  W3: {W3.shape}, b3: {b3.shape}")

# ==================== 单样本前向传播 ====================
# 输入一个样本（4维向量）
x_single = np.array([0.5, -0.3, 0.8, 0.1])  # 4个特征值

# 第一层：线性变换 + ReLU激活
z1 = x_single @ W1 + b1     # 线性变换：4维 → 8维
a1 = relu(z1)                # 非线性激活

# 第二层：线性变换 + ReLU激活
z2 = a1 @ W2 + b2           # 线性变换：8维 → 6维
a2 = relu(z2)                # 非线性激活

# 第三层：线性变换 + Softmax激活
z3 = a2 @ W3 + b3           # 线性变换：6维 → 3维
output = softmax(z3)         # 输出概率分布

print(f"\n单样本前向传播:")
print(f"  输入: {x_single}")
print(f"  第一层输出 (z1): {z1.round(3)}")
print(f"  第一层激活 (a1): {a1.round(3)}")
print(f"  第二层输出 (z2): {z2.round(3)}")
print(f"  第二层激活 (a2): {a2.round(3)}")
print(f"  最终输出概率: {output.round(4)}")
print(f"  预测类别: {np.argmax(output)} (概率: {output.max():.4f})")

# ==================== 批量前向传播（矩阵运算的威力） ====================
# 同时处理 32 个样本，利用矩阵乘法的并行性
batch_size = 32
X_batch = np.random.randn(batch_size, 4)  # 32个样本，每个4维

# 批量前向传播：一次矩阵乘法处理所有样本
Z1 = X_batch @ W1 + b1    # (32, 4) @ (4, 8) → (32, 8)
A1 = relu(Z1)

Z2 = A1 @ W2 + b2         # (32, 8) @ (8, 6) → (32, 6)
A2 = relu(Z2)

Z3 = A2 @ W3 + b3         # (32, 6) @ (6, 3) → (32, 3)
outputs = softmax(Z3)

print(f"\n批量前向传播:")
print(f"  输入批次形状: {X_batch.shape}")
print(f"  输出批次形状: {outputs.shape}")
print(f"  前3个样本的预测类别: {np.argmax(outputs[:3], axis=1)}")
print(f"  GPU可以并行处理这些矩阵运算，这就是深度学习快的原因！")

# ==================== 参数量计算 ====================
total_params = (W1.size + b1.size) + (W2.size + b2.size) + (W3.size + b3.size)
print(f"\n网络总参数量: {total_params}")
print(f"  = (4×8+8) + (8×6+6) + (6×3+3) = {4*8+8} + {8*6+6} + {6*3+3} = {total_params}")
print("  每个参数都是权重矩阵中的一个元素，训练就是优化这些数值")

import numpy as np

# ==================== 从零实现 PCA 类 ====================

class PCAReducer:
    """用numpy从零实现的PCA降维器"""
    
    def __init__(self, n_components=None, variance_threshold=None):
        """
        初始化PCA降维器
        
        参数:
            n_components: 目标维度数（直接指定保留几个主成分）
            variance_threshold: 方差解释比例阈值（如0.95表示保留95%方差）
        """
        self.n_components = n_components          # 目标维度
        self.variance_threshold = variance_threshold  # 方差阈值
        self.mean_ = None       # 训练数据的均值（用于中心化）
        self.components_ = None  # 主成分方向（特征向量）
        self.eigenvalues_ = None # 特征值
        self.explained_variance_ratio_ = None  # 方差解释比例
        self.n_components_ = None  # 实际保留的主成分数
    
    def fit(self, X):
        """
        在数据上拟合PCA模型
        
        参数:
            X: 数据矩阵，形状 (n_samples, n_features)
        """
        # 第一步：计算并保存均值，用于中心化
        self.mean_ = np.mean(X, axis=0)  # 每个特征的均值
        X_centered = X - self.mean_       # 中心化
        
        # 第二步：计算协方差矩阵
        n_samples = X_centered.shape[0]
        cov_matrix = (X_centered.T @ X_centered) / (n_samples - 1)
        
        # 第三步：特征值分解
        eigenvalues, eigenvectors = np.linalg.eigh(cov_matrix)
        
        # 第四步：按特征值降序排列
        idx = np.argsort(eigenvalues)[::-1]
        eigenvalues = eigenvalues[idx]
        eigenvectors = eigenvectors[:, idx]
        
        # 第五步：计算方差解释比例
        total_variance = np.sum(eigenvalues)
        self.explained_variance_ratio_ = eigenvalues / total_variance
        
        # 第六步：确定保留的主成分数
        if self.n_components is not None:
            # 直接指定维度数
            self.n_components_ = self.n_components
        elif self.variance_threshold is not None:
            # 根据方差阈值自动确定维度数
            cumulative = np.cumsum(self.explained_variance_ratio_)
            self.n_components_ = np.searchsorted(cumulative, self.variance_threshold) + 1
        else:
            # 默认保留所有主成分
            self.n_components_ = len(eigenvalues)
        
        # 保存结果
        self.eigenvalues_ = eigenvalues
        self.components_ = eigenvectors[:, :self.n_components_]  # 取前k个特征向量
        
        return self
    
    def transform(self, X):
        """
        将数据投影到低维空间
        
        参数:
            X: 数据矩阵，形状 (n_samples, n_features)
        返回:
            降维后的数据，形状 (n_samples, n_components_)
        """
        X_centered = X - self.mean_  # 用训练时的均值中心化
        return X_centered @ self.components_  # 矩阵乘法完成投影
    
    def fit_transform(self, X):
        """拟合并转换"""
        self.fit(X)
        return self.transform(X)
    
    def inverse_transform(self, X_reduced):
        """
        从低维空间重建高维数据
        
        参数:
            X_reduced: 降维后的数据
        返回:
            重建的高维数据（会有信息损失）
        """
        return X_reduced @ self.components_.T + self.mean_
    
    def summary(self):
        """打印PCA结果摘要"""
        print(f"PCA降维摘要:")
        print(f"  原始维度: {self.components_.shape[0]}")
        print(f"  降维后维度: {self.n_components_}")
        print(f"  保留方差比例: {np.sum(self.explained_variance_ratio_[:self.n_components_])*100:.2f}%")
        print(f"\n  各主成分方差解释比例:")
        for i in range(min(self.n_components_, 10)):
            print(f"    PC{i+1}: {self.explained_variance_ratio_[i]*100:.2f}%")

# ==================== 实战：对高维数据进行PCA降维 ====================
np.random.seed(42)

# 模拟一个用户行为数据集：1000个用户，20个行为特征
n_users = 1000
n_features = 20

# 构造数据：只有5个独立的信息源，其余是它们的线性组合+噪声
n_sources = 5
sources = np.random.randn(n_users, n_sources) * np.array([10, 5, 3, 2, 1])[:, np.newaxis].T

# 随机混合矩阵：将5个源混合成20个特征
mix_matrix = np.random.randn(n_sources, n_features)
X = sources @ mix_matrix + np.random.randn(n_users, n_features) * 0.5  # 加少量噪声

print("=" * 60)
print("实战：用户行为数据的PCA降维")
print("=" * 60)
print(f"\n原始数据: {n_users} 个用户, {n_features} 个行为特征")

# 方式1：指定保留95%的方差
pca_auto = PCAReducer(variance_threshold=0.95)
X_reduced = pca_auto.fit_transform(X)
pca_auto.summary()

# 方式2：指定保留5个主成分
pca_k5 = PCAReducer(n_components=5)
X_reduced_k5 = pca_k5.fit_transform(X)
print(f"\n指定保留5个主成分:")
print(f"  降维后数据形状: {X_reduced_k5.shape}")
print(f"  保留方差比例: {np.sum(pca_k5.explained_variance_ratio_[:5])*100:.2f}%")

# ==================== 评估降维效果 ====================
# 重建误差：降维后重建，与原始数据比较
X_reconstructed = pca_k5.inverse_transform(X_reduced_k5)
mse = np.mean((X - X_reconstructed) ** 2)
total_var = np.mean(X ** 2)
print(f"\n降维效果评估:")
print(f"  重建均方误差(MSE): {mse:.4f}")
print(f"  原始数据总方差: {total_var:.4f}")
print(f"  相对误差: {mse/total_var*100:.2f}%")

# ==================== 数据压缩比 ====================
original_size = n_users * n_features  # 原始数据需要的存储量
compressed_size = n_users * 5 + 5 * n_features + n_features  # 降维数据 + 投影矩阵 + 均值
compression_ratio = original_size / compressed_size
print(f"\n数据压缩:")
print(f"  原始存储量: {original_size} 个数值")
print(f"  压缩后存储量: {compressed_size} 个数值")
print(f"  压缩比: {compression_ratio:.2f}x")
print(f"  （用约 {100/compression_ratio:.0f}% 的空间保留了 {np.sum(pca_k5.explained_variance_ratio_[:5])*100:.1f}% 的信息）")