深度学习blog- 数学基础（全是数学）

矩阵‌：矩阵是一个二维数组，通常由行和列组成，每个元素可以通过行索引和列索引进行访问。
张量‌：张量是一个多维数组的抽象概念，可以具有恣意数量的维度。除了标量（0D张量）、向量（1D张量）和矩阵（2D张量）外，张量还可以体现更高维度的数组。例如，一个3x3x2的三维张量
它是标量、向量、矩阵的高维扩展，属于一个数据容器。
张量由三个概念界说：
轴的个数（阶）
形状（shape）：为一个整数元组，体现张量沿每个轴的维度巨细（元素个数）。
数据类型（dtype）：这是整个张量中数据元素的数据类型，张量的类型可以是 float32 、 uint8 、 float64 等。
向量，是由n个数，构成的有序数组。有n个数，就有n维，称之为n维向量。向量可以横着写，称之为行向量，也可以竖着写，称之为列向量。向量是一种特别的矩阵。
向量之中的数，称之为该向量的分量，但是这些数，必须以有序的方式排列。为什么要以有序的方式呢？是因为数是有其特定内涵的。
而列向量是可以通过转置，变成行向量，行向量也可以通过转置变成列向量。
而如果所有的分量，都是0，称之为零向量。

矩阵A可逆，A必须是方阵（行数与列数相等的矩阵）。一个矩阵可逆的须要条件是它的行列式不为0，而行列式只对方阵界说。因此，只有方阵才有大概是可逆的。
如果n阶方阵A有n个线性无关的特征向量，那么矩阵A可以被相似对角化，且存在一个对角矩阵D（对角线上的元素是特征值）和一个可逆矩阵P（列是特征向量），使得：

这说明A与对角矩阵D相似。若特征向量的数量小于n，A就不能被对角化。
什么是矩阵的特征分解？
矩阵的特征分解是指将一个方阵表达为特征向量和特征值的组合形式。详细来说，对于一个n×n的可对角化矩阵A，有：

此中，D是一个对角矩阵，其对角线上的元素是A的特征值，而P是一个由A的特征向量构成的矩阵。
矩阵的特征分解实质上是一种矩阵的相似对角化形式，它表达矩阵的性子及其在特征向量基下的行为。
特征分解可以被视为一种特定的相似变更，此中重要关注的是特征值和对应特征向量。
求矩阵行列式和特征向量，逆矩阵、正交矩阵、陪同矩阵
‌高斯-约当消元法（初等变更法）‌：
通过初等行变更（交换行或线性计算）将矩阵转换为行最简形式（单位矩阵）。
同时对这些变更应用到单位矩阵上，最终得到的矩阵就是原矩阵的逆矩阵。
适用于任何可逆矩阵，但计算过程大概较为繁琐。
‌
行列式法‌：
对于2x2矩阵，可以直接通过计算其行列式及其逆行列式来写出逆矩阵。
对于3x3或更高阶的矩阵，可以利用克莱姆法则来求解，但计算量通常较大。
须要注意的是，行列式为零的矩阵不可逆。
‌
陪同矩阵法‌：
首先计算原矩阵的行列式。
如果行列式不为零，则计算原矩阵的每个元素的代数余子式。
将代数余子式矩阵转置，得到原矩阵的陪同矩阵。
最后，根据公式“逆矩阵 = 1/行列式 * 陪同矩阵”来计算逆矩阵。
‌
矩阵分解法‌：
如LU分解、QR分解、特征值分解和奇特值分解（SVD）等。
这些方法将矩阵分解为更简单的矩阵形式，然后分别对这些矩阵求逆，最后将得到的逆矩阵相乘得到原矩阵的逆。
适用于大规模矩阵或希奇矩阵，计算更为稳定和高效。
上三角矩阵的行列式计算非常直接，重要是找出对角线上元素的乘积。
NumPy库中的矩阵运算
首先确保你安装了NumPy库，如果没有安装，可以通过以下命令安装：
pip install numpy

1. import numpy as np  
3. # 创建一个全0的3x3矩阵  
4. zero_matrix = np.zeros((3, 3))  
5. print("全0矩阵:\n", zero_matrix)  
7. # 初始化一个上三角矩阵  
8. upper_triangle = np.triu(np.array([[1, 2, 3],   
9.                                      [4, 5, 6],   
10.                                      [7, 8, 9]]))  
11. print("上三角矩阵:\n", upper_triangle)  
13. # 初始化一个下三角矩阵
14. lower_triangle = np.tril(np.array([[1, 2, 3],   
15.                                      [4, 5, 6],   
16.                                      [7, 8, 9]]))  
17. print("下三角矩阵:\n", lower_triangle)  
19. # 初始化单位矩阵  
20. identity_matrix = np.eye(3)  
21. print("单位矩阵:\n", identity_matrix)
23. #a. 求矩阵的行列式
24. import numpy as np  
26. # 创建一个2x2矩阵  
27. A = np.array([[4, 2],  
28.               [3, 1]])  
30. # 计算行列式  
31. det_A = np.linalg.det(A)  
32. print("行列式:", det_A)  
35. #b. 矩阵的转置
36. # 矩阵转置  
37. A_transpose = A.T  
38. print("转置矩阵:\n", A_transpose)  
41. #c. 矩阵的逆
42. # 计算逆矩阵  
43. inv_A = np.linalg.inv(A)  
44. print("逆矩阵:\n", inv_A)
46.   
47. #d. 特征分解
48. # 特征值和特征向量  
49. eigenvalues, eigenvectors = np.linalg.eig(A)  
50. print("特征值:", eigenvalues)  
51. print("特征向量:\n", eigenvectors)
53.   
54. #e. 矩阵的仿射变换（例如线性变换）
55. # 线性变换  
56. B = np.array([1, 2])  # 输入向量  
57. affine_transform = np.dot(A, B)  
58. print("仿射变换结果:", affine_transform)  

复制代码

PyTorch库中的矩阵运算
确保你安装了PyTorch，这里利用的是CPU版本，如果你有GPU，可以选择相应版本：
pip install torch

1. import numpy as np  
2. import torch  
4. # PyTorch中的张量初始化
5. # 创建一个全0的3x3张量  
6. zero_tensor = torch.zeros((3, 3))  
7. print("全0张量:\n", zero_tensor)  
9. # 创建一个上三角张量  
10. upper_triangle_tensor = torch.triu(torch.tensor([[1, 2, 3],   
11.                                                   [4, 5, 6],   
12.                                                   [7, 8, 9]]))  
13. print("上三角张量:\n", upper_triangle_tensor)  
15. # 创建一个下三角张量  
16. lower_triangle_tensor = torch.tril(torch.tensor([[1, 2, 3],   
17.                                                   [4, 5, 6],   
18.                                                   [7, 8, 9]]))  
19. print("下三角张量:\n", lower_triangle_tensor)  
21. # 创建一个单位张量  
22. identity_tensor = torch.eye(3)  
23. print("单位张量:\n", identity_tensor)  
25. # 创建一个具有随机值的3x3张量  
26. random_tensor = torch.rand((3, 3))  
27. print("随机张量:\n", random_tensor)  
29. # 创建一个全1的3x3矩阵  
30. ones_matrix = np.ones((3, 3))  
31. print("全1矩阵:\n", ones_matrix)  
34. #a. 张量转置
35. # 创建一个张量  
36. A_torch = torch.tensor([[4, 2],  
37.                          [3, 1]])  
39. # 张量的转置  
40. A_transpose_torch = A_torch.t()  
41. print("转置张量:\n", A_transpose_torch)
43.   
44. #b. 张量的逆
45. # 计算逆张量  
46. inv_A_torch = torch.inverse(A_torch.float())  
47. print("逆张量:\n", inv_A_torch)
49.   
50. #c. 特征分解
51. # 特征值和特征向量  
52. eigenvalues_torch, eigenvectors_torch =  torch.linalg.eigvals(A_torch.float())  
53. print("特征值:\n", eigenvalues_torch)  
54. print("特征向量:\n", eigenvectors_torch)  
57. #d. 张量重塑 (view)
58. # 创建一个3x4的张量  
59. C = torch.tensor([[1, 2, 3, 4],  
60.                   [5, 6, 7, 8],  
61.                   [9, 10, 11, 12]])  
63. # 重塑为2x6的张量  
64. C_view = C.view(2, 6)  
65. print("重塑后的张量:\n", C_view)  
68. #e. 张量的广播和加法
69. # 创建两个张量  
70. D = torch.tensor([[1, 2, 3],  
71.                   [4, 5, 6]])  
73. # 张量加法  
74. E = D + 10  # 广播机制  
75. print("加法结果:\n", E)  
78. #其他常见运算
79. #a. 张量的散射（scatter）
81. # 创建一个全0的3x5张量  
82. F = torch.zeros(3, 5)  
84. # 确保索引在范围内  
85. # 这里的indices需要在0到5之间，因为F有5列  
86. indices = torch.tensor([[0, 1, 2], [0, 1, 2]])  # 合法索引  
87. values = torch.tensor(np.ones((2, 3)), dtype=torch.float32)  # 创建一个全1的2x3张量  
89. # 尝试通过scatter_函数进行散射  
90. # 1. 使用整数常量进行散射  
91. F.scatter_(0, indices, 2)  # 在第0维（行）进行散射  
92. print("散射结果（使用常量2）：\n", F)  
94. # 2. 使用values进行散射  
95. F.scatter_(1, indices, values)  # 在第1维（列）上进行散射  
96. print("散射结果（使用values）：\n", F)  
98. # 第一个参数表示维度，如果0表示行，那么第二个参数张量中的元素值表示行索引，元素所在的列表示列索引，
99. # 如果第一个参数是1，那么那么第二个参数张量中的元素值表示列索引，元素所在的行表示行索引，
100. # 用第三个参数去填充，如果第三个参数是张量，则从第三个参数张量中，取与第二参数张量相同位置的元素作为填充数据
103. # unsqueeze 用于在指定维度上增加一个维度。它的常见用法包括：1将一维张量转换为二维张量。2在需要维度匹配时，调整张量的形状。
104. x = torch.tensor([1, 2, 3])  # 形状为 (3,)  
105. y = x.unsqueeze(0)  # 形状变为 (1, 3)  
106. z = x.unsqueeze(1)  # 形状变为 (3, 1)

复制代码

另有两个函数在张量的处理和变更中非常常用：
view 用于更改张量的形状，而不改变数据。
cat 用于将多个张量在指定维度上连接成一个新的张量。

• tensor.view(shape): 张量重塑
  函数功能
  view 函数用于重塑张量的形状，不外它不改变张量的实际数据，只是改变它的体现方式。这个操作是包罗在 PyTorch 的计算图中，因此它是可微分的。
  

变更规则
必须满足条件：重塑后的巨细必须等于原始张量的元素总数。你不能随意改变张量的巨细；重塑后的形状的元素个数必须等于重塑前的元素个数。
支持负值：利用 -1 可以让 PyTorch 自动推断该维度的巨细。例如，如果你想重塑一个张量为二维张量，而不知道此中一维的巨细，可以用 view 函数中的 -1 作为占位符，PyTorch 会自动计算出相应的维度。
示例代码

1. import torch  
3. # 创建一个一维张量  
4. x = torch.tensor([1, 2, 3, 4, 5, 6])  
6. # 原始张量的形状  
7. print("原始张量形状:", x.shape)  
9. # 重塑为2行3列  
10. y = x.view(2, 3)  
11. print("重塑为2x3张量的形状:", y.shape)  
13. # 使用-1自动推断大小  
14. z = x.view(-1, 2)  # 把第一个维度自动推断为3，因为6/2=3  
15. print("重塑为3x2张量的形状:", z.shape)  
17. # 打印重塑后的张量内容  
18. print("重塑后的张量:\n", z)

复制代码

• torch.cat(tensors, dim): 张量拼接
  函数功能
  cat 函数用于将多个张量沿指定的维度拼接（连接）在一起。这个函数用于组合多个张量，而不是改变张量的维度。
  

变更规则
维度一致：除了拼接的维度外，其他维度的巨细必须相等。也就是说，拼接的张量在拼接维度之外的所有维度上都须要有相同的长度。
拼接维度：dim 参数指定了在哪个维度上进行拼接。0 代表按照行拼接，1 代表按照列拼接。

1. import torch  
3. # 创建两个相同维度的张量  
4. a = torch.tensor([[1, 2, 3], [4, 5, 6]])  
5. b = torch.tensor([[7, 8, 9], [10, 11, 12]])  
7. # 打印原始张量  
8. print("张量A:\n", a)  
9. print("张量B:\n", b)  
11. # 沿第0维（行）拼接  
12. c = torch.cat((a, b), dim=0)  
13. print("沿第0维拼接的结果:\n", c)  
15. # 沿第1维（列）拼接  
16. d = torch.cat((a, b), dim=1)  
17. print("沿第1维拼接的结果:\n", d)

复制代码

以下是一些常用的 PyTorch 张量操作函数：
a. 张量创建
torch.zeros(size)：创建全0张量。
torch.ones(size)：创建全1张量。
torch.empty(size)：创建未初始化的张量。
torch.rand(size)：创建随机值张量。
torch.eye(n)：创建单位矩阵。
b. 张量形状操作
tensor.view(shape)：重塑张量。
tensor.unsqueeze(dim)：在指定维度上增加一个维度。
tensor.squeeze(dim)：去除指定维度的巨细为1的维度。
tensor.permute(dims)：改变张量的维度顺序。
torch.cat(tensors, dim)：沿指定维度拼接多个张量。
c. 张量运算
torch.matmul(a, b)：矩阵乘法。
torch.add(a, b)：张量加法。
torch.subtract(a, b)：张量减法。
torch.multiply(a, b)：张量逐元素相乘。
torch.divide(a, b)：张量逐元素相除。
d. 张量统计
tensor.mean(dim)：计算均值。
tensor.sum(dim)：计算和。
tensor.max(dim)：计算最大值。
tensor.min(dim)：计算最小值。
e. 张量索引与切片
tensor[index]：索引单个元素。
tensor[start:end]：切片操作。
f. 其他操作
transpose(dim0, dim1)：交换两个维度。
transpose(-2, -1)交换最后两个维度，负数体现从里层开始算，正数体现从外层开始算。
torch.stack(tensors, dim)：在新维度上堆叠多个张量。
tensor.clone()：克隆一个张量。
泛化误差可分解为偏差、方差与噪声。
偏差：度量了模子算法的计算值与真值的偏离程度，反映模子算法的拟合能力。
方差：度量了同样巨细的训练集的变动所导致的学习性能的变革，数据扰动所造成的影响。
噪声：表达了在当前任务上任何学习算法所可以或许达到的期望泛化误差的下界，即学习问题自己的难度。
1、训练集的错误率较小，而验证集/测试集的错误率较大，说明模子存在较大方差，大概出现了过拟合（未思量到所有环境）。
2、训练集和测试集的错误率都较大，且两者相近，说明模子存在较大偏差，大概出现了欠拟合（算法不合适）。
3、训练集和测试集的错误率都较小，且两者相近，说明方差和偏差都较小，这个模子效果比较好，这是我们寻求的。
损失函数，度量了模子算法的计算值与真值的误差，
1 均方误差（Mean Squared Error, MSE）
界说：MSE 是回归问题中常用的损失函数，其计算方式为预测值与真实值之间差异的平方的平均值。
公式：

用途：广泛应用于回归问题，可以或许惩罚大误差（因为平方），但对非常值敏感。
2 交叉熵损失（Cross-Entropy Loss）
界说：交叉熵损失重要用于分类问题，尤其是多分类和二分类问题。它衡量了真实分布与预测分布之间的差异。
公式：

对于多分类：

广泛应用于分类问题，尤其是深度学习模子中的神经网络。
3 绝对误差（Mean Absolute Error, MAE）
界说：MAE 是另一种常用的回归损失函数，计算预测值与真实值之间绝对差的平均值。
公式：

梯度：简单概括，就是求导数或偏导数
梯度降落法：简单概括，就是往梯度方向的相反方向更新模子参数。
梯度（Gradient）是一个向量，它体现函数在某一点上沿各个方向的变革率。在深度学习中，梯度通常用于体现损失函数相对于网络参数的导数（或偏导数），即损失函数值随参数变革而变革的快慢和方向。
梯度的计算通常通过自动微分技术实现。自动微分利用计算图（Computational Graph）和链式法则自动计算梯度。计算图是一种体现函数计算过程的有向图，此中每个节点体现一个操作（如加法、乘法、激活函数等），每个边体现操作之间的依靠关系。在前向传播过程中，计算图记载了每个节点的输出和中心效果；在反向传播过程中，利用链式法则逐层计算每个节点的梯度，并将梯度传播到前面的节点。
反向传播：从输出层到输入层逐层计算误差梯度，并利用这些梯度更新网络参数以最小化损失函数。详细过程如下：
误差计算：从输出层开始，计算损失函数。
误差传播：将误差信息反向传播到隐藏层，逐层计算每个神经元的误差梯度。
参数更新：利用梯度降落或其他优化算法来更新网络中的权重和偏置参数，以最小化损失函数。
1、动量梯度降落（Gradient Descent with Momentum）
动量梯度降落的核生理念是，通过引入动量来加快梯度降落，提高收敛速度，尤其在高曲率的区域中。动量使得参数更新不但依靠于当前的梯度，还与之前的梯度有关系。

总结动量梯度降落的公式

2、RMSProp（Root Mean Square Prop）
RMSProp是由Geoff Hinton提出的一种自适应学习率的梯度降落方法，它通过计算梯度的平方的指数衰减平均值来调解学习率。这种方法在处理希奇梯度和不同特征标准时体现出色。
计算过程：

总结RMSProp的公式

动量梯度降落：通过引入历史梯度的动量，加快收敛速度，尤其在坡度较大的位置。
RMSProp：通过对每个参数的梯度平方进行指数加权平均，自适应调解学习率，有效应对希奇数据和不同特征标准的问题。
3、Adam算法
Adam（Adaptive Moment Estimation）优化算法联合了动量法（Momentum）和RMSProp算法的优点，可以或许自适应地调解每个参数的学习率。
算法步调：

Adam更新公式总结：
参数更新的最终公式为：

防止过拟合的方法：
正则化，即在损失函数中加入一个正则化项(惩罚项)，惩罚模子的复杂度，防止网络过拟合。
Droupout：随机的对神经网络每一层进行丢弃部分神经元操作。包管损失函数是单调降落的droupout才会有效。
数据增强，
指通过剪切、旋转/反射/翻变化更、缩放变更、平移变更、标准变更、对比度变更、噪声扰动、颜色变更等一种或多种组合数据增强变更的方式来增加数据集的巨细。
降维算法：
降维（Dimensionality Reduction）是机器学习中用来淘汰数据集特征数量的技术，其目标是在尽大概生存原始数据信息的同时降低数据的复杂度。降维不但可以加快模子训练、淘汰计算资源消耗，还能帮助消除噪声、提高模子性能，并且有助于可视化高维数据。

• 主成分分析 (PCA)
  通过对数据进行线性变更，找到新的正交基（主成分），以便在生存数据中最大方差的同时淘汰维度。PCA通过主成分分析找到数据的重要变革方向。
  通过计算数据矩阵的协方差矩阵，然后得到协方差矩阵的特征值特征向量，选择特征值最大(即方差最大)的k个特征所对应的特征向量组成的矩阵。如许就可以将数据矩阵转换到新的空间当中，实现数据特征的降维。
  

由于得到协方差矩阵的特征值特征向量有两种方法：特征值分解协方差矩阵、奇特值分解协方差矩阵，所以PCA算法有两种实现方法：基于特征值分解协方差矩阵实现PCA算法、基于SVD分解协方差矩阵实现PCA算法。
步调

1. import numpy as np
2. from scipy import linalg
3. from sklearn.datasets import load_iris
5. X,y = load_iris(return_X_y = True)
6. # 1、去中心化
7. B = X - X.mean(axis = 0)
8. B[:5]
10. # 2、协方差
11. # 方差是协方差特殊形式
12. # 协方差矩阵
13. V = np.cov(B,rowvar=False,bias = True)
14. print(V)
15. # 3、协方差矩阵的特征值和特征向量
16. # 特征值和特征向量矩阵的概念
17. eigen,ev = np.linalg.eig(V)
19. # 4、降维标准，2个特征，选取两个最大的特征值所对应的特征的特征向量
20. #  百分比，计算各特征值，占权重，累加可以
21. cond = (eigen/eigen.sum()).cumsum() >= 0.98
22. index = cond.argmax()
23. ev = ev[:,:index + 1]
25. # 5、进行矩阵运算
26. pca_result = B.dot(ev)
28. # 6、标准化
29. pca_result = (pca_result -pca_result.mean(axis = 0))/pca_result.std(axis = 0)
30. pca_result[:5]

复制代码

1. import numpy as np
2. from sklearn.decomposition import PCA
3. from sklearn.datasets import load_iris
5. # 加载数据
6. data = load_iris()
7. X = data.data
9. # PCA 降维到2维
10. pca = PCA(n_components=2)
11. X_reduced = pca.fit_transform(X)
13. print("降维后的数据:\n", X_reduced)

复制代码

• 线性判别分析 (LDA)
  LDA 是一种监视学习的方法，适用于分类问题。LDA 的目标在于通过最大化类间散度与类内散度之比，找到最佳的特征子空间，以区分不同类别的样本。
  

步调

1. from sklearn.discriminant_analysis import LinearDiscriminantAnalysis as LDA  
3. # 加载数据  
4. data = load_iris()  
5. X = data.data  
6. y = data.target  
8. # LDA 降维  
9. lda = LDA(n_components=2)  
10. X_reduced = lda.fit_transform(X, y)  
12. print("LDA 降维后的数据:\n", X_reduced)

复制代码

• 核主成分分析 (KPCA)
  KPCA 是 PCA 的扩展，通过利用核函数将数据映射到高维空间，在新的特征空间中实行 PCA，以捕捉数据中的非线性结构。
  

步调

1. from sklearn.datasets import load_iris  
2. from sklearn.decomposition import KernelPCA  
4. # 加载数据  
5. data = load_iris()  
6. X = data.data  
8. # KPCA 降维到2维  
9. kpca = KernelPCA(n_components=2, kernel='rbf')  
10. X_reduced = kpca.fit_transform(X)  
12. print("KPCA 降维后的数据:\n", X_reduced)

复制代码

• 局部线性嵌入 (LLE)
  LLE是一种非线性降维算法，假设数据点可以通过其近来邻的线性组合体现。LLE致力于保持这种局部线性结构。
  步调
  
  
  
  

1. from sklearn.manifold import LocallyLinearEmbedding  
3. # 加载数据  
4. data = load_iris()  
5. X = data.data  
7. # LLE 降维到2维  
8. lle = LocallyLinearEmbedding(n_components=2, n_neighbors=10)  
9. X_reduced = lle.fit_transform(X)  
11. print("LLE 降维后的数据:\n", X_reduced)

复制代码

• t-分布随机邻域嵌入 (t-SNE)
  t-SNE 是一种基于概率的降维方法，旨在生存相似数据点之间的间隔关系，特别适合用于数据可视化。它通过将高维空间中的数据点相似性转换为低维体现。
  

步调

1. from sklearn.manifold import TSNE  
3. # 加载数据  
4. data = load_iris()  
5. X = data.data  
7. # t-SNE 降维到2维  
8. tsne = TSNE(n_components=2, random_state=42)  
9. X_reduced = tsne.fit_transform(X)  
11. print("t-SNE 降维后的数据:\n", X_reduced)

复制代码

• 自编码器 (Autoencoder)
  自编码器是一种神经网络架构，旨在通过编码息争码结构来学习高效的低维体现，无监视学习的方式进行数据降维。网络的中心层实现降维。
  

步调
构建自编码器：界说一个编码器（将输入压缩到隐藏层）息争码器（从隐藏层重构输入）。
训练网络：利用重构误差（如均方误差）作为损失函数进行训练。
提取体现：利用训练好的编码器将输入数据映射到低维空间。

1. import numpy as np  
2. from keras.layers import Input, Dense  
3. from keras.models import Model  
5. # 构造自编码器  
6. input_dim = 4  # 输入数据维度  
7. encoding_dim = 2  # 降维后的维度  
9. # 输入层  
10. input_data = Input(shape=(input_dim,))  
11. # 编码层  
12. encoded = Dense(encoding_dim, activation='relu')(input_data)  
13. # 解码层  
14. decoded = Dense(input_dim, activation='sigmoid')(encoded)  
16. # 自编码器模型  
17. autoencoder = Model(input_data, decoded)  
18. autoencoder.compile(optimizer='adam', loss='mean_squared_error')  
20. # 训练自编码器  
21. data = load_iris().data  
22. autoencoder.fit(data, data, epochs=100, batch_size=10)  
24. # 获取编码器部分  
25. encoder = Model(input_data, encoded)  
26. X_reduced = encoder.predict(data)  
28. print("自编码器降维后的数据:\n", X_reduced)

复制代码

• 随机投影 (Random Projection)
  随机投影是基于Johnson-Lindenstrauss引理的一种简单而高效的降维方法。它通过将高维数据乘以一个随机生成的低维投影矩阵，将数据生存在低维空间中。
  

步调

1. from sklearn.random_projection import GaussianRandomProjection  
2. from sklearn.datasets import load_iris  
4. # 加载数据  
5. data = load_iris()  
6. X = data.data  
8. # 随机投影降维到2维  
9. rp = GaussianRandomProjection(n_components=2)  
10. X_reduced = rp.fit_transform(X)  
12. print("随机投影降维后的数据:\n", X_reduced)

复制代码

• 多维标准分析 (MDS)
  原理
  MDS是一种基于间隔矩阵的降维方法，它试图保持原始空间中数据点之间的间隔关系。在新的低维空间中，各点之间的间隔尽大概接近原始空间中的间隔。
  

步调
计算间隔矩阵：输入数据点之间的间隔（或相似度）。
多维标准映射：通过经典的MDS算法，将间隔矩阵转换为低维坐标。
优化：最小化指定的损失函数（如应生存的间隔差）。

1. from sklearn.manifold import MDS  
3. # 加载数据  
4. data = load_iris()  
5. X = data.data  
7. # 使用MDS降维到2维  
8. mds = MDS(n_components=2, random_state=42)  
9. X_reduced = mds.fit_transform(X)  
11. print("MDS 降维后的数据:\n", X_reduced)

复制代码

• Isomap
  

Isomap 是一种保持测地间隔的非线性降维方法。它联合了经典的多维标准分析和最短路径算法，捕捉数据在高维空间中的内在几何形状。
步调
构建毗邻图：确定每个点的 k 个近来邻，形成图。
计算最短路径：利用 Dijkstra 算法计算所有点对之间的最短路径。
构建间隔矩阵：形成新的间隔矩阵。
应用经典 MDS：对新的间隔矩阵利用经典 MDS 进行降维。

1. from sklearn.manifold import Isomap  
3. # 加载数据  
4. data = load_iris()  
5. X = data.data  
7. # 使用 Isomap 降维到2维  
8. isomap = Isomap(n_components=2, n_neighbors=5)  
9. X_reduced = isomap.fit_transform(X)  
11. print("Isomap 降维后的数据:\n", X_reduced)

复制代码

激活函数

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。