diff --git a/.DS_Store b/.DS_Store new file mode 100644 index 00000000..80e0543a Binary files /dev/null and b/.DS_Store differ diff --git a/README.md b/README.md index bcbbe450..29aa84ad 100644 --- a/README.md +++ b/README.md @@ -153,9 +153,9 @@ * [拉普拉斯特征映射(Laplacian Eigenmaps)](https://github.com/KeKe-Li/tutorial/blob/master/assets/src/DRA/DRA.0.7.md) * [t－分布随机近邻嵌入(t-SNE)](https://github.com/KeKe-Li/tutorial/blob/master/assets/src/DRA/DRA.0.8.md) * [深度自动编码器(Deep Autoencoder Networks)](https://github.com/KeKe-Li/tutorial/blob/master/assets/src/DRA/DRA.0.9.md) - * [集成算法]() - * [Boosting]() - * [Bagging]() + * [集成算法(Ensemble Learning)](https://github.com/KeKe-Li/tutorial/blob/master/assets/src/EL/EL.0.1.md) + * [Boosting](https://github.com/KeKe-Li/tutorial/blob/master/assets/src/EL/EL.0.2.md) + * [Bagging](https://github.com/KeKe-Li/tutorial/blob/master/assets/src/EL/EL.0.3.md) * [AdaBoost]() * [堆叠泛化（混合）]() * [GBM 算法]() @@ -171,7 +171,27 @@ * [迁移学习]() 算法模型的整体基本就是这样目录，后续的算法模型我会不断完善和补充，更新！ + +#### 大模型LLM + +大型语言模型（LLM,Large Language Model）伴随着chatgpt的诞生，走进了我们的视野，GPT 3.0它不仅仅是一项具体的技术，其实体现的是LLM应该往何处去的一个发展理念。 + +自此之后，差距拉得越来越远，ChatGPT只是这种发展理念差异的一个自然结果。 + +那么什么是大语言模型呢， 我们深入探索和学习下。 + +大型语言模型（LLM）是基于大量数据进行预训练的超大型深度学习模型。底层转换器是一组神经网络，这些神经网络由具有自注意力功能的编码器和解码器组成。编码器和解码器从一系列文本中提取含义，并理解其中的单词和短语之间的关系。 + +转换器 LLM 能够进行无监督的训练，但更精确的解释是转换器可以执行自主学习。通过此过程，转换器可学会理解基本的语法、语言和知识。 + +与早期按顺序处理输入的循环神经网络（RNN）不同，转换器并行处理整个序列。这可让数据科学家使用 GPU 训练基于转换器的 LLM，从而大幅度缩短训练时间。 + +借助转换器神经网络架构，您可使用非常大规模的模型，其中通常具有数千亿个参数。这种大规模模型可以摄取通常来自互联网的大量数据，但也可以从包含 500 多亿个网页的 Common Crawl 和拥有约 5700 万个页面的 Wikipedia 等来源摄取数据。 + +* [走进大语言模型LLM)](https://github.com/KeKe-Li/tutorial/blob/master/assets/src/LLM/llm.md) + #### 机器学习的基础 + * 机器学习需要的理论基础：数学，线性代数，数理统计，概率论，高等数学、凸优化理论，形式逻辑等 #### 参考书籍 @@ -194,7 +214,10 @@ ### 机器学习 -觉得此文章不错，支持我的话可以给我star ，:star:！如果有问题可以加我的微信**Sen0676**,加入我们的交流群一起交流机器学习！ +觉得此文章不错，支持我的话可以给我star ，:star:！ 如果有问题可以加我的微信,也可以加入我们的交流群一起交流技术！ +

+ +

### License This is free software distributed under the terms of the MIT license diff --git a/assets/images/438.jpg b/assets/images/438.jpg new file mode 100644 index 00000000..c491823b Binary files /dev/null and b/assets/images/438.jpg differ diff --git a/assets/images/439.jpg b/assets/images/439.jpg new file mode 100644 index 00000000..3a8d2531 Binary files /dev/null and b/assets/images/439.jpg differ diff --git a/assets/images/440.jpg b/assets/images/440.jpg new file mode 100644 index 00000000..9114a740 Binary files /dev/null and b/assets/images/440.jpg differ diff --git a/assets/images/441.jpg b/assets/images/441.jpg new file mode 100644 index 00000000..18ab03ec Binary files /dev/null and b/assets/images/441.jpg differ diff --git a/assets/images/442.jpg b/assets/images/442.jpg new file mode 100644 index 00000000..7fb2b6ce Binary files /dev/null and b/assets/images/442.jpg differ diff --git a/assets/images/443.jpg b/assets/images/443.jpg new file mode 100644 index 00000000..753a98bf Binary files /dev/null and b/assets/images/443.jpg differ diff --git a/assets/images/444.jpg b/assets/images/444.jpg new file mode 100644 index 00000000..bb5dd40a Binary files /dev/null and b/assets/images/444.jpg differ diff --git a/assets/images/445.jpg b/assets/images/445.jpg new file mode 100644 index 00000000..f81c5e7a Binary files /dev/null and b/assets/images/445.jpg differ diff --git a/assets/images/446.jpg b/assets/images/446.jpg new file mode 100644 index 00000000..45c0ec5d Binary files /dev/null and b/assets/images/446.jpg differ diff --git a/assets/images/447.jpg b/assets/images/447.jpg new file mode 100644 index 00000000..7c0f7372 Binary files /dev/null and b/assets/images/447.jpg differ diff --git a/assets/images/448.jpg b/assets/images/448.jpg new file mode 100644 index 00000000..fd13db09 Binary files /dev/null and b/assets/images/448.jpg differ diff --git a/assets/images/449.jpg b/assets/images/449.jpg new file mode 100644 index 00000000..981f3dc2 Binary files /dev/null and b/assets/images/449.jpg differ diff --git a/assets/images/450.jpg b/assets/images/450.jpg new file mode 100644 index 00000000..3ded9f1a Binary files /dev/null and b/assets/images/450.jpg differ diff --git a/assets/images/451.jpg b/assets/images/451.jpg new file mode 100644 index 00000000..f4ed55b0 Binary files /dev/null and b/assets/images/451.jpg differ diff --git a/assets/images/452.jpg b/assets/images/452.jpg new file mode 100644 index 00000000..68927b06 Binary files /dev/null and b/assets/images/452.jpg differ diff --git a/assets/images/453.jpg b/assets/images/453.jpg new file mode 100644 index 00000000..bc949f43 Binary files /dev/null and b/assets/images/453.jpg differ diff --git a/assets/images/454.jpg b/assets/images/454.jpg new file mode 100644 index 00000000..12a694e1 Binary files /dev/null and b/assets/images/454.jpg differ diff --git a/assets/images/455.jpg b/assets/images/455.jpg new file mode 100644 index 00000000..67595e54 Binary files /dev/null and b/assets/images/455.jpg differ diff --git a/assets/images/456.jpg b/assets/images/456.jpg new file mode 100644 index 00000000..6c8d4c96 Binary files /dev/null and b/assets/images/456.jpg differ diff --git a/assets/images/457.jpg b/assets/images/457.jpg new file mode 100644 index 00000000..b9964034 Binary files /dev/null and b/assets/images/457.jpg differ diff --git a/assets/images/458.jpg b/assets/images/458.jpg new file mode 100644 index 00000000..7f24af1e Binary files /dev/null and b/assets/images/458.jpg differ diff --git a/assets/images/459.jpg b/assets/images/459.jpg new file mode 100644 index 00000000..cab01b79 Binary files /dev/null and b/assets/images/459.jpg differ diff --git a/assets/images/460.jpg b/assets/images/460.jpg new file mode 100644 index 00000000..bc2e5c5f Binary files /dev/null and b/assets/images/460.jpg differ diff --git a/assets/images/461.jpg b/assets/images/461.jpg new file mode 100644 index 00000000..4820c410 Binary files /dev/null and b/assets/images/461.jpg differ diff --git a/assets/images/462.jpg b/assets/images/462.jpg new file mode 100644 index 00000000..1ae9d84f Binary files /dev/null and b/assets/images/462.jpg differ diff --git a/assets/images/463.jpg b/assets/images/463.jpg new file mode 100644 index 00000000..38109403 Binary files /dev/null and b/assets/images/463.jpg differ diff --git a/assets/images/464.jpg b/assets/images/464.jpg new file mode 100644 index 00000000..7a7576ea Binary files /dev/null and b/assets/images/464.jpg differ diff --git a/assets/images/465.jpg b/assets/images/465.jpg new file mode 100644 index 00000000..19420002 Binary files /dev/null and b/assets/images/465.jpg differ diff --git a/assets/images/466.jpg b/assets/images/466.jpg new file mode 100644 index 00000000..09eff6a3 Binary files /dev/null and b/assets/images/466.jpg differ diff --git a/assets/images/467.jpg b/assets/images/467.jpg new file mode 100644 index 00000000..ad43767a Binary files /dev/null and b/assets/images/467.jpg differ diff --git a/assets/images/468.jpg b/assets/images/468.jpg new file mode 100644 index 00000000..e59037d0 Binary files /dev/null and b/assets/images/468.jpg differ diff --git a/assets/images/469.jpg b/assets/images/469.jpg new file mode 100644 index 00000000..85684f6e Binary files /dev/null and b/assets/images/469.jpg differ diff --git a/assets/src/ABT/ABT.md b/assets/src/ABT/ABT.md index d7d47252..b8c46f79 100644 --- a/assets/src/ABT/ABT.md +++ b/assets/src/ABT/ABT.md @@ -12,6 +12,7 @@ 如今的机器学习领域主要的研究工作在三个方面进行：1）面向任务的研究，研究和分析改进一组预定任务的执行性能的学习系统；2）认知模型，研究人类学习过程并进行计算模拟；3）理论的分析，从理论的层面探索可能的算法和独立的应用领域算法。 #### AdaBoost + 自适应提升（AdaBoost：Adaptive Boosting）算法是基于概率近似正确的学习模型下提出的一种提升算法。在分类问题中，AdaBoost通过修改训练样本的权值分布，学习多个弱分类器，并将这些分类器进行线性组合，构成一个强分类器，提高分类性能。其中强分类器可理解为分类精确度高的算法，弱分类器可理解为分类精度低的算法，一般AdaBoost算法是弱分类器的线性组合为：

diff --git a/assets/src/ANN/ANN.0.4.md b/assets/src/ANN/ANN.0.4.md index a62b663b..74d0df6d 100644 --- a/assets/src/ANN/ANN.0.4.md +++ b/assets/src/ANN/ANN.0.4.md @@ -40,6 +40,7 @@ RNN主要解决序列数据的处理，比如文本、语音、视频等等。

当k=1时，模型变为: +

@@ -56,7 +57,7 @@ RNN主要解决序列数据的处理，比如文本、语音、视频等等。

-把序列视作时间序列，隐含层h的自连接边实际上是和上一时刻的h相连.在每一个时刻t，的取值是当前时刻的输入,和上一时刻的隐含层值的一个函数: +把序列视作时间序列，隐含层h的自连接边实际上是和上一时刻的h相连.在每一个时刻t，的取值是当前时刻的输入,和上一时刻的隐含层值的一个函数:

@@ -98,6 +99,7 @@ RNN训练困难的主要原因在于隐藏层参数w的传播：由于误差传

+ 而对梯度消失问题，则有很多不同的方案： * 有效初始化+ReLU激活函数能够得到较好效果 @@ -106,7 +108,7 @@ RNN训练困难的主要原因在于隐藏层参数w的传播：由于误差传 * 在BPTT算法中加入skip connection，此时误差可以间歇的向前传播。 * 加入一些Leaky Units，思路类似于skip connection -LSTM 全称叫 Long Short-Term Memory networks，它和传统 RNN 唯一的不同就在与其中的神经元（感知机）的构造不同。传统的 RNN 每个神经元和一般神经网络的感知机没啥区别，但在 LSTM 中，每个神经元是一个“记忆细胞”（元胞状态，Cell State），将以前的信息连接到当前的任务中来。每个LSTM细胞里面都包含: +LSTM 全称叫 `Long Short-Term Memory networks`，它和传统 RNN 唯一的不同就在与其中的神经元（感知机）的构造不同。传统的 RNN 每个神经元和一般神经网络的感知机没啥区别，但在 LSTM 中，每个神经元是一个“记忆细胞”（元胞状态，Cell State），将以前的信息连接到当前的任务中来。每个LSTM细胞里面都包含: * 输入门（input gate）: 一个Sigmoid层，观察和,对于元胞状态中的每一个元素，输出一个0~1之间的数。1表示“完全保留该信息”，0表示“完全丢弃该信息”： @@ -146,6 +148,7 @@ LSTM 全称叫 Long Short-Term Memory networks，它和传统 RNN 唯一的不 如果我们把LSTM的forget gate全部置0（总是忘记之前的信息），input gate全部 置1，output gate全部置1（把cell state中的信息全部输出），这样LSTM就变成一个标准的RNN。 目前 LSTM 模型在实践中取得了非常好的效果， 只需要训练一个两三层的LSTM, 它就可以: + * 模仿保罗·格雷厄姆进行写作 * 生成维基百科的 markdown 页面 * 手写识别 diff --git a/assets/src/ANN/ANN.0.7.md b/assets/src/ANN/ANN.0.7.md index 8418b6b2..bcc81d07 100644 --- a/assets/src/ANN/ANN.0.7.md +++ b/assets/src/ANN/ANN.0.7.md @@ -22,10 +22,8 @@ CNN的基本结构包括两层，其一为特征提取层，每个神经元的 CNN主要用来识别位移、缩放及其他形式扭曲不变性的二维图形。由于CNN的特征检测层通过训练数据进行学习，所以在使用CNN时，避免了显式的特征抽取，而隐式地从训练数据中进行学习；再者由于同一特征映射面上的神经元权值相同，所以网络可以并行学习，这也是卷积网络相对于神经元彼此相连网络的一大优势。卷积神经网络以其局部权值共享的特殊结构在语音识别和图像处理方面有着独特的优越性，其布局更接近于实际的生物神经网络，权值共享降低了网络的复杂性，特别是多维输入向量的图像可以直接输入网络这一特点避免了特征提取和分类过程中数据重建的复杂度。

- +

- - #### 应用示例 ```python import numpy as np diff --git a/assets/src/BA/BA.0.3.md b/assets/src/BA/BA.0.3.md index 2d533d11..758d9c33 100644 --- a/assets/src/BA/BA.0.3.md +++ b/assets/src/BA/BA.0.3.md @@ -1,4 +1,5 @@ ### Deeplearning Algorithms tutorial + 谷歌的人工智能位于全球前列，在图像识别、语音识别、无人驾驶等技术上都已经落地。而百度实质意义上扛起了国内的人工智能的大旗，覆盖无人驾驶、智能助手、图像识别等许多层面。苹果业已开始全面拥抱机器学习，新产品进军家庭智能音箱并打造工作站级别Mac。另外，腾讯的深度学习平台Mariana已支持了微信语音识别的语音输入法、语音开放平台、长按语音消息转文本等产品，在微信图像识别中开始应用。全球前十大科技公司全部发力人工智能理论研究和应用的实现，虽然入门艰难，但是一旦入门，高手也就在你的不远处！ AI的开发离不开算法那我们就接下来开始学习算法吧！ @@ -9,6 +10,7 @@ AI的开发离不开算法那我们就接下来开始学习算法吧！ 学习矢量量化是一种结构简单、功能强大的有监督式神经网络分类方法。作为一种最近邻原型分类器，LVQ在训练过程中通过对神经元权向量（原型向量）的不断更新，对其学习率的不断调整，能够使不同类别权向量之间的边界逐步收敛至贝叶斯分类边界。算法中，对获胜神经元（最近邻权向量）的选取是通过计算输入样本和权向量之间的距离的大小来判断的。与矢量量化（VQ）相比，LVQ最突出的特点就是其具有自适应性 1.向量量化 + 向量量化的思路是，将高维输入空间分成若干不同的区域，对每个区域确定一个中心向量作为聚类的中心，与其处于同一区域的输入向量可用该中心向量来代表，从而形成了以各中心向量为聚类中心的点集。在图像处理领域常用各区域中心点（向量）的编码代替区域内的点来存储或传输，从而提出了各种基于向量量化的有损压缩技术，在二维输入平面上表示的中心向量分布称为Voronoi图，如图所示：

@@ -18,24 +20,31 @@ AI的开发离不开算法那我们就接下来开始学习算法吧！ 自组织映射可以起到聚类作用，但无法直接分类或识别，因此它只是自适应解决模式分类问题两步中的第一步。第二步：学习向量量化，采用监督机制，在训练中加入信号作为分类信息对权值进行细调，并对输出神经元预先指定其类别。 2.学习矢量量化网络结构与工作原理 + 学习矢量量化神经网络有三层组成：输入层，竞争层，线性输出层。 +

+ 竞争层有m个神经元，输入层有n个神经元，两层之间完全连接。输出层每个神经元只与竞争层中的一组神经元连接，连接权重固定为1，训练过程中输入层和竞争层之间的权值逐渐被调整为聚类中心。当一个样本输入LVQ网络时，竞争层的神经元通过胜者为王学习规则产生获胜神经元，容许其输出为1，其它神经元输出为0。与获胜神经元所在组相连的输出神经元输出为1，而其它输出神经元为0，从而给出当前输入样本的模式类。将竞争层学习得到的类成为子类，而将输出层学习得到的类成为目标类。 3.学习矢量量化网络学习算法 + 学习矢量量化学习规则结合了竞争学习规则和有导师学习规则，所以样本集应当为{(xi，di)}。其中di为l维，对应输出层的l个神经元，它只有一个分量为1，其他分量均为0。通常把竞争层的每个神经元指定给一个输出神经元，相应的权值为1，从而得到输出层的权值。比如某LVQ网络竞争层6个神经元，输出层3个神经元，代表3类。若将竞争层的1，3指定为第一个输出神经元，2，5指定为第二个输出神经元，3，6指定为第三个输出神经元。则竞争层到输出层的权值矩阵为: +

训练前预先定义好竞争层到输出层权重，从而指定了输出神经元类别，训练中不再改变。网络的学习通过改变输入层到竞争层的权重来进行。根据输入样本类别和获胜神经元所属类别，可判断当前分类是否正确。若分类正确，则将获胜神经元的权向量向输入向量方向调整，分类错误则向相反方向调整。 +

学习矢量量化网络学习算法的步骤如下: + * 初始化。竞争层各神经元权值向量随机赋值小随机数，确定初始学习速率和训练次数。 * 输入样本向量。 * 寻找激活神经元。 @@ -46,10 +55,13 @@ AI的开发离不开算法那我们就接下来开始学习算法吧！

当网络分类结果与教师信号不一致时，向输入样本反方向调整权值： +

+ 其他非激活神经元权值保持不变。 + * 更新学习速率

diff --git a/assets/src/BNS/BNS.0.6.md b/assets/src/BNS/BNS.0.6.md index 1673b0bc..49e29537 100644 --- a/assets/src/BNS/BNS.0.6.md +++ b/assets/src/BNS/BNS.0.6.md @@ -6,7 +6,7 @@ AI的开发离不开算法那我们就接下来开始学习算法吧！ 贝叶斯网络(Bayesian network)，又称信念网络(Belief Network)，或有向无环图模型(directed acyclic graphical model)，是一种概率图模型，于1985年由Judea Pearl首先提出，它是基于概率推理的图形化网络，可以模拟人类推理过程中因果关系的不确定性处理模型，其网络拓朴结构是一个有向无环图。而贝叶斯公式则是这个概率网络的基础。贝叶斯网络是基于概率推理的数学模型，所谓概率推理就是通过一些变量的信息来获取其他的概率信息的过程，基于概率推理的贝叶斯网络(Bayesian network)是为了解决不定性和不完整性问题而提出的，它对于解决复杂设备不确定性和关联性引起的故障有很大的优势，在多个领域中获得广泛应用。 -贝叶斯网络的有向无环图(Directed Acyclic Graph,DAG)中的节点表示随机变量，,由代表变量节点及连接这些节点有向边构成。它们可以是可观察到的变量，或隐变量、未知参数等。认为有因果关系（或非条件独立）的变量或命题则用箭头来连接。若两个节点间以一个单箭头连接在一起，表示其中一个节点是“因(parents)”，另一个是“果(children)”，两节点就会产生一个条件概率值。节点代表随机变量，节点间的有向边代表了节点间的互相关系(由父节点指向其子节点)，用条件概率进行表达关系强度，没有父节点的用先验概率进行信息表达。节点变量可以是任何问题的抽象，如：测试值，观测现象，意见征询等。适用于表达和分析不确定性和概率性的事件，应用于有条件地依赖多种控制因素的决策，可以从不完全、不精确或不确定的知识或信息中做出推理。 +贝叶斯网络的有向无环图(Directed Acyclic Graph,DAG)中的节点表示随机变量，,由代表变量节点及连接这些节点有向边构成。它们可以是可观察到的变量，或隐变量、未知参数等。认为有因果关系（或非条件独立）的变量或命题则用箭头来连接。若两个节点间以一个单箭头连接在一起，表示其中一个节点是“因(parents)”，另一个是“果(children)”，两节点就会产生一个条件概率值。节点代表随机变量，节点间的有向边代表了节点间的互相关系(由父节点指向其子节点)，用条件概率进行表达关系强度，没有父节点的用先验概率进行信息表达。节点变量可以是任何问题的抽象，如：测试值，观测现象，意见征询等。适用于表达和分析不确定性和概率性的事件，应用于有条件地依赖多种控制因素的决策，可以从不完全、不精确或不确定的知识或信息中做出推理。 使用贝叶斯网络必须知道各个状态之间相关的概率。得到这些参数的过程叫做训练。和训练马尔可夫模型一样，训练贝叶斯网络要用一些已知的数据。比如在训练上面的网络，需要知道一些心血管疾病和吸烟、家族病史等有关的情况。相比马尔可夫链，贝叶斯网络的训练比较复杂，从理论上讲，它是一个 NP-complete问题，也就是说，现阶段没有可以在多项式时间内完成的算法。但是，对于某些应用，这个训练过程可以简化，并在计算上高效实现。 diff --git a/assets/src/BNS/BNS.md b/assets/src/BNS/BNS.md index cd31cea0..69b7ef51 100644 --- a/assets/src/BNS/BNS.md +++ b/assets/src/BNS/BNS.md @@ -3,7 +3,6 @@ AI的开发离不开算法那我们就接下来开始学习算法吧！ #### 贝叶斯网络 - 贝叶斯网络（Bayesian networks or Bayesnets）也称为因果概率网络（CPNs，Causal Probabilistic Networks）、贝叶斯信念网络（BNS，Bayesian belief Networks）或信念网络，是用来对那些带有不确定性问题的问题域进行建模的系统。 从形式上说，贝叶斯网络是由一组以单向箭头相连的节点以及与每个节点相对应的概率函数所构成的网络。对于离散变量的贝叶斯网络，概率函数便具有了概率表的形式。这个网络必须是一个有向无环图，即其中不存在一条起始和终止于同一节点的通路。用图形的方法描述数据间的相互（因果）关系，语义清晰、可理解性强，有助于利用数据间的因果关系进行诊断、预测、分类等分析。因而贝叶斯方法具有独特的不确定性知识表达形式、丰富的概率表达能力、综合先验知识的增量学习特性等优点。 @@ -12,11 +11,11 @@ AI的开发离不开算法那我们就接下来开始学习算法吧！ 贝叶斯网络根据每个节点的概率表，在给定部分（一个或多个）节点状态值的前提下，对其余全部或部分节点的概率分布进行预测的过程即为网络的推理过程。 -分析流程 +分析流程: 贝叶斯网络的分析流程通常由三个步骤组成，即(1)网络建立,(2)参数学习或参数设置,(3)网络推理，如图所示.

- +

贝叶斯网络分析流程 @@ -60,12 +59,12 @@ AI的开发离不开算法那我们就接下来开始学习算法吧！ 如果要计算节点D的概率，由于节点D和节点A、B相关，根据边界概率的定义有:

- +

-在没有任何证据提供给网络的情况下有初始边界概率为 +在没有任何证据提供给网络的情况下有初始边界概率为: -P(D)＝0.8×0.1×0.4＋0.6×0.1×0.6＋0.6×0.9×0.4＋0.3×0.9＋0.6＝0.032＋0.036＋0.0216＋0.0162＝0. 446． +P(D)＝0.8×0.1×0.4＋0.6×0.1×0.6＋0.6×0.9×0.4＋0.3×0.9＋0.6＝0.032＋0.036＋0.0216＋0.0162＝0.446． 同样，考虑节点C发生了的情况，亦即C＝TRUE，知道P(A)从0.1变成0.471，P(notA)也就从0.9变成0.529，将这些值重新代入式(2)，得到修改后的边界概率，即条件概率P(D| C)＝0.542．给网络输入新的证据以更新各个节点的概率，这个过程称为概率繁殖．贝叶斯网络的作用就在于对不确定性系统进行知识表达并利用概率繁殖来对其进行推理． diff --git a/assets/src/CA/CA.0.2.md b/assets/src/CA/CA.0.2.md index 45f66244..074cbff2 100644 --- a/assets/src/CA/CA.0.2.md +++ b/assets/src/CA/CA.0.2.md @@ -4,7 +4,7 @@ AI的开发离不开算法那我们就接下来开始学习算法吧！ #### K-均值(K-Means Algorithm) -k-means算法，也被称为k-平均或k-均值，是一种得到最广泛使用的聚类算法。 它把n个点（可以是样本的一次观察或一个实例）划分到k个聚类中，使得每个点都属于离他最近的均值（此即聚类中心）对应的聚类，以之作为聚类的标准。 +k-means算法，也被称为k-平均或k-均值，是一种得到最广泛使用的聚类算法。 通常它把n个点（可以是样本的一次观察或一个实例）划分到k个聚类中，使得每个点都属于离他最近的均值（此即聚类中心）对应的聚类，以之作为聚类的标准。 k-means算法属于无监督学习方法。此算法以k为参数，把n 个对象分为k个簇，以使簇内具有较高的相似度，而且簇间的相似度较低。相似度的计算根据一个簇中对象的平均值（被看作簇的重心）来进行。此算法首先随机选择k个对象，每个对象代表一个聚类的质心。对于其余的每一个对象，根据该对象与各聚类质心之间的距离，把它分配到与之最相似的聚类中。然后，计算每个聚类的新质心。重复上述过程，直到准则函数收敛。k-means算法是一种较典型的逐点修改迭代的动态聚类算法，其要点是以误差平方和为准则函数。逐点修改类中心：一个象元样本按某一原则，归属于某一组类后，就要重新计算这个组类的均值，并且以新的均值作为凝聚中心点进行下一次象元素聚类；逐批修改类中心：在全部象元样本按某一组的类中心分类之后，再计算修改各类的均值，作为下一次分类的凝聚中心点 diff --git a/assets/src/CART/CART.md b/assets/src/CART/CART.md index 7c750743..e6c6444a 100644 --- a/assets/src/CART/CART.md +++ b/assets/src/CART/CART.md @@ -31,19 +31,26 @@ CART算法原理:CART决策树是结构简洁的二叉树，采用一种二分

对于给定样本集合D，其基尼指数的计算为： +

+ 如果样本集合D根据特征A是否取某一可能值a被分割成D1和D2两部分，即：,D2=D-D1 则在特征A的条件下，集合D的基尼指数计算公式为： +

+ 基尼指数Gini(D)表示集合D的不确定性，基尼指数Gini(D,A)表示经A=a分割后集合D的不确定性。基尼指数值越大，样本集合的不确定性也就越大。 -（2）回归树原理：回归树用平方误差最小化准则，进行特征选择，生成二叉树。将输入空间划分为M个区域R1，R2，…，Rm，则生成的回归树模型表示为： + +(2)回归树原理：回归树用平方误差最小化准则，进行特征选择，生成二叉树。将输入空间划分为M个区域R1，R2，…，Rm，则生成的回归树模型表示为： +

+ 其中cm表示单元Rm上的最小误差平方的最优解. 2、决策树的剪枝 diff --git a/assets/src/CAS/CAS.md b/assets/src/CAS/CAS.md index a8e97b2e..7fefbfc0 100644 --- a/assets/src/CAS/CAS.md +++ b/assets/src/CAS/CAS.md @@ -18,7 +18,7 @@ AI的开发离不开算法那我们就接下来开始学习算法吧！ #### 聚类分析 -聚类分析（英语：Cluster analysis，亦称为群集分析）是对于统计数据分析的一门技术，在许多领域受到广泛应用，包括机器学习，数据挖掘，模式识别，图像分析以及生物信息。聚类是把相似的对象通过静态分类的方法分成不同的组别或者更多的子集（subset），这样让在同一个子集中的成员对象都有相似的一些属性，常见的包括在坐标系中更短的空间距离等。 +聚类分析（Cluster analysis，亦称为群集分析）是对于统计数据分析的一门技术，在许多领域受到广泛应用，包括机器学习，数据挖掘，模式识别，图像分析以及生物信息。聚类是把相似的对象通过静态分类的方法分成不同的组别或者更多的子集（subset），这样让在同一个子集中的成员对象都有相似的一些属性，常见的包括在坐标系中更短的空间距离等。 一般把数据聚类归纳为一种非监督学习。 @@ -64,6 +64,7 @@ AI的开发离不开算法那我们就接下来开始学习算法吧！ 1.可以选取前K个观测变量值为初始中心点； 2.最小最大原则：先选择所有样本数据中距离最远的两个值；并且选择第三个值，使得与前两个聚点的距离最小者等于所有其余数据的较小距离中最大的，依次按这个原则选取，直到最终确定K个中心点；用公式可以表示为： +

diff --git a/assets/src/DRA/DRA.0.2.md b/assets/src/DRA/DRA.0.2.md index 38dc3675..50574b30 100644 --- a/assets/src/DRA/DRA.0.2.md +++ b/assets/src/DRA/DRA.0.2.md @@ -1,4 +1,5 @@ ### Deeplearning Algorithms tutorial + 谷歌的人工智能位于全球前列，在图像识别、语音识别、无人驾驶等技术上都已经落地。而百度实质意义上扛起了国内的人工智能的大旗，覆盖无人驾驶、智能助手、图像识别等许多层面。苹果业已开始全面拥抱机器学习，新产品进军家庭智能音箱并打造工作站级别Mac。另外，腾讯的深度学习平台Mariana已支持了微信语音识别的语音输入法、语音开放平台、长按语音消息转文本等产品，在微信图像识别中开始应用。全球前十大科技公司全部发力人工智能理论研究和应用的实现，虽然入门艰难，但是一旦入门，高手也就在你的不远处！ AI的开发离不开算法那我们就接下来开始学习算法吧！ diff --git a/assets/src/DRA/DRA.0.4.md b/assets/src/DRA/DRA.0.4.md index cbd4c7fa..d9a3b485 100644 --- a/assets/src/DRA/DRA.0.4.md +++ b/assets/src/DRA/DRA.0.4.md @@ -14,6 +14,508 @@ AI的开发离不开算法那我们就接下来开始学习算法吧！ 在对自变量每一次观察测量值都是连续量的时候，LDA能有效的起作用。当处理类别自变量时，与LDA相对应的技术称为判别反应分析。 -通常，它能够保证投影后模式样本在新的空间中有最小的类内距离和最大的类间距离，即模式在该空间中有最佳的可分离性。 +通常它能够保证投影后模式样本在新的空间中有最小的类内距离和最大的类间距离，即模式在该空间中有最佳的可分离性。 +应用示例: +```python +from __future__ import print_function + +import os +import time +import pickle +import itertools +import numpy as np +import matplotlib.pyplot as plt + +import theano +import lasagne + +# init color printer +class BColors: + """ + Colored command line output formatting + """ + HEADER = '\033[95m' + OKBLUE = '\033[94m' + OKGREEN = '\033[92m' + WARNING = '\033[93m' + FAIL = '\033[91m' + ENDC = '\033[0m' + BOLD = '\033[1m' + UNDERLINE = '\033[4m' + + def __init__(self): + """ Constructor """ + pass + + def print_colored(self, string, color): + """ Change color of string """ + return color + string + BColors.ENDC + +col = BColors() + + +def threaded_generator(generator, num_cached=10): + """ + Threaded generator + """ + import Queue + queue = Queue.Queue(maxsize=num_cached) + queue = Queue.Queue(maxsize=num_cached) + end_marker = object() + + # define producer + def producer(): + for item in generator: + #item = np.array(item) # if needed, create a copy here + queue.put(item) + queue.put(end_marker) + + # start producer + import threading + thread = threading.Thread(target=producer) + thread.daemon = True + thread.start() + + # run as consumer + item = queue.get() + while item is not end_marker: + yield item + queue.task_done() + item = queue.get() + + +def generator_from_iterator(iterator): + """ + Compile generator from iterator + """ + for x in iterator: + yield x + + +def threaded_generator_from_iterator(iterator, num_cached=10): + """ + Compile threaded generator from iterator + """ + generator = generator_from_iterator(iterator) + return threaded_generator(generator, num_cached) + + +def accuracy_score(t, p): + """ + Compute accuracy + """ + return float(np.sum(p == t)) / len(p) + + +class LDA(object): + """ LDA Class """ + + def __init__(self, r=1e-3, n_components=None, verbose=False, show=False): + """ Constructor """ + self.r = r + self.n_components = n_components + + self.scalings_ = None + self.coef_ = None + self.intercept_ = None + self.means = None + + self.verbose = verbose + self.show = show + + def fit(self, X, y, X_te=None): + """ Compute lda on hidden layer """ + + # split into semi- and supervised- data + X_all = X.copy() + X = X[y >= 0] + y = y[y >= 0] + + # get class labels + classes = np.unique(y) + + # set number of components + if self.n_components is None: + self.n_components = len(classes) - 1 + + # compute means + means = [] + for group in classes: + Xg = X[y == group, :] + means.append(Xg.mean(0)) + self.means = np.asarray(means) + + # compute covs + covs = [] + for group in classes: + Xg = X[y == group, :] + Xg = Xg - np.mean(Xg, axis=0) + covs.append(np.cov(Xg.T)) + + # within scatter + Sw = np.average(covs, axis=0) + + # total scatter + X_all = X_all - np.mean(X_all, axis=0) + if X_te is not None: + St = np.cov(np.concatenate((X_all, X_te)).T) + else: + St = np.cov(X_all.T) + + # between scatter + Sb = St - Sw + + # cope for numerical instability + Sw += np.identity(Sw.shape[0]) * self.r + + # compute eigen decomposition + from scipy.linalg.decomp import eigh + evals, evecs = eigh(Sb, Sw) + + # sort eigen vectors according to eigen values + evecs = evecs[:, np.argsort(evals)[::-1]] + + # normalize eigen vectors + evecs /= np.apply_along_axis(np.linalg.norm, 0, evecs) + + # compute lda data + self.scalings_ = evecs + self.coef_ = np.dot(self.means, evecs).dot(evecs.T) + self.intercept_ = (-0.5 * np.diag(np.dot(self.means, self.coef_.T))) + + if self.verbose: + top_k_evals = evals[-self.n_components:] + print("LDA-Eigenvalues (Train):", np.array_str(top_k_evals, precision=2, suppress_small=True)) + print("Ratio min(eigval)/max(eigval): %.3f, Mean(eigvals): %.3f" % (top_k_evals.min() / top_k_evals.max(), top_k_evals.mean())) + + if self.show: + plt.figure("Eigenvalues") + ax = plt.subplot(111) + top_k_evals /= np.sum(top_k_evals) + plt.plot(range(self.n_components), top_k_evals, 'bo-') + plt.grid('on') + plt.xlabel('Eigenvalue', fontsize=20) + plt.ylabel('Explained Discriminative Variance', fontsize=20) + plt.ylim([0.0, 1.05 * np.max(top_k_evals)]) + + ax.tick_params(axis='x', labelsize=18) + ax.tick_params(axis='y', labelsize=18) + + return evals + + def transform(self, X): + """ transform data """ + X_new = np.dot(X, self.scalings_) + return X_new[:, :self.n_components] + + def predict_proba(self, X): + """ estimate probability """ + prob = -(np.dot(X, self.coef_.T) + self.intercept_) + np.exp(prob, prob) + prob += 1 + np.reciprocal(prob, prob) + prob /= prob.sum(axis=1).reshape((prob.shape[0], -1)) + return prob + + def predict_log_proba(self, X): + """ estimate log probability """ + return np.log(self.predict_proba(X)) + + +def create_iter_functions(l_out, l_in, y_tensor_type, objective, learning_rate, l_2, compute_updates): + """ Create functions for training, validation and testing to iterate one epoch. """ + + # init target tensor + targets = y_tensor_type('y') + + # compute train costs + tr_output = lasagne.layers.get_output(l_out, deterministic=False) + tr_cost = objective(tr_output, targets) + + # compute validation costs + va_output = lasagne.layers.get_output(l_out, deterministic=True) + va_cost = objective(va_output, targets) + + # collect all parameters of net and compute updates + all_params = lasagne.layers.get_all_params(l_out, trainable=True) + + # add weight decay + if l_2 is not None: + tr_cost += l_2 * lasagne.regularization.apply_penalty(all_params, lasagne.regularization.l2) + + # compute updates from gradients + all_grads = lasagne.updates.get_or_compute_grads(tr_cost, all_params) + updates = compute_updates(all_grads, all_params, learning_rate) + + # compile iter functions + tr_outputs = [tr_cost] + iter_train = theano.function([l_in.input_var, targets], tr_outputs, updates=updates) + + va_outputs = [va_cost, va_output] + iter_valid = theano.function([l_in.input_var, targets], va_outputs) + + # compile output function + compute_output = theano.function([l_in.input_var], va_output) + + return dict(train=iter_train, valid=iter_valid, test=iter_valid, compute_output=compute_output) + + +def train(iter_funcs, dataset, train_batch_iter, valid_batch_iter, r): + """ + Train the model with `dataset` with mini-batch training. + Each mini-batch has `batch_size` recordings. + """ + import sys + import time + + for epoch in itertools.count(1): + + # iterate train batches + batch_train_losses = [] + iterator = train_batch_iter(dataset['X_train'], dataset['y_train']) + generator = threaded_generator_from_iterator(iterator) + + start, after = time.time(), time.time() + for i_batch, (X_b, y_b) in enumerate(generator): + batch_res = iter_funcs['train'](X_b, y_b) + batch_train_losses.append(batch_res[0]) + after = time.time() + train_time = (after-start) + + # report loss during training + perc = 100 * (float(i_batch) / train_batch_iter.n_batches) + dec = int(perc // 4) + progbar = "|" + dec * "#" + (25-dec) * "-" + "|" + vals = (perc, progbar, train_time, np.mean(batch_train_losses)) + loss_str = " (%d%%) %s time: %.2fs, loss: %.5f" % vals + print(col.print_colored(loss_str, col.WARNING), end="\r") + sys.stdout.flush() + + print("\x1b[K", end="\r") + avg_train_loss = np.mean(batch_train_losses) + + # lda evaluation (accuracy based) + + # iterate validation batches + batch_valid_losses = [] + iterator = valid_batch_iter(dataset['X_valid'], dataset['y_valid']) + generator = threaded_generator_from_iterator(iterator) + net_output_va, y_va = None, np.zeros(0, dtype=np.int32) + for X_b, y_b in generator: + batch_res = iter_funcs['valid'](X_b, y_b) + batch_valid_losses.append(batch_res[0]) + + y_va = np.concatenate((y_va, y_b)) + net_output = iter_funcs['compute_output'](X_b) + if net_output_va is None: + net_output_va = net_output + else: + net_output_va = np.vstack((net_output_va, net_output)) + + avg_valid_loss = np.mean(batch_valid_losses) + + # compute train set net output + iterator = train_batch_iter(dataset['X_train'], dataset['y_train']) + generator = threaded_generator_from_iterator(iterator) + net_output_tr, y_tr = None, np.zeros(0, dtype=np.int32) + for i_batch, (X_b, y_b) in enumerate(generator): + y_tr = np.concatenate((y_tr, y_b)) + net_output = iter_funcs['compute_output'](X_b) + if net_output_tr is None: + net_output_tr = net_output + else: + net_output_tr = np.vstack((net_output_tr, net_output)) + + # fit lda on net output + print("") + dlda = LDA(r=r, n_components=None, verbose=True) + evals = dlda.fit(net_output_tr, y_tr) + + # predict on train set + proba = dlda.predict_proba(net_output_tr[y_tr >= 0]) + y_tr_pr = np.argmax(proba, axis=1) + tr_acc = 100 * accuracy_score(y_tr[y_tr >= 0], y_tr_pr) + + # predict on validation set + proba = dlda.predict_proba(net_output_va) + y_va_pr = np.argmax(proba, axis=1) + va_acc = 100 * accuracy_score(y_va, y_va_pr) + + # estimate overfitting + overfit = va_acc / tr_acc + + # collect results + yield { + 'number': epoch, + 'train_loss': avg_train_loss, + 'train_acc': tr_acc, + 'valid_loss': avg_valid_loss, + 'valid_acc': va_acc, + 'overfitting': overfit, + 'eigenvalues': evals + } + + +def fit(l_out, l_in, data, objective, y_tensor_type, + train_batch_iter, valid_batch_iter, + r=1e-3, num_epochs=100, patience=20, + learn_rate=0.01, update_learning_rate=None, + l_2=None, compute_updates=None, + exp_name='ff', out_path=None, dump_file=None): + """ Train model """ + + # log model evolution + log_file = os.path.join(out_path, 'results.pkl') + + print("\n") + print(col.print_colored("Running Test Case: " + exp_name, BColors.UNDERLINE)) + + # adaptive learning rate + learning_rate = theano.shared(np.float32(learn_rate)) + if update_learning_rate is None: + def update_learning_rate(lr, e): + return lr + learning_rate.set_value(update_learning_rate(learn_rate, 0)) + + # initialize evaluation output + pred_tr_err, pred_val_err, overfitting = [], [], [] + tr_accs, va_accs = [], [] + eigenvalues = [] + + print("Building model and compiling functions...") + iter_funcs = create_iter_functions(l_out, l_in, y_tensor_type, objective, learning_rate=learning_rate, + l_2=l_2, compute_updates=compute_updates) + + print("Starting training...") + now = time.time() + try: + + # initialize early stopping + last_improvement = 0 + best_model = lasagne.layers.get_all_param_values(l_out) + + # iterate training epochs + prev_acc_tr, prev_acc_va = 0.0, 0.0 + for epoch in train(iter_funcs, data, train_batch_iter, valid_batch_iter, r): + + print("Epoch {} of {} took {:.3f}s".format( + epoch['number'], num_epochs, time.time() - now)) + now = time.time() + + # update learning rate + learn_rate = update_learning_rate(learn_rate, epoch['number']) + learning_rate.set_value(learn_rate) + + # --- collect train output --- + + tr_loss, va_loss = epoch['train_loss'], epoch['valid_loss'] + train_acc, valid_acc = epoch['train_acc'], epoch['valid_acc'] + overfit = epoch['overfitting'] + + # prepare early stopping + if valid_acc >= prev_acc_va: + last_improvement = 0 + best_model = lasagne.layers.get_all_param_values(l_out) + + # dump net parameters during training + if dump_file is not None: + with open(dump_file, 'w') as fp: + params = lasagne.layers.get_all_param_values(l_out) + pickle.dump(params, fp) + + # increase improvement counter + last_improvement += 1 + + # plot train output + if train_acc is None: + txt_tr = 'costs_tr %.5f' % tr_loss + else: + txt_tr = 'costs_tr %.5f (%.3f), ' % (tr_loss, train_acc) + if train_acc >= prev_acc_tr: + txt_tr = col.print_colored(txt_tr, BColors.OKGREEN) + prev_acc_tr = train_acc + + if valid_acc is None: + txt_val = '' + else: + txt_val = 'costs_val %.5f (%.3f), tr/val %.3f' % (va_loss, valid_acc, overfit) + if valid_acc >= prev_acc_va: + txt_val = col.print_colored(txt_val, BColors.OKGREEN) + prev_acc_va = valid_acc + + print(' lr: %.5f' % learn_rate) + print(' ' + txt_tr + txt_val) + + # collect model evolution data + tr_accs.append(train_acc) + va_accs.append(valid_acc) + pred_tr_err.append(tr_loss) + pred_val_err.append(va_loss) + overfitting.append(overfit) + eigenvalues.append(epoch['eigenvalues']) + + # --- early stopping: preserve best model --- + if last_improvement > patience: + print(col.print_colored("Early Stopping!", BColors.WARNING)) + status = "Epoch: %d, Best Validation Accuracy: %.3f" % (epoch['number'], prev_acc_va) + print(col.print_colored(status, BColors.WARNING)) + break + + # maximum number of epochs reached + if epoch['number'] >= num_epochs: + break + + # shuffle train data + if not hasattr(data['X_train'], 'reset_batch_generator'): + rand_idx = np.random.permutation(data['X_train'].shape[0]) + data['X_train'] = data['X_train'][rand_idx] + data['y_train'] = data['y_train'][rand_idx] + + # save results + exp_res = dict() + exp_res['pred_tr_err'] = pred_tr_err + exp_res['tr_accs'] = tr_accs + exp_res['pred_val_err'] = pred_val_err + exp_res['va_accs'] = va_accs + exp_res['overfitting'] = overfitting + exp_res['eigenvalues'] = eigenvalues + + with open(log_file, 'w') as fp: + pickle.dump(exp_res, fp) + + except KeyboardInterrupt: + pass + + # set net to best weights + lasagne.layers.set_all_param_values(l_out, best_model) + + # evaluate on test set + test_losses, test_acc = [], [] + iterator = valid_batch_iter(data['X_test'], data['y_test']) + for X_b, y_b in iterator: + loss_te = iter_funcs['test'](X_b, y_b) + test_losses.append(loss_te[0]) + if len(loss_te) > 1: + test_acc.append(loss_te[1]) + + # compute evaluation measures + avg_loss_te = np.mean(test_losses) + avg_acc_te = np.mean(test_acc) + + print("--------------------------------------------") + print('Loss on Test-Set: %.5f' % avg_loss_te) + print("--------------------------------------------\n") + + if out_path is not None: + + # add test results and save results + exp_res['avg_loss_te'] = avg_loss_te + exp_res['avg_acc_te'] = avg_acc_te + + with open(log_file, 'w') as fp: + pickle.dump(exp_res, fp) + + return l_out, prev_acc_va +``` diff --git a/assets/src/DRA/DRA.0.5.md b/assets/src/DRA/DRA.0.5.md index 9e59e0ce..5cc0bdbd 100644 --- a/assets/src/DRA/DRA.0.5.md +++ b/assets/src/DRA/DRA.0.5.md @@ -3,6 +3,147 @@ AI的开发离不开算法那我们就接下来开始学习算法吧！ #### 等度量映射(IsometricMapping,Isomap) -等度量映射(Isomap)是最经典的非线性映射降维方法之一，它在MDS的基础上引入了“测地距离”的概念，直接解决了MDS使用欧氏距离无法应对非线性流形的问题。 +等度量映射(Isomap)是最经典的非线性映射降维方法之一，它在MDS的基础上引入了“测地距离”的概念，直接解决了MDS使用欧氏距离无法应对非线性流形的问题。 测地距离(Geometric Distance)是高维流形中两点之间的最短距离，高维流形中，空间是不规则的，所以最短距离不一定是直线距离(欧氏距离)。就像蚂蚁从立方体的一面爬到另一面，不能直接横穿立方体一样。 + +

+ +

+ +图中左边的两个点的最近距离是蓝色实线的距离，而不应该是虚线的距离。 + +通常情况下真实的测地距离是非常难以求出的，但是等度量映射基于流形局部近似于欧式空间的定义提出了一种近似的求解方式。 + +我们通常的做法是: + +1. 求得原样本的KNN图，并依据定义保留其欧式距离。 +2. 所有非KNN的点间的距离规定为无穷大。 +3. 用dijkstra或floyd求出任意两点的最短路便可近似表示两点间的测地距离。 +4. 然后等度量映射(Isomap)将得到的测地距离矩阵输入MDS完成降维。 + +最后等度量映射(Isomap)将得到的测地距离矩阵输入MDS完成降维。 + +最后的结果是这样的。 + +

+ +

+ +应用示例: +```python +from IsomapCuda import * +from DataUtils import * +import getopt,sys + +GPU_MEM_SIZE = 512 + +def Isomap(dataSet,outfile,srcDims,trgDims,k,eps=1000000000., CIsomap=False): + """ + Classical isomap + """ + + #first do KNN + knnRefs,knnDists,knnm = KNN(dataSet,k,eps,srcDims) + mdists = [] + if CIsomap: + mdists = C_Isomap(knnDists,knnm,k) + + #then do APSP + pathMatrix = APSP(knnRefs,knnDists,knnm,eps) + del knnRefs + del knnDists + del knnm + + #then normalize the matrix + normMatrix = NormMatrix(pathMatrix,mdists) + del pathMatrix + del mdists + + #then get eigenvalues + #embedding = EigenEmbedding(normMatrix,trgDims) + embedding = QEig(normMatrix,trgDims) + del normMatrix + + return embedding + + +def NMIsomap(dataSet,outfile,srcDims,trgDims,k,eps=1000000000., saveSteps = False): + """ + Non-Metric Isomap + """ + + #first do KNN + knnRefs,knnDists = loadSplitTable(KNN(dataSet,k,eps,srcDims)) + + #then do APSP + pathMatrix = APSP(knnRefs,knnDists,eps) + del knnRefs + del knnDists + + #XXX:hacky way of saving this info + if saveSteps: + saveTable(pathMatrix,outfile[:-4]+'_distances.csv') + + #then get the rank matrix + origDims = len(pathMatrix) + rankMatrix = RankMatrix(pathMatrix) + del pathMatrix + + #then get the NMDS embedding + embedding = NMDS(rankMatrix, loadMatrix(dataSet)[:,:trgDims], origDims, trgDims) + + return embedding + + + +if __name__ == '__main__': + arg_values = ['nonmetric=','outdims=','indims=','if=','of=','k=','eps=','help','h'] + optlist, args = getopt.getopt(sys.argv[1:], 'x', arg_values) + + trgDims = 3 + srcDims = 10000000000 + k =6 + eps = 1000000000. + infile='swissroll.csv' + outfile='embedding.csv' + nonmetric=False + + + for o in optlist: + if o[0].strip('-') == 'outdims': + trgDims = int(o[1]) + for o in optlist: + if o[0].strip('-') == 'indims': + srcDims = int(o[1]) + for o in optlist: + if o[0].strip('-') == 'if': + infile = o[1] + for o in optlist: + if o[0].strip('-') == 'of': + outfile = o[1] + for o in optlist: + if o[0].strip('-') == 'k': + k = int(o[1]) + for o in optlist: + if o[0].strip('-') == 'nonmetric': + if o[1].strip(' \r\n\t') == 'True' or o[1].strip(' \r\n\t') == 'true': + nonmetric = True + + for o in optlist: + if o[0].strip('-') == 'help' or o[1].strip('-') == 'h': + print "The following commands are available:" + print "\t--if=inputfile\tDefaults to swissroll.csv" + print "\t--of=outputfile\tDefaults to embedding.csv" + print "\t--k=k_nearest_neighbours\tDefaults to 12" + print "\t--outdims=embedding_dimensions\tDefaults to 3" + print "\t--indims=input_dimensions\tDefaults to all in the input file" + print "\t--nonmetric\tEnables non-metric MDS embeddings" + result = None + if not nonmetric: + result = Isomap(infile,outfile,srcDims,trgDims,k,eps,False) + else: + result = NMIsomap(infile,outfile,srcDims,trgDims,k,eps,False) + + saveTable(result,outfile) +``` diff --git a/assets/src/DRA/DRA.0.6.md b/assets/src/DRA/DRA.0.6.md index 1867dc6c..41683bc3 100644 --- a/assets/src/DRA/DRA.0.6.md +++ b/assets/src/DRA/DRA.0.6.md @@ -3,3 +3,354 @@ AI的开发离不开算法那我们就接下来开始学习算法吧！ #### 局部线性嵌入(Locally Linear Embedding) +数据降维是指通过线性的或非线性的映射关系将高维数据转换成低维数据的过程。一般情况下，该低维数据代表了原始高维数据的主要成分（图1），并描述了原始高维数据的空间分布结构。由于经过降维后的数据更易于被分类、识别、可视化以及存储等，故数据降维技术在诸多科研领域受到了越来越多地关注。 + +从数据本身的的性质特征来看，数据降维可以大致分为线性降维和非线性降维两种技术方法。其中，线性降维技术仅对于数据维数相对较低、且具有全局线性结构的数据有着很好的降维效果。然而，在实际的科学研究中，科研工作者却需要面对海量的非线性高维数据。因此，能够有效处理高维非线性数据的方法亟待被提出，本文将介绍一种用于处理高维非线性数据的降维方法。 + +局部线性嵌入（Locally linear embedding, LLE）是一种非线性的降维方法，该算法由 Sam T.Roweis等人于2000年提出并发表在《Science》杂志上。LLE试图保留原始高维数据的局部性质，通过假设局部原始数据近似位于一张超平面上，从而使得该局部的某一个数据可以由其邻域数据线性表示。 + +Sam T.Roweis 和 Lawrence K.Saul提出局部线性嵌入（Locally linear embedding, LLE）算法，它是针对非线性数据的一种新的降维技术，并且能够使降维后的数据保持原有的拓扑结构。 LLE算法可以广泛的应用于非线性数据的降维、聚类以及图像分割等领域。 + +局部线性嵌入(Locally linear embedding, LLE)是最新提出的非线性降维方法。该算法即具有处理非线性数据的优点又有线性降维方法计算性能的优越性。 简单的讲，该方法是将高维流型用剪刀剪成很多的小块，每一小块可以用平面代替，然后再低维中重新拼合出来， 且要求保留各点之间的拓扑关系不变。整个问题最后被转化为两个二次规划问题。 + +局部线性嵌入(Locally linear embedding, LLE)算法可以归结为三步: +1. 寻找每个样本点的k个近邻点； +2. 由每个样本点的近邻点计算出该样本点的局部重建权值矩阵； +3. 由该样本点的局部重建权值矩阵和其近邻点计算出该样本点的输出值。 + +局部线性嵌入算法的第一步是计算出每个样本点的k个近邻点。把相对于所求样本点距离最近的k个样本点规定为所求样本点的k个近邻点。k是一个预先给定值。Sam T.Roweis 和 Lawrence K.Saul算法采用的是欧氏距离，则减轻复杂的计算。然而本文是假定高维空间中的数据是非线性分布的，采用了diijstra距离。Dijkstra 距离是一种测地距离，它能够保持样本点之间的曲面特性，在ISOMAP算法中有广泛的应用。针对样本点多的情况，普通的dijkstra算法不能满足LLE算法的要求。 + + +应用示例： +```python + +import numpy +import sources + +from sklearn import manifold +from sklearn.utils.extmath import randomized_svd +from sklearn.neighbors import NearestNeighbors + + +from wordreps import WordReps +from scipy.sparse import csr_matrix, eye +from scipy.sparse.linalg import eigsh +from scipy.sparse.linalg.eigen.arpack.arpack import ArpackNoConvergence + +from scipy.io import savemat, loadmat + +import sys +import time +import argparse +import collections + + +class MetaEmbed(): + + def __init__(self, wordreps, words): + self.words = words + self.ids = {} + for (i,word) in enumerate(words): + self.ids[word] = i + + self.reps = wordreps + self.dims = [x.dim for x in self.reps] + self.embeds = [] + N = len(words) + + # Create the source embedding matrices + write("Creating source embedding matrices...") + for i in range(len(self.reps)): + M = numpy.zeros((self.reps[i].dim, N), dtype=numpy.float64) + for j in range(N): + M[:,j] = self.reps[i].vects[self.words[j]] + self.embeds.append(M) + write("done\n") + pass + + def compute_neighbours(self, nns): + """ + Compute the nearest neighbours for each embedding. + """ + self.NNS = [] + for i in range(len(self.embeds)): + start_time = time.clock() + write("Computing nearest neighbours for embedding no = %d ..." % i) + nbrs = NearestNeighbors(n_neighbors=nns, algorithm='ball_tree').fit(self.embeds[i].T) + distances, indices = nbrs.kneighbors(self.embeds[i].T) + self.NNS.append(indices[:,1:]) + end_time = time.clock() + write("Done (%s sec.)\n" % str(end_time - start_time)) + pass + + def show_nns(self, word ,nns): + """ + Print nearest neigbours for a word in different embeddings. + """ + for i in range(len(self.embeds)): + print "Showing nearest neighbours for = %s" % word + print "\nEmbedding no = %d" % i + for s in self.NNS[i][self.ids[word], :][:nns]: + print self.words[s] + pass + + def compute_weights(self): + """ + Computes the reconstruction weights. + """ + start_time = time.clock() + T = 10 # no. of iterations. + alpha = 0.01 # learning rate. + N = len(self.words) + self.W = numpy.zeros((N, N), dtype=numpy.float64) + + # initialise the weights. + for i in range(N): + nns = set() + for j in range(len(self.embeds)): + for x in self.NNS[j][i,:]: + nns.add(x) + val = 1.0 / float(len(nns)) + for j in nns: + self.W[i,j] = val + + # iterate + for i in range(N): + write("\x1b[2K\rLearning weights for (%d of %d) = %s" % (i, N, self.words[i])) + for t in range(T): + d = [self.embeds[j][:,i] - numpy.sum([self.W[i,k] * self.embeds[j][:,k] for k in self.NNS[j][i,:]], axis=0) for j in range(len(self.embeds))] + #for j in range(len(self.embeds)): + # d.append(self.embeds[j][:,i] - numpy.sum([self.W[i,k] * self.embeds[j][:,k] for k in self.NNS[j][i,:]], axis=0)) + + grad = numpy.zeros(N, dtype=numpy.float64) + for j in range(len(self.embeds)): + for k in self.NNS[j][i,:]: + grad[k] += -2.0 * numpy.dot(d[j], self.embeds[j][:,k]) + + self.W[i,:] -= (alpha * grad) + + total = numpy.sum(self.W[i,:]) + if total != 0: + self.W[i,:] = self.W[i,:] / total + write("\n") + end_time = time.clock() + write("Done (took %s seconds)\n" % str(end_time - start_time)) + pass + + def save_weights(self, fname): + """ + Save the weight matrix to a disk file. + """ + savemat(fname, {"W":self.W}) + pass + + def load_weights(self, fname): + """ + Load the weight matrix from a disk file. + """ + self.W = loadmat(fname)["W"] + pass + + def test_compute_weights(self): + """ + Check whether the weights are computed correctly + """ + N = len(self.words) + # Check whether non-neighbours have weights equal to zero. + write("Checking whether non-neighbours have zero weights...\n") + for i in range(N): + pred_nns = set(numpy.where(self.W[i,:] != 0)[0]) + nns = set() + for j in range(len(self.embeds)): + nns = nns.union(set(self.NNS[j][i,:])) + assert(pred_nns == nns) + + # Check whether reconstruction weights add upto one. + write("Checking whether weights add to 1...\n") + for i in range(N): + assert(numpy.allclose(numpy.sum(self.W[i,:]), 1)) + + # print nearest neighbours and their weights + nn_file = open("../work/nn.csv", 'w') + for i in range(N): + nn_file.write("%s, " % self.words[i]) + L = [] + for j in range(N): + if self.W[i,j] != 0: + L.append((self.words[j], self.W[i,j])) + L.sort(lambda x, y: -1 if x[1] > y[1] else 1) + for (w, val) in L: + nn_file.write("%s, %f, " % (w, val)) + nn_file.write("\n") + nn_file.close() + pass + + def compute_M(self): + """ + Compute the smallest eigenvectors of M = (I - W')\T(I - W'). + """ + # Building W' + N = len(self.words) + start_time = time.clock() + write("Computing W'...") + for i in range(N): + z = numpy.zeros(N) + write("Completed %d of %d\r" % (i, N)) + for nns in self.NNS: + z[nns[i,:]] += 1 + self.W[i,:] = z * self.W[i,:] + end_time = time.clock() + write("Done (took %s seconds)\n" % str(end_time - start_time)) + + # Computing M. + start_time = time.clock() + write("Computing M....") + self.W = csr_matrix(self.W) + M = eye(N, format=self.W.format) - self.W + M = (M.T * M).tocsr() + end_time = time.clock() + write("Done (took %s seconds)\n" % str(end_time - start_time)) + return M + + def compute_embeddings(self, k, M, embed_fname): + """ + Perform eigen decomposition. + """ + N = len(self.words) + start_time = time.clock() + write("Computing Eigen decomposition...") + s, V = eigsh(M, k+1, tol=1E-6, which="SA", maxiter=100) + end_time = time.clock() + write("Done (took %s seconds)\n" % str(end_time - start_time)) + P = V[:, 1:] + err = numpy.sum(s[1:]) + write("Projection error = %f\n" % err) + + write("Writing embeddings to file...") + # Write embeddings to file. + with open(embed_fname, 'w') as embed_file: + for i in range(N): + embed_file.write("%s %s\n" % (self.words[i], " ".join([str(x) for x in P[i,:]]))) + write("Done\n") + pass + + +def write(msg): + sys.stdout.write(msg) + sys.stdout.flush() + pass + + +def meta_embed(embeddings, words, nns, comps, embed_path): + """ + Perform meta-embedding using LLE. + """ + ME = MetaEmbed(embeddings, words) + ME.compute_neighbours(nns) + #ME.show_nns("king", 5) + + #ME.compute_weights_parallel() + ME.compute_weights() + + #ME.save_weights("../work/weights_%d" % nns) + #ME.load_weights("../work/weights+n=%d.meta" % nns) + #ME.test_compute_weights() + M = ME.compute_M() + for k in comps: + embed_fname = "%s/n=%d+k=%d" % (embed_path, nns, k) + write("Embedding NNS = %d, Components (k) = %d\n" % (nns, k)) + try: + ME.compute_embeddings(k, M, embed_fname) + except ArpackNoConvergence as e: + print e + return ME + + +def baseline_concatenate(embeddings, words, embed_fname): + """ + Concatenate embeddings to create co-embeddings. + """ + dim = sum([x.dim for x in embeddings]) + + print "Concatenation dimension =", dim + # concatenate the vectors. + with open(embed_fname, 'w') as embed_file: + for (i,word) in enumerate(words): + L = [] + for x in embeddings: + w = 8 if x.dim == 300 else 1 + #w = 1 + L.append(w * x.vects[word]) + + z = numpy.concatenate(L) + embed_file.write("%s %s\n" % (word, " ".join([str(x) for x in z]))) + pass + +def get_common_words(embeddings): + words = set(embeddings[0].vocab) + for i in range(1, len(embeddings)): + words = words.intersection(set(embeddings[i].vocab)) + return words + + +def get_selected_words(fname): + words = [] + with open(fname) as F: + for line in F: + words.append(line.strip()) + return words + +def perform_embedding(nns, comps): + print "Neigbourhood size = %d" % nns + + #embed_sett + embed_settings = sources.embed_settings + embeddings = [] + for (embd_fname, dim) in embed_settings: + start_time = time.clock() + sys.stdout.write("Loading %s -- (%d dim) ..." % (embd_fname, dim)) + sys.stdout.flush() + WR = WordReps() + WR.read_model(embd_fname, dim) + end_time = time.clock() + sys.stdout.write("\nDone. took %s seconds\n" % str(end_time - start_time)) + sys.stdout.flush() + embeddings.append(WR) + + common_words = get_common_words(embeddings) + selected_words = get_selected_words("../work/selected-words") + words = [] + for word in selected_words: + if word in common_words and word not in words: + words.append(word) + print "No. of common words =", len(common_words) + print "Vocabulary size =", len(words) + ME = meta_embed(embeddings, words, nns, comps, "../work/meta-embeds") + pass + +def save_embedding(words, WR, fname): + F = open(fname, 'w') + for w in words: + if w in WR.vects: + F.write("%s " % w) + F.write("%s\n" % " ".join([str(x) for x in WR.vects[w]])) + # elif w.lower() in WR.vects: + # F.write("%s " % w.lower()) + # F.write("%s\n" % " ".join([str(x) for x in WR.vects[w.lower()]])) + F.close() + pass + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("-nns", type=int, help="number of nearest neighbours") + parser.add_argument("-comps", type=str, help="components for the projection") + args = parser.parse_args() + comps = [int(x) for x in args.comps.split(',')] + perform_embedding(args.nns, comps) + pass + +if __name__ == '__main__': + main() + pass + +``` diff --git a/assets/src/DRA/DRA.0.7.md b/assets/src/DRA/DRA.0.7.md index 0a29994c..082ec559 100644 --- a/assets/src/DRA/DRA.0.7.md +++ b/assets/src/DRA/DRA.0.7.md @@ -3,3 +3,201 @@ AI的开发离不开算法那我们就接下来开始学习算法吧！ #### 拉普拉斯特征映射(Laplacian Eigenmaps) + +拉普拉斯特征映射（Laplacian Eigenmaps，LE），就是将核函数方法应用在局部保持投影的非监督降维方法，也是无监督降维的一种方法，LE方法的直观思想是希望相互间有关系的点（在图中相连的点）在降维后的空间中尽可能的靠近。LE可以反映出数据内在的流形结构。 + +拉普拉斯特征映射是一种基于图的降维算法，它希望相互间有关系的点（在图中相连的点）在降维后的空间中尽可能的靠近，从而在降维后仍能保持原有的数据结构。 借鉴了图论里面的Laplacian矩阵，把每个样本点看成图中的一个节点，通过样本距离或者邻接矩阵得到W（可以表征样本间的相似关系，用来重构数据流形的局部结构特征），再通过D = diag(sum(W,2))，得到对角的度矩阵（每个元素都是行和或者列和），然后通过L = D - W 得到Laplacian矩阵。 + +Laplacian Eigenmaps算法的主要思想是，如果两个数据实例i和j很相似，那么i和j在降维后目标子空间中应该尽量接近。设数据实例的数目为n，目标子空间即最终的降维目标的维度为m。定义n×m大小的矩阵Y，其中每一个行向量yTi是数据实例i在目标m维子空间中的向量表示（即降维后的数据实例i）。 + + +Laplacian Eigenmap算法主要步骤: + +1. 建立邻接图：这里采用ϵ−最近邻图和K−最近邻图都能够解决问题。两种方法各有利弊，前者几何解释清楚，并且邻接矩阵天然是对称的，然而参数选择有困难，并且图的连通性未必有好的保证；后者参数选择容易，且图的连接性较好，但是几何解释不清晰。 + + +2. 赋权：我们常用热核来赋给权重，即对于连通的两个点i,i′,令；而对其它点对权值赋0. 最终我们可以用邻接矩阵W来表示这个图. + +3. 计算Laplace算子矩阵：完成建图后，我们定义顶点vi的度是: +

+ +

+ +并构造一个度矩阵: + +

+ +

+ +由此即可得到未归一化的图Laplace矩阵: + +

+ +

+ +容易说明, L是对称半正定矩阵，特征值是非负实数，且0是L的特征值，而特征向量是常1向量。值得说明的是我们经常采用的是经过归一化的L矩阵，规范化的方法是: + +

+ +

+ +4. 计算特征向量：即解以下问题： + +

+ +

+ +得到特征值 + +5. 特征映射：（先验地）假定低维流形维数d的值，并将数据映射到特征空间上，即 + +

+ +

+ +这就是拉普拉斯特征映射(Laplacian Eigenmaps)算法进行数据降维处理的全过程。 + +应用示例: +```python + from numpy import exp, median +from scipy.sparse.csgraph import laplacian +from sklearn.manifold.locally_linear import ( + null_space, LocallyLinearEmbedding) +from sklearn.metrics.pairwise import pairwise_distances, rbf_kernel +from sklearn.neighbors import kneighbors_graph, NearestNeighbors + + +def ler(X, Y, n_components=2, affinity='nearest_neighbors', + n_neighbors=None, gamma=None, mu=1.0, y_gamma=None, + eigen_solver='auto', tol=1e-6, max_iter=100, + random_state=None): + """ + Laplacian Eigenmaps for Regression (LER) + + Parameters + ---------- + X : ndarray, 2-dimensional + The data matrix, shape (num_points, num_dims) + + Y : ndarray, 1 or 2-dimensional + The response matrix, shape (num_points, num_responses). + + n_components : int + Number of dimensions for embedding. Default is 2. + + affinity : string or callable, default : "nearest_neighbors" + How to construct the affinity matrix. + - 'nearest_neighbors' : construct affinity matrix by knn graph + - 'rbf' : construct affinity matrix by rbf kernel + + n_neighbors : int, optional, default=None + Number of neighbors for kNN graph construction on X. + + gamma : float, optional, default=None + Scaling factor for RBF kernel on X. + + mu : float, optional, default=1.0 + Influence of the Y-similarity penalty. + + y_gamma : float, optional + Scaling factor for RBF kernel on Y. + Defaults to the inverse of the median distance between rows of Y. + + Returns + ------- + embedding : ndarray, 2-dimensional + The embedding of X, shape (num_points, n_components) + """ + + if eigen_solver not in ('auto', 'arpack', 'dense'): + raise ValueError("unrecognized eigen_solver '%s'" % eigen_solver) + + nbrs = NearestNeighbors(n_neighbors=n_neighbors + 1) + nbrs.fit(X) + X = nbrs._fit_X + + Nx, d_in = X.shape + Ny = Y.shape[0] + + if n_components > d_in: + raise ValueError("output dimension must be less than or equal " + "to input dimension") + if Nx != Ny: + raise ValueError("X and Y must have same number of points") + if affinity == 'nearest_neighbors': + if n_neighbors >= Nx: + raise ValueError("n_neighbors must be less than number of points") + if n_neighbors == None or n_neighbors <= 0: + raise ValueError("n_neighbors must be positive") + elif affinity == 'rbf': + if gamma != None and gamma <= 0: + raise ValueError("n_neighbors must be positive") + else: + raise ValueError("affinity must be 'nearest_neighbors' or 'rbf' must be positive") + + if Y.ndim == 1: + Y = Y[:, None] + + if y_gamma is None: + dists = pairwise_distances(Y) + y_gamma = 1.0 / median(dists) + + if affinity == 'nearest_neighbors': + affinity = kneighbors_graph(X, n_neighbors, include_self=True) + else: + if gamma == None: + dists = pairwise_distances(X) + gamma = 1.0 / median(dists) + affinity = kneighbors_graph(X, n_neighbors, mode='distance', include_self=True) + affinity.data = exp(-gamma * affinity.data ** 2) + + K = rbf_kernel(Y, gamma=y_gamma) + lap = laplacian(affinity, normed=True) + lapK = laplacian(K, normed=True) + embedding, _ = null_space(lap + mu * lapK, n_components, + k_skip=1, eigen_solver=eigen_solver, + tol=tol, max_iter=max_iter, + random_state=random_state) + + return embedding + + +class LER(LocallyLinearEmbedding): + """Scikit-learn compatible class for LER.""" + + def __init__(self, n_components=2, affinity='nearest_neighbors', + n_neighbors=2, gamma=None, mu=1.0, y_gamma=None, + eigen_solver='auto', tol=1E-6, max_iter=100, + random_state=None, neighbors_algorithm='auto'): + + self.n_components = n_components + self.affinity = affinity + self.n_neighbors = n_neighbors + self.gamma = gamma + self.mu = mu + self.y_gamma = y_gamma + self.eigen_solver = eigen_solver + self.tol = tol + self.max_iter = max_iter + self.random_state = random_state + self.neighbors_algorithm = neighbors_algorithm + + def fit_transform(self, X, Y): + self.fit(X, Y) + return self.embedding_ + + def fit(self, X, Y): + # NN necessary for out-of-sample extensions + self.nbrs_ = NearestNeighbors(self.n_neighbors, + algorithm=self.neighbors_algorithm) + self.nbrs_.fit(X) + + self.embedding_ = ler( + X, Y, n_components=self.n_components, + affinity=self.affinity, n_neighbors=self.n_neighbors, + gamma=self.gamma, mu=self.mu, y_gamma=self.y_gamma, + eigen_solver=self.eigen_solver, tol=self.tol, + max_iter=self.max_iter, random_state=self.random_state) + + return self +``` diff --git a/assets/src/DRA/DRA.0.8.md b/assets/src/DRA/DRA.0.8.md index 3e7af32b..33f9d169 100644 --- a/assets/src/DRA/DRA.0.8.md +++ b/assets/src/DRA/DRA.0.8.md @@ -1,6 +1,227 @@ ### Deeplearning Algorithms tutorial + 谷歌的人工智能位于全球前列，在图像识别、语音识别、无人驾驶等技术上都已经落地。而百度实质意义上扛起了国内的人工智能的大旗，覆盖无人驾驶、智能助手、图像识别等许多层面。苹果业已开始全面拥抱机器学习，新产品进军家庭智能音箱并打造工作站级别Mac。另外，腾讯的深度学习平台Mariana已支持了微信语音识别的语音输入法、语音开放平台、长按语音消息转文本等产品，在微信图像识别中开始应用。全球前十大科技公司全部发力人工智能理论研究和应用的实现，虽然入门艰难，但是一旦入门，高手也就在你的不远处！ AI的开发离不开算法那我们就接下来开始学习算法吧！ #### t－分布随机近邻嵌入(t-SNE) -t－分布随机近邻嵌入(t-Distributed Stochastic Neighbor Embedding,t-SNE) + +t－分布随机近邻嵌入(t-Distributed Stochastic Neighbor Embedding,t-SNE) 是用于降维的一种机器学习算法，是由 Laurens van der Maaten 和 Geoffrey Hinton在08年提出来。此外，t-SNE 是一种非线性降维算法，非常适用于高维数据降维到2维或者3维，进行可视化。 + +流形(Manifold)是局部具有欧式空间性质的空间，包括各种纬度的曲线曲面，例如球体、弯曲的平面等。流形的局部和欧式空间是同构的。但是在全局尺度下不能简单的用欧式几何计算。一个好理解的例子就是地球，我们在几米的尺度下计算三角形的内角和是180度，但是在几百公里的尺度下会大于180度。因为地球上有意义的数据点是分布在球面上的，此时需要引入黎曼几何来描述问题。可见流形空间在真实世界中其实是大量存在的，所以我们对数据进行了一个假设，假设数据都是在高维欧式空间中的低维流形，如果我们能将其降维到低维，就能直观的发现其本质和一些内在规律。t-SNE就是基于这样的一个假设。 + +降维（dimension reduction）的基本作用： + +* 缓解维数灾难。即提高样本密度，以及使基于欧氏距离的算法重新生效。 + +* 数据预处理。对数据去冗余、降低信噪比。 + +* 方便可视化。 + +降维的概念中有两对直觉性的概念会反复出现：高维/低维空间、高维/低维数据。在文献中他们有若干别称： + +* 高维空间（high-dimensional space），又叫原空间（original space） + +* 高维数据（low-dimensional data），也直接叫数据点（data points），用于和下述的映射点对应。 + +* 低维空间（low-dimensional space），又叫嵌入空间（embedded space）、低维映射（low-dimensional map，map在此做名词用）等。 + +* 低维数据（low-dimensional data），又叫低维嵌入（low-dimensional embeddings）、低维表示（low-dimensional representations）、映射点（map points）等。 + +嵌入（embedding）：数学上，嵌入是指一个数学结构经映射包含在另一个结构中。 + +* NLP目前所使用的词嵌入（word embedding）一词的本意可能就是这个意思。最初所使用的词向量是one-hot向量，维度等于词表大小（约几十万）。后来采用分布式表示的词向量，维度一般取几百维。因此我们认为分布式表示的词向量是更高维度语义空间的低维嵌入（embedding）。 + +* "Embed Everything！" 嵌入的思想不仅可以用在词（word）上，还能用于许多其他技术上。如知识图谱中可以把原先的网络结构也做嵌入，有实体嵌入、关系嵌入等。 + +降维技术可以分为线性和非线性两大类. + +线性降维技术。侧重让不相似的点在低维表示中分开。 + +* PCA（Principle Components Analysis，主成分分析）. + +* MDS（Multiple Dimensional Scaling，多维缩放）等. + +非线性降维技术（广义上“非线性降维技术”≈“流形学习”，狭义上后者是前者子集）。这类技术假设高维数据实际上处于一个比所处空间维度低的非线性流形上，因此侧重让相似的近邻点在低维表示中靠近。 + +* Sammon mapping. + +* SNE（Stochastic Neighbor Embedding，随机近邻嵌入），t-SNE是基于SNE的。 + +* Isomap（Isometric Mapping，等度量映射）. + +* MVU（Maximum Variance Unfolding）. + +* LLE（Locally Linear Embedding，局部线性嵌入）等. + +流形（manifold）： + +* 机器学习中指的流形指本征维度较低但嵌入在高维空间中的空间（a manifold haslow intrinsic dimensions, and is embedded within a space of much higher dimensionality）。比如上图中的S-curve数据集，本征维度=2（摊开来是一个二维空间），但被嵌在三维空间中。 + +* 数学中提到流形，强调其具有局部欧式空间的性质，可以在局部应用欧几里得距离。但是在机器学习（流形学习）中，这个假设基本不成立。原因是高维空间由于维数灾难的存在，没有足够稠密的数据能在足够小的局部去近似该流形。 + +* 但是流形概念中局部的思想仍可以借鉴。它为降维提供了另一个视角：从微观角度去探索高维数据结构。 + +学习：流形学习之所以叫学习，因为它不像PCA一类的纯线性代数降维方法，而是更像一个类似神经网络的学习算法。 + +* 神经网络大部分是有监督学习；流形学习大部分是无监督学习。 + +* 神经网络拟合一个分类函数；流形学习（以t-SNE为例）拟合高维数据的分布。 + +* 神经网络学习参数；流形学习（以t-SNE为例）直接学习低维数据的表达。 + +* 两者均有损失函数、梯度下降、迭代轮数等学习算法的特点。 + +#### t-分布 + +学生t-分布（t-distribution）用于根据小样本来估计呈正态分布且方差未知的总体的均值。其曲线形态与自由度有关，自由度越小，t分布越平坦；自由度为无穷时，t分布等同于标准正态分布。本文主要目的是理解t-SNE，所以只需要知道t-分布的解析式和曲线形状（见下图）即可，更多的内容请自行Wiki。 + +

+ +

+ +#### SNE + +t-SNE可以看做是SNE的改进，所以我们从SNE开始说起。SNE的核心思路可以概括如下： + +在高维空间相似的数据点，映射到低维空间距离也是相似的。常规的做法是用欧式距离表示这种相似性，而SNE把这种距离关系转换为一种条件概率来表示相似性。并使高维和低维下每个数据点对于其他数据点的相似性分布尽量接近。 + +对于高维空间中每一个数据点 xi来说，xj是剩下的每个数据点，我们可以算出 xi 和每一个 xj 的欧式距离 dj 。但是不同维度下的欧式距离没有可比性，所以SNE的想法是构造一个概率来表征出这种距离的相似度来，一个合适易求导的分布就是高斯分布。构造一个 μ=xi 的高斯分布，并假设 σ=σi 是已知的（方差如何选择会在后面讨论）。那么每个 xj 和 xj 的距离对应的概率就可以作为相似度的度量。如下图，显然距离远的点相似度很底，距离近的点相似度很高。 + +那么这个“高斯相似度”可以定义如下: + +

+ +

+ +另外因为我们只考虑不同数据点之间的相似度，所以定义 sim(xi,xi)=0. + +对 xi 和所有的 xj 计算相似度，我们就可以得到 xi 的相似度分布了，这个分布每一点的概率可以写成条件概率的形式，为了保证概率和为1，需要做归一化。即： + +

+ +

+ + +相应的，在低维度我们做同样的处理，设 xi 在低维的映射是 yi ，则可以得到低维下拟合每对数据点相似度的条件概率 。另外由于我们可以任意假设低维下数据点的分布，为了方便和好看就设置每个数据点的相似度分布（同样是高斯分布）的 。于是有 + + +

+ +

+ +此时就很明朗了，如果 yi 和 yj 能真实反映 xi 和 xj 的关系，那么 pj|i 和 qj|i 就应该是完全相等的。我们对所有j计算条件概率，就能得到这个条件概率的完整分布 Pi 。同理可以得到低维下的分布 Qi 。我们的目标就是使两个分布尽量接近，自然而然想到了KL散度。于是SNE的代价函数就可以写出来了，用梯度下降求解即可。 + +

+ +

+ +求梯度的过程参考softmax函数的梯度，这里不重要，省略过程。对 yi 求梯度得到: + +

+ +

+ +其实这个梯度是有一定物理意义的，可以把 yi 看做一个分子，它最终的受力方向是由所有其他分子对它的合力决定的。对其中一个分子j来说， (pj∣i−qj∣i+pi∣j−qi∣j) 决定了力的大小，(yi−yj) 决定了力的方向。在初始化中，可以用较小的 σ 下的高斯分布来进行初始化。为了加速优化过程和避免陷入局部最优解，梯度中需要使用一个相对较大的动量(momentum)。即参数更新中除了当前的梯度，还要引入之前的梯度累加的指数衰减项，如下: + + +

+ +

+ +这里的 Y(t) 表示迭代t次的解，η 表示学习速率, α(t) 表示迭代t次的动量。另外SNE在超参数的选择上需要做多次优化才可以。 + + +#### 困惑度（Perplexity） + +刚才在构建 qj|i 时，我们假设已知了每个 xi 的高斯相似度分布的 σ 。那 σ 究竟应该怎么设置呢？SNE的唯一参数困惑度就是用来为每个数据点 xi 寻找合适的 σi 的。困惑度可以定义为: + +

+ +

+ +其中 H(Pi) 是 Pi 的香农熵。从直观上是可以理解这个式子的，数据越混乱，熵越大，为了使每个数据点的困惑度都满足给定的困惑度，就需要一个很大的 σi使高斯分布尽量平坦，这样得到的每个 pj|i 就更接近一些。实际上我们经常将Perp设置为近邻数，因为增大 σ 就相当于增加近邻数据点。困惑度通常会被设置为 5 - 50 之间，并且在这个范围内具有良好的鲁棒性。 + +因为 σi 和 Perp(Pi)是线性相关的，所以当设置好Perp后，我们可以简单的用 Binary Search 去为每个高斯分布找一个对应的 σi 。 + +#### Symmetric SNE + +SNE设计出来之后，效果其实并没有想象的那么好。在人们尝试着去寻找优化方案时发现了这样一个问题， pj|i 和 pi|j 是不对称的。这违背了相似度这个概念的初衷，Symmetric SNE 就是来解决这个问题的。 + +Symmetric SNE 把条件概率转换为了联合概率去度量相似度，这样就确保了对称性。在实践中联合概率采用了一种简单直观的定义方式: + +

+ +

+ +其中n为数据点总数。这样定义既保证了对称性，又保证了每个点对总代价的贡献都不会太小（因为 ）。此外，由联合分布计算出的梯度拥有更简单的形式，计算效率更高了。 + +

+ +

+ +#### 拥挤问题（The Crowding Problem） + +虽然 Symmetric SNE 解决了不对称问题，但是其得到的结果类边界也还是有一些模糊。这里涉及到了一个从高维降到低维所面临的拥挤问题。举个例子，我们假设在10维空间中有11个点两两距离相等，但是其降到可以可视化的二维后，我们是没有办法保存它们距离两两相等的信息的，因为在二维空间中最多只有三个点的距离可以两两相等。 + +再假设在三维空间里有一个球体，数据点在球体内均匀分布。如果想把它降到二维，根据各个点到球心的距离，会得到一个圆形范围，且越靠近球面的数据点越密集。同理，越是高维的“球体”，降到低维后边缘越拥挤，因为高维球体的体积是呈 rd 增长的。这就是所谓的拥挤问题，降维后的簇会拥挤在一起无法区分，SNE 和 Symmetric SNE 都不能很好地解决这个问题。 + +#### t-SNE + +然后t-SNE出现了，t-SNE在SNE的基础上做出了如下两个改进： + +* 使用联合概率代替条件概率（同 Symmetric SNE） +* 在低维空间使用t分布代替高斯分布（高维空间不变） + +其中第一个改进保证了对称性和代价函数的下限，第二个改进一定程度上解决了拥挤问题。那么t分布是怎么解决拥挤问题的呢？ + +

+ +

+ +t分布有一个重要的特点：属于长尾分布。我们看上图，高斯分布在3sigma后的概率密度就变得特别小，因此为了迎合长尾部分的数据，它会主动变得平坦，从而导致拟合不准确。或者可以说，高斯分布对异常值较为敏感。而t分布的长尾特性使其既能兼顾均值周围的数据点，又能兼顾边缘的数据点，更好的捕获了数据的特征。 + +

+ +

+ +除此之外，高斯分布和t分布的差异也有助于缓解拥挤问题。我们看上图，横轴表示距离，纵轴表示相似度, 可以看到，对于较大相似度的点，t分布在低维空间中的距离需要稍小一点；而对于低相似度的点，t分布在低维空间中的距离需要更远。这恰好满足了我们的需求，即同一簇内的点(距离较近)聚合的更紧密，不同簇之间的点(距离较远)更加疏远。 + +使用了自由度为1的t分布后， qij 变成了： + +

+ +

+ +可以看出公式里少了指数函数，计算上会方便很多。最终得到t-SNE的更新梯度（推导见原论文Appendix）是: + +

+ +

+ +然后再利用梯度下降求解 yi 即可。 + +#### t-SNE效果 + +t-SNE降维后的效果，总体是完爆其他可视化降维方法的。 + +

+ +

+ +t-SNE得到的是局部最优解。因为KL散度是一个不对称的度量，从代价函数的公式中可以看出，当 pj|i 较大， qj|i 较小时，代价较高；而当 qj|i 较大， pj|i 较小时，代价较低。什么意思呢？就是当高维空间距离远，低维空间距离近的时候，代价函数会很高，模型会尽量避免这种事情发生，所以会加大低维的距离，这没问题。 + +但是当高维近低维远的时候，代价会变低，模型也就不会在乎这个问题，导致低维空间距离较远的点始终拉不近。换句话说，t-SNE的代价函数更关注局部结构，而忽视了全局结构。所以假设数据集是在高维空间中的低维流形这一点是比较重要的，如果数据集的本征维度本身就很高，那么是不可能完整的映射到2-3维空间的。 + +#### t-SNE优点 + +流形学习中其他方法如Isomap、LLE等，主要用于展开单个连续的低维流形（比如“瑞士卷”数据集），而t-SNE主要用于数据的局部结构，并且会倾向于提取出局部的簇，这种能力对于可视化同时包含多个流形的高维数据（比如MNIST数据集）很有效。 + +#### t-SNE缺点 + +* 时间、空间复杂度为O(n^2)，计算代价昂贵。百万量级的数据需要几小时，对于PCA可能只需要几分钟。 + +* 升级版Barnes-Hut t-SNE可以让复杂度降为O(nlogn)，但只限于获得二维和三维的嵌入。（sklearn中可以直接使用参数method='barnes_hut'） + +* 由于代价函数非凸，多次执行算法的结果是随机的（名字中“Stochatsic”的由来？），需要多次运行选取最好的结果。 + +* 全局结构不能很清楚的保留。这个问题可以通过先用PCA降维到一个合理的维度（如50）后再用t-SNE来缓解，前置的PCA步骤也可以起到去除噪声等功能。（sklearn中可以直接使用参数init='pca'）. diff --git a/assets/src/DRA/DRA.0.9.md b/assets/src/DRA/DRA.0.9.md index 1780af93..c9bf8de9 100644 --- a/assets/src/DRA/DRA.0.9.md +++ b/assets/src/DRA/DRA.0.9.md @@ -3,3 +3,5 @@ AI的开发离不开算法那我们就接下来开始学习算法吧！ #### 深度自动编码器(Deep Autoencoder Networks) + +自动编码器是一种无监督的神经网络模型，它可以学习到输入数据的隐含特征，这称为编码(coding)，同时用学习到的新特征可以重构出原始输入数据，称之为解码(decoding)。从直观上来看，自动编码器可以用于特征降维，类似主成分分析PCA，但是其相比PCA其性能更强，这是由于神经网络模型可以提取更有效的新特征。除了进行特征降维，自动编码器学习到的新特征可以送入有监督学习模型中，所以自动编码器可以起到特征提取器的作用。作为无监督学习模型，自动编码器还可以用于生成与训练样本不同的新数据，这样自动编码器（变分自动编码器，Variational Autoencoders）就是生成式模型。 diff --git a/assets/src/EL/EL.0.1.md b/assets/src/EL/EL.0.1.md new file mode 100644 index 00000000..3cbe8ee5 --- /dev/null +++ b/assets/src/EL/EL.0.1.md @@ -0,0 +1,23 @@ +### Deeplearning Algorithms tutorial +谷歌的人工智能位于全球前列，在图像识别、语音识别、无人驾驶等技术上都已经落地。而百度实质意义上扛起了国内的人工智能的大旗，覆盖无人驾驶、智能助手、图像识别等许多层面。苹果业已开始全面拥抱机器学习，新产品进军家庭智能音箱并打造工作站级别Mac。另外，腾讯的深度学习平台Mariana已支持了微信语音识别的语音输入法、语音开放平台、长按语音消息转文本等产品，在微信图像识别中开始应用。全球前十大科技公司全部发力人工智能理论研究和应用的实现，虽然入门艰难，但是一旦入门，高手也就在你的不远处！ +AI的开发离不开算法那我们就接下来开始学习算法吧！ + +#### 集成算法(Ensemble Learning) + +集成学习(Ensemble Learning)是使用一序列学习器进行学习，并使用某种规则把各个学习结果进行整合从而获得比单个学习器更好的学习效果的一种机器学习方法。集成学习中多个学习器被称为“弱学习器”，如果这些弱学习器都是一个种类的，则被称为是同质的；若这些弱学习器不全是一个种类的，则被称为异质的。一般情况下，集成学习中的多个学习器都是同质的“弱学习器” + +集成学习在各个规模的数据集上都有很好的策略。 + +* 数据集大：划分成多个小数据集，学习多个模型进行组合 +* 数据集小：利用Bootstrap方法进行抽样，得到多个数据集，分别训练多个模型再进行组合 + +集成算法(Ensemble Learning)主要包括: + +* Boosting +* Bagging +* AdaBoost +* 堆叠泛化（混合） +* GBM 算法 +* GBRT 算法 +* 随机森林 + diff --git a/assets/src/EL/EL.0.2.md b/assets/src/EL/EL.0.2.md new file mode 100644 index 00000000..b25fa577 --- /dev/null +++ b/assets/src/EL/EL.0.2.md @@ -0,0 +1,20 @@ +### Deeplearning Algorithms tutorial +谷歌的人工智能位于全球前列，在图像识别、语音识别、无人驾驶等技术上都已经落地。而百度实质意义上扛起了国内的人工智能的大旗，覆盖无人驾驶、智能助手、图像识别等许多层面。苹果业已开始全面拥抱机器学习，新产品进军家庭智能音箱并打造工作站级别Mac。另外，腾讯的深度学习平台Mariana已支持了微信语音识别的语音输入法、语音开放平台、长按语音消息转文本等产品，在微信图像识别中开始应用。全球前十大科技公司全部发力人工智能理论研究和应用的实现，虽然入门艰难，但是一旦入门，高手也就在你的不远处！ +AI的开发离不开算法那我们就接下来开始学习算法吧！ + +#### Boosting + +Bagging是Bootstrap aggregating的简写。这里先说一下`bootstrap`，`bootstrap` 也被称为自助法，它是一种有放回的抽样方法，目的为了得到统计量的分布以及置信区间。 + +Baggging 和 Boosting都是模型融合的方法，可以将弱分类器融合之后形成一个强分类器，而且融合之后的效果会比最好的弱分类器更好。 + +Bagging即套袋法，其算法过程如下： + +从原始样本集中抽取训练集。每轮从原始样本集中使用Bootstraping的方法抽取n个训练样本（在训练集中，有些样本可能被多次抽取到，而有些样本可能一次都没有被抽中）。共进行k轮抽取，得到k个训练集。（k个训练集之间是相互独立的） + +* 每次使用一个训练集得到一个模型，k个训练集共得到k个模型。（注：这里并没有具体的分类算法或回归方法，我们可以根据具体问题采用不同的分类或回归方法，如决策树、感知器等） + +* 对分类问题：将上步得到的k个模型采用投票的方式得到分类结果；对回归问题，计算上述模型的均值作为最后的结果。（所有模型的重要性相同） + + +Boosting这其实思想相当的简单，大概是，对一份数据，建立M个模型（比如分类），一般这种模型比较简单，称为弱分类器(weak learner)每次分类都将上一次分错的数据权重提高一点再进行分类，这样最终得到的分类器在测试数据与训练数据上都可以得到比较好的成绩。 diff --git a/assets/src/EL/EL.0.3.md b/assets/src/EL/EL.0.3.md new file mode 100644 index 00000000..758daf19 --- /dev/null +++ b/assets/src/EL/EL.0.3.md @@ -0,0 +1,4 @@ +### Deeplearning Algorithms tutorial +谷歌的人工智能位于全球前列，在图像识别、语音识别、无人驾驶等技术上都已经落地。而百度实质意义上扛起了国内的人工智能的大旗，覆盖无人驾驶、智能助手、图像识别等许多层面。苹果业已开始全面拥抱机器学习，新产品进军家庭智能音箱并打造工作站级别Mac。另外，腾讯的深度学习平台Mariana已支持了微信语音识别的语音输入法、语音开放平台、长按语音消息转文本等产品，在微信图像识别中开始应用。全球前十大科技公司全部发力人工智能理论研究和应用的实现，虽然入门艰难，但是一旦入门，高手也就在你的不远处！ +AI的开发离不开算法那我们就接下来开始学习算法吧！ + diff --git a/assets/src/EL/EL.0.4.md b/assets/src/EL/EL.0.4.md new file mode 100644 index 00000000..758daf19 --- /dev/null +++ b/assets/src/EL/EL.0.4.md @@ -0,0 +1,4 @@ +### Deeplearning Algorithms tutorial +谷歌的人工智能位于全球前列，在图像识别、语音识别、无人驾驶等技术上都已经落地。而百度实质意义上扛起了国内的人工智能的大旗，覆盖无人驾驶、智能助手、图像识别等许多层面。苹果业已开始全面拥抱机器学习，新产品进军家庭智能音箱并打造工作站级别Mac。另外，腾讯的深度学习平台Mariana已支持了微信语音识别的语音输入法、语音开放平台、长按语音消息转文本等产品，在微信图像识别中开始应用。全球前十大科技公司全部发力人工智能理论研究和应用的实现，虽然入门艰难，但是一旦入门，高手也就在你的不远处！ +AI的开发离不开算法那我们就接下来开始学习算法吧！ + diff --git a/assets/src/HPD/HPD.md b/assets/src/HPD/HPD.md index 7952183e..5df2bb20 100644 --- a/assets/src/HPD/HPD.md +++ b/assets/src/HPD/HPD.md @@ -1,7 +1,8 @@ ### Deeplearning Algorithms tutorial + 谷歌的人工智能位于全球前列，在图像识别、语音识别、无人驾驶等技术上都已经落地。而百度实质意义上扛起了国内的人工智能的大旗，覆盖无人驾驶、智能助手、图像识别等许多层面。苹果业已开始全面拥抱机器学习，新产品进军家庭智能音箱并打造工作站级别Mac。另外，腾讯的深度学习平台Mariana已支持了微信语音识别的语音输入法、语音开放平台、长按语音消息转文本等产品，在微信图像识别中开始应用。全球前十大科技公司全部发力人工智能理论研究和应用的实现，虽然入门艰难，但是一旦入门，高手也就在你的不远处！ -AI的开发离不开算法那我们就接下来开始学习算法吧！ +AI的开发离不开算法那我们就接下来开始学习算法吧！ 所谓的人工神经网络 （Artificial Neural Network，ANN）简称神经网络(NN)，是基于生物学中神经网络的基本原理，在理解和抽象了人脑结构和外界刺激响应机制后，以网络拓扑知识为理论基础，模拟人脑的神经系统对复杂信息的处理机制的一种数学模型，根植于神经科学、数学、思维科学、人工智能、统计学、物理学、计算机科学以及工程科学的一门技术，通常用于解决分类和回归问题。具有并行分布的处理能力、高容错性、智能化和自学习等能力的特征，本质上是一个有大量简单元件相互连接而成的复杂网络，具有高度的非线性，能够进行复杂的逻辑操作和非线性关系实现的系统。 @@ -67,17 +68,25 @@ Hopfield网络按网络输入和输出的数字形式不同可分为离散型和 DHNN结构：它是一种单层全反馈网络,共有n个神经元。每个神经元都通过连接权接收所有其它神经元输出反馈来的信息，其目的是为了让任一神经元的输出能接受所有神经元输出的控制,从而使各神经元能相互制约。 -DHNN的设计原则：吸引子的分布是由网络的权值（包括阀值）决定的，设计吸引子的核心就是如何设计一组合适的权值。为了使所设计的权值满足要求，权值矩阵应符合以下要求：(1)为保证异步方式工作时网络收敛，W应为对称阵；(2)为保证同步方式工作时网络收敛，W应为非负定对称阵；(3)保证给定的样本是网络的吸引子，并且要有一定的吸引域。 +DHNN的设计原则：吸引子的分布是由网络的权值（包括阀值）决定的，设计吸引子的核心就是如何设计一组合适的权值。为了使所设计的权值满足要求，权值矩阵应符合以下要求： -具体设计时，可以采用不同的方法：(1)联立方程法；(2)外积和法。 +(1)为保证异步方式工作时网络收敛，W应为对称阵； -CHNN：在连续型Hopfield神经网络中，所有神经元都随时间t并行更新，网络状态随时间连续改变。 +(2)为保证同步方式工作时网络收敛，W应为非负定对称阵； + +(3)保证给定的样本是网络的吸引子，并且要有一定的吸引域。 +具体设计时，可以采用不同的方法： + +(1)联立方程法； + +(2)外积和法。 + +CHNN：在连续型Hopfield神经网络中，所有神经元都随时间t并行更新，网络状态随时间连续改变。 #### 应用领域 Hopfield是反馈归神经网络，主要应用于联想记忆、聚类以及优化计算等方面。 - #### 优缺点 Hopfield网络是一种非线性的动力网络，可通过反复的网络动态迭代来求解问题，这是符号逻辑方法所不具有的特性。在求解某些问题时，其求解问题的方法与人类求解问题的方法很相似，虽然所求得的解不是最佳解，但其求解速度快，更符合人们日常解决问题的策略。 diff --git a/assets/src/LLM/img.png b/assets/src/LLM/img.png new file mode 100644 index 00000000..d5c17b3c Binary files /dev/null and b/assets/src/LLM/img.png differ diff --git a/assets/src/LLM/img_1.png b/assets/src/LLM/img_1.png new file mode 100644 index 00000000..d5c17b3c Binary files /dev/null and b/assets/src/LLM/img_1.png differ diff --git a/assets/src/LLM/llm.md b/assets/src/LLM/llm.md new file mode 100644 index 00000000..1f32b023 --- /dev/null +++ b/assets/src/LLM/llm.md @@ -0,0 +1,172 @@ +#### 什么是大型语言模型？ + +大型语言模型（LLM）是基于大量数据进行预训练的超大型深度学习模型。底层转换器是一组神经网络，这些神经网络由具有自注意力功能的编码器和解码器组成。编码器和解码器从一系列文本中提取含义，并理解其中的单词和短语之间的关系。 + +转换器 LLM 能够进行无监督的训练，但更精确的解释是转换器可以执行自主学习。通过此过程，转换器可学会理解基本的语法、语言和知识。 + +与早期按顺序处理输入的循环神经网络（RNN）不同，转换器并行处理整个序列。这可让数据科学家使用 GPU 训练基于转换器的 LLM，从而大幅度缩短训练时间。 + +借助转换器神经网络架构，您可使用非常大规模的模型，其中通常具有数千亿个参数。这种大规模模型可以摄取通常来自互联网的大量数据，但也可以从包含 500 多亿个网页的 Common Crawl 和拥有约 5700 万个页面的 Wikipedia 等来源摄取数据。 + +#### 为什么大型语言模型如此重要？ + +大型语言模型非常灵活。一个模型可以执行完全不同的任务，例如回答问题、总结文档、翻译语言和完成语句。LLM 有可能破坏内容创作以及人们使用搜索引擎和虚拟助手的方式。 + +尽管并不完美，但 LLM 表现出根据相对较少量的提示或输入做出预测的非凡能力。LLM 可用于生成式人工智能，以根据采用人类语言的输入提示生成内容。 + +LLM 非常庞大。它们可以考虑数十亿个参数，并且有许多可能的用途。下面是一些示例： + +Open AI 的 GPT-3 模型有 1750 亿个参数。类似的产品 ChatGPT 可以从数据中识别模式并生成自然且可读的输出。 + +虽然我们不知道 Claude 2 的规模，但该模型可以在每个提示中输入多达 10 万个令牌，这意味着它可以处理数百页的技术文档，甚至可以处理整本书。 + +AI21 Labs 的 Jurassic-1 模型具有 1780 亿个参数和由 25 万单词部分组成的令牌词汇表以及类似的对话功能。 + +Cohere 的 Command 模型具有类似的功能，并且可以使用 100 多种不同的语言开展工作。 + +LightOn 的 Paradigm 提供根基模型，并且宣称该模型的功能超过 GPT-3。所有这些 LLM 都带有 API，可让开发人员打造独特的生成式人工智能应用程序。 + + +Timeline of LLMs: + +

+ +

+ +#### 大型语言模型如何运作？ + +LLM 运作原理的一个关键因素是它们表示单词的方式。 + +早期的机器学习使用数字表来表示每个单词。但是，这种表示形式无法识别单词之间的关系，例如具有相似含义的单词。 + +人们采用如下方式克服此限制：使用多维向量（通常称为单词嵌入）来表示单词，从而使具有相似上下文含义或其他关系的单词在向量空间中彼此接近。 + +使用单词嵌入，转换器可以通过编码器将文本预处理为数字表示，并理解含义相似的单词和短语的上下文以及单词之间的其他关系，例如语音部分。然后，LLM 就可以通过解码器应用这些语言知识来生成独特的输出。 + +#### 大型语言模型有哪些应用？ + +LLM 有很多实际应用。 + +* 文案写作 + +除了 GPT-3 和 ChatGPT 之外，Claude、Llama 2、Cohere Command 和 Jurassic 也可编写原件。 + +AI21 Wordspice 建议修改原始语句以改善风格和语音。 + +* 知识库回答 + +该技术通常称为知识密集型自然语言处理（KI-NLP），是指可以根据数字存档中的信息帮助回答特定问题的 LLM。AI21 Studio playground 能够回答常识性问题就是此类示例。 + +* 文本分类 + +使用集群，LLM 可以对含义或情绪相似的文本进行分类。用途包括衡量客户情绪、确定文本之间的关系和文档搜索。 + +* 代码生成 + +LLM 擅长根据自然语言提示生成代码。示例包括 Amazon CodeWhisperer 和 GitHub Copilot 中使用的 Open AI Codex，它们可以用 Python、JavaScript、Ruby 和其他几种编程语言编码。其他编码应用包括创建 SQL 查询、编写 Shell 命令和进行网站设计。 + +* 文本生成 + +与代码生成类似，文本生成可以完成不完整的语句，编写产品文档，或者像 Alexa Create 一样创作简短的儿童故事。 + +#### 如何训练大型语言模型？ + +基于转换器的神经网络非常庞大。这些网络包含多个节点和层。层中的每个节点都有指向后续层中所有节点的连接，并且每个节点都有权重和偏差。权重和偏差以及嵌入称为模型参数。基于转换器的大型神经网络可以有数十亿个参数。模型的大小通常由模型大小、参数数量和训练数据规模之间的经验关系决定。 + +使用大量高质量数据执行训练。在训练过程中，模型会迭代调整参数值，直到模型可根据前一个输入令牌序列正确预测下一个令牌。为此，模型使用自学技术，这些技术教导模型调整参数，以最大限度地提高训练示例中正确预测下一个令牌的可能性。 + +经过训练，LLM 可以很容易地适应使用相对较小的有监督数据集执行多项任务，这一过程称为微调。 + +存在三种常见的学习模型： + +* 零样本学习；Base LLM 无需明确训练即可响应各种请求，通常是通过提示，但是答案的准确性各不相同。 +* 少量样本学习：通过提供一些相关的训练示例，基础模型在该特定领域的表现显著提升。 +* 微调：这是少量样本学习的扩展，其中数据科学家训练基础模型，使模型使用与特定应用相关的其他数据来调整其参数。 + +#### LLM 的未来前景是什么？ + +随着 ChatGPT、Claude 2 和 Llama 2 等可以回答问题和生成文本的大型语言模型的引入，我们可以预见令人兴奋的未来前景。可以肯定的是，LLM 会越来越接近人性化的表现，尽管这一过程会较为漫长。这些 LLM 即时取得的成功表明人们对机器人类型 LLM 的浓厚兴趣，这些 LLM 可模仿人类大脑的思维，在某些情况下表现甚至优于人类大脑。以下是一些关于 LLM 未来前景的想法： + +* 增强的功能 + +尽管 LLM 给人们留下了深刻的印象，但当前的技术水平并不完善，LLM 也并非绝对可靠。然而，随着开发人员学习如何在减少偏见和消除错误答案的同时提高性能，较新的 LLM 版本将提高准确性和增强功能。 + +* 视听训练 + +开发人员使用文本训练大多数 LLM，但有些人已经开始使用视频和音频输入来训练模型。这种形式的训练应该可以加快模型开发速度，并为将 LLM 用于自动驾驶汽车开辟新的可能性。 + +* 工作场所转型 + +LLM 是颠覆性的因素，它将转变工作场所。LLM 可能会采用机器人处理重复性制造任务的相同方式来减少单调和重复的任务。可能减少的任务包括重复的文书任务、客户服务聊天机器人和简单的自动文案写作。 + +* 对话式人工智能 + +LLM 无疑将提高 Alexa、Google Assistant 和 Siri 等自动虚拟助手的性能。这些虚拟助手将能够更妥善地解释用户意图并响应复杂的命令。 + +#### 学习大语言模型指南 + +1. 入门篇： + +* 了解大语言模型的基础知识和常见术语。 +* 学会使用编程语言访问 OpenAI API 等常见大语言模型接口。 + +2. 提高篇： + +* 了解机器学习、神经网络、NLP 的基础知识。 +* 了解 Transformer 以及典型 Decoder-only 语言模型的基础结构和简单原理。 +* 了解大语言模型发展历史，以及业界主流模型（含开源模型）进展。 + +3. 应用篇： + +* 可以在本地环境搭建开源模型的推理环境。 +* Prompt 工程。 +* 使用已有框架（如Langchain）或自行开发，结合大语言模型结果，开发生产应用。 + +4. 深入篇： + +* 掌握 Continue Pre-train、Fine-tuning 已有开源模型的能力。 +* 掌握 Lora、QLora 等低资源高效模型训练的能力。 +* 掌握大语言模型微调以及预训练数据准备的能力。 +* 深入了解大模型背后的技术原理。 +* 了解生产环境部署大模型的相关技术点。 + +#### 学习资料 + +1. 入门篇 + +* [大语言模型](https://github.com/RUCAIBox/LLMSurvey) +* [ChatGPT Prompt Engineering for Developers](https://learn.deeplearning.ai/courses/chatgpt-prompt-eng/lesson/1/introduction) +* [Prompt中英双语字幕](https://github.com/GitHubDaily/ChatGPT-Prompt-Engineering-for-Developers-in-Chinese) +* [OpenAI 官方 Quickstart 文档](https://platform.openai.com/docs/api-reference) +* [GPT的训练和应用](https://www.youtube.com/watch?v=bZQun8Y4L2A) +* [GPT的训练和应用稳定](https://karpathy.ai/stateofgpt.pdf) + + +2. 提高篇 + +* [清华大模型公开课:从NLP到大模型的综合课程](https://www.bilibili.com/video/BV1UG411p7zv/?vd_source=66c6e275fb1f3c8315a531e1a1b051d8) +* [深度学习：台湾大学李宏毅](https://www.bilibili.com/video/BV1J94y1f7u5/) +* [The Illustrated GPT-2 (Visualizing Transformer Language Models](https://jalammar.github.io/illustrated-gpt2/) +* [图解 GPT2 中文翻译](https://zhuanlan.zhihu.com/p/139840113) +* [InstructGPT: Training language models to follow instructions with human feedback](https://cdn.openai.com/papers/Training_language_models_to_follow_instructions_with_human_feedback.pdf) +* [RLHF技术详解](https://huggingface.co/blog/zh/rlhf) +* [NLP 入门课程](https://huggingface.co/learn/nlp-course/chapter1/1) + +3. 应用篇 + +* [Building Systems with the ChatGPT API](https://learn.deeplearning.ai/courses/chatgpt-building-system/lesson/1/introduction) +* [使用ChatGPT API构建系统](https://www.bilibili.com/video/BV1gj411X72B/) +* [Langchain 是大语言模型框架](https://python.langchain.com/docs/get_started/introduction) +* [LangChain for LLM Application Development](https://learn.deeplearning.ai/courses/langchain/lesson/1/introduction) +* [LLM应用开发实践](https://www.bilibili.com/video/BV1Ku411x78m/?vd_source=66c6e275fb1f3c8315a531e1a1b051d8) +* [OpenAI 官方出的最佳实践](https://platform.openai.com/docs/guides/gpt-best-practices/gpt-best-practices) +* [OpenAI 官方 Cookbook](https://github.com/openai/openai-cookbook) +* [Prompt 工程简介](https://github.com/brexhq/prompt-engineering) + + +4. 深入篇 + +* [Transformer 官方文档](https://huggingface.co/docs/transformers/index) +* [大语言模型的北极星能力](https://yaofu.notion.site/6dafe3f8d11445ca9dcf8a2ca1c5b199) +* [GPT，GPT-2，GPT-3 论文精读](https://www.bilibili.com/video/BV1AF411b7xQ/) +* [在生产环境中构建 LLM 应用](https://huyenchip.com/2023/04/11/llm-engineering.html) \ No newline at end of file diff --git a/assets/src/LLM/llm01.md b/assets/src/LLM/llm01.md new file mode 100644 index 00000000..8bdfcd04 --- /dev/null +++ b/assets/src/LLM/llm01.md @@ -0,0 +1,288 @@ +#### 什么是大型语言模型？ + +大型语言模型（LLM）是基于大量数据进行预训练的超大型深度学习模型。底层转换器是一组神经网络，这些神经网络由具有自注意力功能的编码器和解码器组成。编码器和解码器从一系列文本中提取含义，并理解其中的单词和短语之间的关系。 + +转换器 LLM 能够进行无监督的训练，但更精确的解释是转换器可以执行自主学习。通过此过程，转换器可学会理解基本的语法、语言和知识。 + +与早期按顺序处理输入的循环神经网络（RNN）不同，转换器并行处理整个序列。这可让数据科学家使用 GPU 训练基于转换器的 LLM，从而大幅度缩短训练时间。 + +借助转换器神经网络架构，您可使用非常大规模的模型，其中通常具有数千亿个参数。这种大规模模型可以摄取通常来自互联网的大量数据，但也可以从包含 500 多亿个网页的 Common Crawl 和拥有约 5700 万个页面的 Wikipedia 等来源摄取数据。 + + +#### 大型语言模型工作原理 + +LLM 通过利用深度学习技术和大量文本数据来运行。这些模型通常基于转换器架构，如生成式预训练转换器，它擅长处理文本输入等顺序数据。LLM 由多层神经网络组成，每层神经网络的参数都可以在训练过程中进行微调，而被称为注意力机制的众多神经网络层则进一步增强了这些神经网络的功能，这些神经网络层可以对数据集的特定部分进行调整。 + +在训练过程中，这些模型学习根据前面单词提供的上下文来预测句子中的下一个单词。该模型通过将概率分数归因于重复的已标记单词（分解为较小的字符序列）来实现这一点。然后，这些标记被转换为嵌入，嵌入是该上下文的数字表示。 + +为了确保准确性，这个过程涉及在大量文本语料库（数十亿页）上训练 LLM，使 LLM 能够通过零样本和自我监督学习来学习语法、语义和概念关系。经过这些训练数据的训练后，LLM 就可以根据它们收到的输入自动预测下一个单词，并利用它们获得的模式和知识来生成文本。其结果是生成连贯且与上下文相关的语言，可用于广泛的 NLU 和内容生成任务。 + +还可以通过即时工程、即时调优、微调和其他策略来提高模型性能，例如基于人类反馈的强化学习 (RLHF)，以消除偏见、仇恨言论和被称为“幻觉”的事实错误答案，这些通常是对如此多的非结构化数据进行训练的有害副产品。这是确保企业级 LLM 随时可用，不会使组织承担不必要的责任或对组织声誉造成损害的最重要的方面之一。 + +#### LLM 用例 + +LLM 正在重新定义越来越多的业务流程，并已在各个行业的无数用例和任务中证明了它们的多功能性。LLM 可以增强聊天机器人和虚拟助理（例如 IBM watsonx Assistant 和 Google 的 BARD）中的会话式 AI，以增强支持卓越客户服务的交互，提供模仿与人工客服交互的情境感知响应。 + +LLM 还擅长内容生成，可以自动创建内容，包括博客文章、营销或销售资料以及其他写作任务。在研究和学术界，它们帮助从大量数据集中总结和提取信息，加速知识发现。LLM 在语言翻译中也发挥着至关重要的作用，通过提供准确且与上下文相关的翻译来打破语言障碍。它们甚至可以用来编写代码，或者在编程语言之间进行“翻译”。 + +此外，它们还通过提供文字转语音应用以及以无障碍格式生成内容等功能，帮助残障人员，为无障碍访问功能做出了贡献。从医疗保健到金融，LLM 正在通过简化流程、改善客户体验以及实现更高效和数据驱动的决策来推动行业发展和变革。 + +最令人兴奋的是，所有这些功能都很容易访问，在某些情况下，实际上只需 API 集成即可。 + +以下是 LLM 为组织带来益处的一些最重要的领域： + +* 文本生成：语言生成能力，如根据提示撰写电子邮件、博客文章或其他中长篇内容，并加以提炼和润色。检索增强生成 (RAG) 就是一个很好的例子。 + +* 内容摘要：将长文章、新闻报道、研究报告、公司文档甚至客户历史记录汇总成根据输出格式定制长度的完整文本。 + +* AI 助手：聊天机器人，可以回答客户询问、执行后端任务并以自然语言提供详细信息，作为集成式自助客户服务解决方案的一部分。 + +* 代码生成：帮助开发人员构建应用程序，查找代码中的错误并发现多种编程语言中的安全问题，甚至在它们之间进行“翻译”。 + +* 情感分析：分析文本，确定客户的语气，以便大规模了解客户反馈并帮助进行品牌声誉管理。 + +* 语言翻译：通过流畅的翻译和多语言功能，为各语言和地域的组织提供更广泛的覆盖范围。 + +LLM 将通过实现客户自助服务自动化、加快对越来越多任务的响应以及提高准确性、增强路由和智能上下文收集，影响从金融到保险、人力资源到医疗保健等各个行业。 + +#### 增加大语言模型推理能力的方案 + +目前，推理的方案与构建通用大型语言模型和聊天机器人的方案密切相关。总共有三个阶段： + +- 预训练或持续训练：在这个阶段，我们通常在大型数据集（如科学文献或代码数据）上训练大型模型。 +- 有监督微调：在这个阶段，我们对模型进行微调，以便完成复杂任务的指令。 +- 强化学习：在这个阶段，我们使用诸如任务是否已全部/部分完成的信号作为奖励。 + +因此，在我们的文献分析中，我们同时考虑推理和编码。我们将看到，就学习方法而言，这两者之间存在惊人的相关性。 + +* 预训练与持续训练 + +分析以下几项研究： + +1. Lewkowycz et. al. 2022. Minerva: [Solving Quantitative Reasoning Problems with Language Models](https://arxiv.org/abs/2206.14858) + +* 在来自 Arxiv 论文的 38.5B 的 token 上继续训练 PaLM 540B。 +* 在 MATH （一个需要使用 LaTeX 格式回答问题的困难数据集），上的得分为 33.6（[GPT-4 的得分是 42.5](https://github.com/FranxYao/chain-of-thought-hub)） + +2. Taylor et. al. 2022. [Galactica: A Large Language Model for Science](https://arxiv.org/abs/2211.09085) + +* 在包含论文、代码、参考资料、知识库和其他内容的 106B token 上预训练一个120B语言模型。 +* 在MATH上的表现为 20.4（Minerva 33.6，GPT-4 42.5） + +3. Chen et. al. 2021. [Codex: Evaluating Large Language Models Trained on Code](https://arxiv.org/abs/2107.03374) + +* 在159GB代码数据上继续训练 12B GPT-3 模型，提高了 HumanEval 数据集上的代码性能。 + +这些研究发现，在大量科学文献代码上进行训练可以显著提高基础模型的推理编码能力。 + +#### 监督微调 + +1. Chung et. al. 2022. [Scaling Instruction-Finetuned Language Models](https://arxiv.org/abs/2210.11416) + +- 使用多样化的指令显著提高了模型零样本泛化的能力 +- 在指令集合中混合思维链数据（[the flan collection](https://arxiv.org/abs/2301.13688) 文章中进一步讨论了这个问题）明显提高了模型的思维链能力 +- 注意：尽管 the flan collection 数据集从多个维度激发了基础模型的能力，但这些指令并非来自真实的聊天机器人用户互动，因此可能[无法直接转化为更好的聊天性能](https://www.yitay.net/blog/flan-ul2-20b)。 + +2. Fu et. al. 2023. [Specializing Smaller Language Models towards Multi-Step Reasoning](https://arxiv.org/abs/2301.12726) + +- 将思维链推理能力提炼到较小规模（小于或等于 10B）的模型。通常，10B 规模的模型非常适合部署（更大的模型太贵了，更小的模型太弱了）。 +- 本文讨论了很多工程细节，如数据工程、能力平衡以及小型和大型模型之间的差异 + +3. [Li et. al. 2022. Competition-Level Code Generation with AlphaCode](https://arxiv.org/abs/2203.07814) + +- 在 715GB 的 GitHub 代码上预训练一个 41B 模型，然后在包含 13k 问题的 CodeContest 数据集上进行微调 +- 在测试期间，使用采样并根据是否通过示例测试来过滤解决方案。从某种意义上说，这种做法类似于推理问题中的 [self-consistency](https://arxiv.org/abs/2203.11171) 方法。 + + +目前关于指令微调的理解是： + +- 通过使用对话格式的数据，将基本模型调优为聊天机器人相对容易（参见像 Alpaca 和 MOSS 这样的优秀示例）。然而，闲聊的能力并不能转化为执行复杂任务的能力。从这个角度来看，模型就像人类一样：说得多不如干得好，代码见真章。 +- 实际上，指令调优问题是一个数据混合问题：如何最好地混合来自不同来源的指令数据，以便从所有角度均匀地提高模型性能（而不是像在 [CoT specialization](https://arxiv.org/abs/2301.12726) 和 [the flan collection](https://arxiv.org/abs/2301.13688) 中讨论的那样，增加一个维度但降低另一个维度）。 +- 数据混合的简单起点是：使用 10-20 个非思维链的数据点（以平衡不同维度的能力），但尽可能多地使用链式思维数据（以最大化推理能力）。 + +#### 强化学习 + +我们分析： + +- Uesato. et. al. 2022. [Solving math word problems with process- and outcome-based feedback](https://arxiv.org/abs/2211.14275) + - 基于中间推理和最终推理结果构建奖励模型。 +- Le et. al. 2022. [CodeRL: Mastering Code Generation through Pretrained Models and Deep Reinforcement Learning](https://arxiv.org/abs/2207.01780) + - 根据诸如编译错误、运行时错误或是否通过测试等信号训练奖励模型。 + +这两项工作都使用中间信号（对于推理，看中间步骤是否正确；对于编码，看代码是否编译）和最终信号作为奖励。 需要注意的是，这种类型的强化学习与基于人类反馈的强化学习（RLHF）有所不同，因为它不需要人类反馈。 + +#### 推理能力和代码能力的耦合 + +这里我们提出了一个假设，即在代码上进行训练可能会提高推理能力，原因如下: + +｜-----------------｜-----------｜-----------| +｜ ｜ 推理 ｜ 代码 ｜ +｜数据格式 ｜ 思维链 ｜逐行注释 ｜ +｜简单和中等难度的任务 ｜ 一步一步推理｜面向过程编程 ｜ +｜困难任务 ｜ 问题分解 ｜面向对象编程 ｜ + +- 代码注释是自然存在的链式思维数据。 +- 面向过程编程类似于逐步解决任务。这适用于简单和中等复杂度的任务。 +- 面向对象编程类似于将任务分解为较小的任务，然后分别解决它们。这适用于较高复杂度的任务。 + +从这个显著的一致性中，我们看到提高推理能力与提高编程能力非常相似。在此，我们通过强调训练大型语言模型进行推理或编码的配方相似性，深化了这个假设： + +｜------------------｜-----------------------------------------------------------------------------------｜----------------------------------------------------------------| +｜ 持续训练 ｜ 在科学文献上持续训练,数据格式 = 文本 + latex ,例子: Minerva / Galactica ｜ 在代码上持续训练,数据格式 = 文本 + 编程语言 ,例子: Codex ｜ +｜ 监督微调 ｜ 使用思维链指令做监督微调,数据格式 = 思维链,例子: CoT specialization ｜ 使用代码指令做监督微调, 数据格式 = 代码 例子: AlphaCode ｜ +｜ 强化学习 ｜ 使用思维链指令做监督微调,数据格式 = 思维链,例子: CoT specialization ｜ 使用代码指令做监督微调, 数据格式 = 代码 例子: AlphaCode ｜ +｜ 监督微调 ｜ 使用中间过程和推理结果作为反馈,格式：是否推理正确,例子: process and outcome based reward ｜ 使用编译率和通过率作为反馈,格式 = 代码是否正确执行 例子: CodeRL ｜ +｜ 采样和解码 ｜ Self-consistency：采样多个解决方案，然后进行多数投票 ｜ Sampling and filtering: ,采样多个解决方案，然后过滤并聚类这些解决方案 ｜ + +看到推理和代码都经历了： + +- 在连续训练阶段，可以在基础模型上增加代码和科学文献数据。 +- 在有监督的微调阶段，可以根据要求完成复杂任务的指令或编写代码对模型进行微调。 +- 在强化学习阶段，将中间推理步骤 / 编译率和最终推理结果 / 代码通过率作为奖励。 +- 在解码过程中，推理和编码都会采样多个解决方案，然后从解码空间中选择最佳方案。 + +#### 复杂推理的提示工程 + +* 基础思维链提示工程 + +推荐给初学者： + +- Wei et. al. 2022. [Chain-of-Thought Prompting Elicits Reasoning in Large Language Models](https://arxiv.org/abs/2201.11903). + - 本文是第一篇发现当使用链式思维进行提示时，存在一个相变现象，表明大型模型在很大程度上优于较小的模型，这进一步导致了[涌现能力](https://arxiv.org/abs/2206.07682)的发现。 +- Wang et. al. 2022. [Self-Consistency Improves Chain of Thought Reasoning in Language Models](https://arxiv.org/abs/2203.11171) + - 对采样的 CoT 推理路径进行多数投票，显著提高了推理性能。 +- Suzgun et. al. 2022. [Challenging BIG-Bench Tasks and Whether Chain-of-Thought Can Solve Them](https://arxiv.org/abs/2210.09261) + - 使用 CoT 处理 big-bench 中困难的任务。这篇论文的一个有意义的副产品是 BigBench Hard 数据集，它在测试模型推理能力方面非常有效。 + + +* 进阶技巧及分析 + +高级 CoT 提示实践： + +- Fu et. al. 2023. [Complexity-Based Prompting for Multi-Step Reasoning](https://arxiv.org/abs/2210.00720) + - 使用复杂链代替简单链作为上下文示例。 +- Khot et. al. 2023. [Decomposed Prompting: A Modular Approach for Solving Complex Tasks](https://arxiv.org/abs/2210.02406) + - 将复杂任务分解为更简单的任务，然后逐个解决。 + +通常，对于复杂任务，首先将其分解为更简单的任务，然后逐步解决更简单的任务。 + +以下论文讨论了上下文学习为什么起作用： + +- Xie et. al. 2021. [An Explanation of In-context Learning as Implicit Bayesian Inference](https://arxiv.org/abs/2111.02080) + - 语言模型在提示中的示例之间推断出一个潜在概念，并进入相应的任务模式 +- Wei et. al. 2023. [Larger language models do in-context learning differently](https://arxiv.org/abs/2303.03846) + - 当出现与先验知识相矛盾的上下文示例时，尽管大型模型可能具有更强的语义先验，大型模型可以根据提示词来覆盖语义先验。 + +简而言之，上下文学习的要点是提示中的示例使模型进入相应的任务模式，然后执行任务。 + + +以下论文讨论了**模型在进行思维链推理时的行为**： + +- Min et. al. 2022. [Rethinking the Role of Demonstrations: What Makes In-Context Learning Work](https://arxiv.org/abs/2202.12837) + - 当某些标签错误时，模型仍然可以做出正确的预测。这表明模型更受提示的 [格式] 影响，而不是提示的 [意义] 。 +- Wang et. al. 2022. [Towards Understanding Chain-of-Thought Prompting: An Empirical Study of What Matters](https://arxiv.org/abs/2212.10001) + - 即使提示中的推理错误，模型仍然可以正确推理，但提示的相关性和推理步骤的顺序更为重要 —— 这再次表明，模型更受提示的 [格式] 影响，而不是提示的[意义]。 +- Madaan and Yazdanbakhsh. 2022. [Text and Patterns: For Effective Chain of Thought, It Takes Two to Tango](https://arxiv.org/abs/2209.07686). + - 详细分析显示，提示的格式可以改善 CoT 推理（虽然内容的正确性可能不起到强烈作用） + +因此呢，模型只关注提示的格式，但可能不会受到提示正确性的显著影响。然而，模型在多大程度上会受到提示正确性的影响，或者提示可以在[多大程度上覆盖模型的先验信念](https://arxiv.org/abs/2303.03846)，还是一个尚待研究的问题。 + +以下论文讨论了如何**通过改进和反馈来提高模型性能**： + +- Madaan. et. al. 2023. [Self-refine: Iterative refinement with self-feedback](https://arxiv.org/abs/2303.17651) + - 模型可以在多个场景中（包括代码优化、数学推理、对话响应生成等）对自身的推理进行优化和改进。 +- Madaan et. al. 2023. [Learning Performance-Improving Code Edits](https://arxiv.org/abs/2302.07867) + - 在程序轨迹上进行训练可以改善编码。 + +因此，以自然语言形式（而非强化学习中的奖励形式）对模型进行改进和反馈非常有效，可以进一步提高语言模型的性能（无论是通过上下文学习还是微调）。 + +#### 评价大语言模型的推理能力 + +#### 评价方法的基础知识 + +在谈论评估时，有三个重要因素需要考虑：数据格式、能力类型和模型类型。 + +首先，提示时有四种数据格式： + +

+ +

+ +其中： + +- In-context 指的是在测试问题之前附加一系列上下文示例。 +- Zero-shot 是指在没有上下文示例的情况下直接将测试问题输入给模型。 +- Chain-of-thought 是指在回答之前生成推理。 +- Answer-only 是指没有链式思维，直接给答案。 + +对于模型能力，有两种大致正交的能力类型： + +- 知识 knowledge：模型是否了解世界 +- 推理 reasoning：模型是否可以根据其知识进行推理。 + +这两个方面并不是严格正交的，因为一些推理规则也可以被视为某种形式的知识。然而，在评估时，这两种能力有明显的差异： + +- 一些数据集更注重对知识的评估，如 [MMLU](https://arxiv.org/abs/2009.03300)，它测试模型是否具有高达大学水平的知识。 +- 一些数据集更注重对推理的评估，如 [BBH](https://arxiv.org/abs/2210.09261)，它测试模型是否具有逐步解决问题的能力。 +- 对于知识，链式思维与仅回答的表现相似（参见 FlanPaLM 论文）。 +- 对于推理，链式思维比仅回答表现得更好（参见原始 [CoT 论文](https://arxiv.org/abs/2201.11903)，然后参见 [FlanPaLM论文](https://arxiv.org/abs/2210.11416) + +在实践中，因为 CoT 在达到或优于 Answer-only 的表现，而且 CoT 更加用户友好（因为它告诉用户思考过程），现代聊天机器人总是部署 CoT（无论你问 ChatGPT 什么，它都会告诉你一堆它的想法）。 + +最后，在评估方面，我们区分了两种类型的模型：预训练之后的 checkpoint 和指令微调之后的 checkpoint。 + +1. 预训练 checkpoint 具有 in-context learning 的能力。大多数预训练模型可以进行 in-context answer-only，一些更好的模型可以进行 in-context chain-of-thought（但目前尚不清楚为什么某些预训练模型可以进行 CoT 而其他模型却不能）。然而，预训练 checkpoint 可能无法进行 zero-shot，因为它们没有经过这方面的训练（但某些预训练检查点仍然可以进行 zero-shot CoT，请参阅 “[让我们逐步思考(https://arxiv.org/abs/2205.11916)” 的论文）。 +2. 指令微调过后的 checkpoint 既具有 zero-shot 又有 in-context 的能力。这里需要注意的是，如果没调好，指令微调之后 in-context 性能可能会[稍有下降](https://arxiv.org/abs/2203.02155)。 + +最后，在评估方面，这里区分了两种类型的模型：预训练之后的 checkpoint 和指令微调之后的 checkpoint。 + +- 预训练 checkpoint 具有 in-context learning 的能力。大多数预训练模型可以进行 in-context answer-only，一些更好的模型可以进行 in-context chain-of-thought（但目前尚不清楚为什么某些预训练模型可以进行 CoT 而其他模型却不能）。然而，预训练 checkpoint 可能无法进行 zero-shot，因为它们没有经过这方面的训练（但某些预训练检查点仍然可以进行 zero-shot CoT，请参阅 “让我们逐步思考” 的论文）。 +- 指令微调过后的 checkpoint 既具有 zero-shot 又有 in-context 的能力。这里需要注意的是，如果没调好，指令微调之后 in-context 性能可能会稍有下降。 + +综上所述，我们建议使用 in-context 和 chain-of-thought 进行评估： + +- In-context 是评估 pretrained checkpoint 的更好方法，因为它更好地揭示了模型潜力。Zero-shot 可能低估模型性能，尤其是对于不支持 Zero-shot chain-of-thought 的（“让我们逐步思考”）的模型。 +- Chain-of-thought prompting 是评估推理能力的更好方法，因为它比 answer-only prompting 更充分地发挥了模型的推理性能。 + +#### Chain-of-thought Hub 简介 + +在讨论了所有评估基础知识之后，这里在介绍 Chain-of-thought Hub，这是一个正在进行的工作，希望成为评估语言模型推理能力的统一平台。他们汇编了一个包括数学（GSM8K）、科学（MATH）、符号（BBH）、知识（MMLU）等复杂推理任务的列表，以衡量哪些模型确实更好。 + +下面是当前的排行榜。尽管许多数字还没跑出来，但当前的内容仍然能给一个大概的模型排名： + +

+ +

+ + +总的来说： + +- 根据 GSM8K 对模型性能进行排名，这是一个经典的基准测试，用于衡量链式思维数学推理性能。这不是唯一的度量标准，但一个很好的解释是 “在保持其他通用能力的同时，模型在数学方面的表现如何” —— 这也非常困难。 +- GPT-4 在 GSM8K 和 MMLU 上明显优于所有其他模型。 +- 65B LLaMA 与 text/code-davinci-002 非常接近，这意味着基于它，如果 SFT 和 RLHF 操作正确，我们很有可能基于 65B LLaMA 复现 ChatGPT。 +- Claude 是唯一可以与 GPT 系列相媲美的模型家族。 +- 较小的模型，如 FlanT5 11B 和 LLaMA 7B，明显落后于排行榜，这意味着复杂推理可能只是大型模型的能力。 + +在 github 中，进一步地分析和了解： + +- 详细的实验设置和结果分析。 +- 用于重现 GPT 和 Claude 所有结果的脚本。 + +因此，在上面我们讨论了大型语言模型的推理能力。复杂推理不仅仅是因为它是更强模型与更弱模型之间的核心区分点，而且它还是模型成为下一代计算平台或者操作系统的基础能力，从而有可能在大模型上建立一个新的生态系统。 + +我们讨论了构建具有强大推理能力的模型的方法：预训练、有监督的微调和强化学习。我们发现提高推理能力的方法与提高代码能力的方法密切相关，这加深了我们先前关于推理与代码之间密切关系的假设。我们进一步讨论了高级提示工程技巧和在执行复杂推理时模型行为的分析。 + +最后，我们讨论了如何评估模型的推理能力，并介绍了 chain-of-thought hub，这是一个正在进行的项目，旨在统一评估语言模型的推理性能。 + +希望这篇文章能成为构建具有强大推理能力的开源模型的路线图。 + + +人世间数百万个闲暇的小时流逝过去，方始出现一个真正的历史性时刻，人类星光闪耀的时刻 —— 《人类群星闪耀时》斯蒂芬·茨威格 + + +#### 更多大语言模型推理的相关资源 + +* [Prompt Engineering](https://lilianweng.github.io/posts/2023-03-15-prompt-engineering/) +* [Microsoft Semantic Kernel ](https://github.com/microsoft/semantic-kernel) +* [Prompt Engineering Guide](https://github.com/dair-ai/Prompt-Engineering-Guide) +* [Towards Reasoning in Large Language Models: A Survey](https://arxiv.org/abs/2212.10403) \ No newline at end of file diff --git a/assets/src/LLM/llm02.md b/assets/src/LLM/llm02.md new file mode 100644 index 00000000..ea675909 --- /dev/null +++ b/assets/src/LLM/llm02.md @@ -0,0 +1,55 @@ +#### 什么是大型语言模型？ + +大型语言模型（LLM）是基于大量数据进行预训练的超大型深度学习模型。底层转换器是一组神经网络，这些神经网络由具有自注意力功能的编码器和解码器组成。编码器和解码器从一系列文本中提取含义，并理解其中的单词和短语之间的关系。 + +转换器 LLM 能够进行无监督的训练，但更精确的解释是转换器可以执行自主学习。通过此过程，转换器可学会理解基本的语法、语言和知识。 + +与早期按顺序处理输入的循环神经网络（RNN）不同，转换器并行处理整个序列。这可让数据科学家使用 GPU 训练基于转换器的 LLM，从而大幅度缩短训练时间。 + +借助转换器神经网络架构，您可使用非常大规模的模型，其中通常具有数千亿个参数。这种大规模模型可以摄取通常来自互联网的大量数据，但也可以从包含 500 多亿个网页的 Common Crawl 和拥有约 5700 万个页面的 Wikipedia 等来源摄取数据。 + +#### 大语言模型综述 + +语言是人类表达和交流的突出能力，它在儿童早期发展 并在一生中不断演变。然而，机器不能自然地掌握以人类语言形式理解和交流的能力，除非配备了强大的人工智能算法。实现这一目标，让机器像人类一样阅读、写作和交流一直是一个长期的研究挑战。 + +从技术上讲，语言建模是提高机器语言智能的主要方法之一。一般来说，语言建模旨在对词序列的生成概率进行建模，以预测未来(或缺失)单词的概率。语言建模的研究在文献中受到了广泛关注，可以分为四个主要发展阶段: + +1. 统计语言模型 (SLM) + +SLMs 基于统计学习方法 开发，并在 20 世纪 90 年代兴起。其基本思想是基于马尔可夫 假设建立词预测模型，例如根据最近的上下文预测下一个词。 +具有固定上下文长度 n 的 SLM 也称为 n-gram 语言模型，例 如 bigram 和 trigram 语言模型。SLM 已被广泛应用于提高信 息检索和自然语言处理的任务性能。然而，它们通常受到维数灾难的困扰：由于需要估计指数级数量的转 换概率，因此很难准确估计高阶语言模型。因此，专门设计的平滑策略，如回退估计和 Good–Turing 估计已被引入以缓解数据稀疏问题。 + +2. 神经语言模型(NLM) + +使用神经网络（例 如循环神经网络）来刻画词序列的概率。作为一个显著贡献，的工作引入了词的分布式表示概念，并在聚合上下文特征（即分布式词向量）的条件下构建词预测函数。通过扩展学习词或句子有效特征的想法，已有研究开发了一种通用神经 + +此外，word2vec被提出来构建一个简化的浅层神经网用于学习分布式词表示，这些表示在各种自然语言处理任务中被证明非常有效。这些研究开创了将语言模型用于表示学习（超越词序列建模），对自然语言处理领域产生了重要影响。 + +3. 预训练语言模型 (PLM) + +作为早期尝试，ELMo被提出来通过预训练一个双向 LSTM（biLSTM）网络（而不是 学习固定的词表示）来捕捉上下文感知的词表示，然后根据特定的下游任务微调 biLSTM 网络。进一步，基于自注意力机制的高度并行化 Transformer 架构，BERT作为双向语言模型，在大规模无标签语料库上使用专门设计的预训练任务。 + +这些预训练的上下文感知词表示作为通用语义特征非常有效，极大地提高了自然语言处理任务的性能。这项研究激发了大量后续工作，确立了“预训练和微调”学习范式。 +遵循这一范式，已经建立了大量关于预训练语言模型的研究引入了不同的架构（例如 GPT-2和 BART），或者改进的预训练策略。在这个范式中，通常需要对预训练语言模型进行微调以适应不同的下游任务。 + + +4. 大语言模型 (LLM) + +研究人员发现，扩展预训练语言模型（例如扩展模型大小或数据大小）通常会提高下游任务的模型容量（即遵循扩展定律）。许多研究通过训练越来越大的 PLM（例如 175B 参数的 GPT-3 和 540B 参数的 PaLM）来探索性能极限。尽管扩展主要在模型大小方面进行（具有类似的架构和预训练任务），但这些大尺寸的预训练语言模型表现出与较小的预训练语言模型（如 330M 参数的 BERT和 1.5B 参数的 GPT-2）不同的行为， +并在解决一系列复杂任务中展示了惊人的能力（称为涌现能力）。例如，GPT-3 可以通过上下文学习解决少样本任务，而 GPT-2 则表现不佳。因此，研究界为这些大型预训练语言模型命名为“大语言模型 (LLM)”1。LLM 的一个显著应用是 ChatGPT2，它将 GPT 系列的 LLM 应用于对话，展现了惊人的与人类对话的能力。 + +在现有文献中，PLM 已经得到了广泛的讨论和调研，而很少有研究对 LLM 以系统的方式进行回顾。为了激发我们的调研，我们首先强调 LLM 和 PLM 之间的三个主要区别。首先，LLM 表现出一些令人惊讶的涌现能力，这些能力可能在以前较小的 PLM 中没有观察到。这些能力是语言模型 可能在以前较小的 PLM 中没有观察到。这些能力是语言模型 的强大和有效性。其次，LLM 将彻底改变人类开发和使用人 工智能算法的方式。与小型 PLM 不同，访问 LLM 的主要方法是通过提示接口(例如 GPT-4 API)。 +人们必须了解 LLM的工作原理，并以 LLM 能够遵循的方式形式化他们的任务。第三，LLM 的发展不再明确区分研究和工程。训练 LLM 需要在大规模数据处理和分布式并行训练方面具有丰富的实践经验。为了开发出有能力的 LLM，研究人员必须解决复杂的工程问题，与工程师合作或成为工程师。 + + +如今，LLM 对 AI 社区产生了重大影响，ChatGPT 和GPT-4 的出现促使人们重新思考通用人工智能(AGI)的可能性。OpenAI 已经发布了一篇名为“Planning for AGI and beyond”的技术文章，讨论了实现 AGI 的短期和长期计划而一篇更近期的论文认为 GPT-4 可能被视为 AGI 系统的早期版本。AI 研究领域正因 LLM 的迅速发展而发生革命性变革。在自然语言处理领域，LLM 可以在一定程度上作为通用语言任务解决器，其研究范式已经转向使用 LLM。 +在信 息检索领域，传统搜索引擎正受到通过 AI 聊天机器人(即ChatGPT)搜索新信息的挑战，而 New Bing3展示了一个初步的基于 LLM 增强搜索结果的研究尝试。在计算机视觉领域，研究人员试图开发类似 ChatGPT 的视觉-语言模型，以更好地为多模态对话提供服务GPT-4已经通过整合视觉信息支持多模态输入。这一新技术浪潮可能会带来 例如GPT-3、PaLM、Galactica和LLaMA。 + + +具体而言，LLM 基于 Transformer 架构构建，其中多头注意力层堆叠在非常深的神经网络中。现有的 LLM 主要采用与小语言模型类似的模型架构（即 Transformer)和预训练目标(即语言建模)。作为主要区别，LLM 大幅扩展了模型大小、预训练数据和总计算量(若干数量级)，可以更好地根据上下文(即提示)理解自然语言并生成高质量的文本。这一能力提升可以部分通过扩展定律来描述，即任务性能大致随着模型大小的增加而显著提高然而，一些能力(例如上下文学习)是不可预测的，只有当模型大小超过一定水平时才能观察到。 + +大语言模型的涌现能力: 在文献中，LLM 的“涌现能力”被正式定义为“在小模型中不存在但在大模型中出现的能力”，这是区分 LLM 与以前的 PLM 最突出的特征之一。它进一步介绍了一个显著的特征，即当规模达到一定水平时，性能显著提高超过随机水平。类比地，这种涌现模式与物理学中的相变”现象有着密切的联系。原则上，涌现能力可以定义为与某些复杂任务相关的能力，而我们更关注能够应用于解决各种任务的通用能力。这里，我们简要介绍三个代表性的 LLM 涌现能力。 + +* 上下文学习:上下文学习能力由 GPT-3 正式引入,假设提供给语言模型自然语言指令和/或多个任务演示，它可以通过完成输入文本的单词序列来为测试实例生成期望的输出，而无需额外的训练或梯度更新。 +* 指令遵循:通过使用自然语言描述的多任务数据集进行微调(称为指令微调)，LLM 可以在同样使用指令形式化描述的未见任务上表现良好。通过指令微调，LLM 能够在没有使用显式示例的情况下遵循任务指令,从而具有更好的泛化能力。 +* 逐步推理:对于小语言模型来说，通常难以解决涉及多个推理步骤的复杂任务，例如数学问题。然而，通过采用“思维链”推理策略，LLM 可以利用包含中间推理步骤的提示机制来解决这些任务，得出最终答案。这种能力被认为可能通过在代码上进行训练来获得。 \ No newline at end of file diff --git a/assets/src/OTR/OTR.md b/assets/src/OTR/OTR.md index 35606c69..47213017 100644 --- a/assets/src/OTR/OTR.md +++ b/assets/src/OTR/OTR.md @@ -1,4 +1,5 @@ ### Deeplearning Algorithms tutorial + 谷歌的人工智能位于全球前列，在图像识别、语音识别、无人驾驶等技术上都已经落地。而百度实质意义上扛起了国内的人工智能的大旗，覆盖无人驾驶、智能助手、图像识别等许多层面。苹果业已开始全面拥抱机器学习，新产品进军家庭智能音箱并打造工作站级别Mac。另外，腾讯的深度学习平台Mariana已支持了微信语音识别的语音输入法、语音开放平台、长按语音消息转文本等产品，在微信图像识别中开始应用。全球前十大科技公司全部发力人工智能理论研究和应用的实现，虽然入门艰难，但是一旦入门，高手也就在你的不远处！ AI的开发离不开算法那我们就接下来开始学习算法吧！ @@ -10,7 +11,7 @@ AI的开发离不开算法那我们就接下来开始学习算法吧！ 机器学习主要有三种方式：监督学习，无监督学习与半监督学习。 -（1）监督学习：从给定的训练数据集中学习出一个函数，当新的数据输入时，可以根据函数预测相应的结果。监督学习的训练集要求是包括输入和输出，也就是特征和目标。训练集中的目标是有标注的。如今机器学习已固有的监督学习算法有可以进行分类的，例如贝叶斯分类，SVM，ID3，C4.5以及分类决策树，以及现在最火热的人工神经网络，例如BP神经网络，RBF神经网络，Hopfield神经网络、深度信念网络和卷积神经网络等。人工神经网络是模拟人大脑的思考方式来进行分析，在人工神经网络中有显层，隐层以及输出层，而每一层都会有神经元，神经元的状态或开启或关闭，这取决于大数据。同样监督机器学习算法也可以作回归，最常用便是逻辑回归。 +（1）监督学习：从给定的训练数据集中学习出一个函数，当新的数据输入时，可以根据函数预测相应的结果。监督学习的训练集要求是包括输入和输出，也就是特征和目标。训练集中的目标是有标注的。如今机器学习已固有的监督学习算法有可以进行分类的，例如贝叶斯分类，`SVM`，ID3，`C4.5` 以及分类决策树，以及现在最火热的人工神经网络，例如BP神经网络，RBF神经网络，Hopfield神经网络、深度信念网络和卷积神经网络等。人工神经网络是模拟人大脑的思考方式来进行分析，在人工神经网络中有显层，隐层以及输出层，而每一层都会有神经元，神经元的状态或开启或关闭，这取决于大数据。同样监督机器学习算法也可以作回归，最常用便是逻辑回归。 （2）无监督学习：与有监督学习相比，无监督学习的训练集的类标号是未知的，并且要学习的类的个数或集合可能事先不知道。常见的无监督学习算法包括聚类和关联，例如K均值法、Apriori算法。 @@ -27,6 +28,7 @@ AI的开发离不开算法那我们就接下来开始学习算法吧！ Hawkins(1980)给出孤立点（outlier）的定义：孤立点是在数据集中与众不同的数据，使人怀疑这些数据并非随机孤立点，而是产生于完全不同的机制。孤立点可能在聚集运行或者检测的时候被发现，比如一个人的年龄是999，这在对数据库进行检测的时候就会被发现。还有就是outlier可能是本身就固有的，而不是一个错误，比如CEO的工资就比一般员工的工资高出很多。 2.算法原理 +

@@ -34,20 +36,24 @@ Hawkins(1980)给出孤立点（outlier）的定义：孤立点是在数据集中 孤立点的挖掘方法主要有：基于统计学的、基于距离的、基于密度的局部离群点方法和基于深度偏差的方法。 马克威孤立点算法是基于距离的：设表示p点和它的第k个最近邻居的距离。直观地看，越大，p越有可能成为孤立点。 + 给定d维空间中包含N个点的数据集、参数N（孤立点个数）和k（偏差距离）,如果满足的点不超过n-1个,那么称p为孤立点。 + 如果对所有数据点根据其距离进行从大到小排序，那么前n个点就被看作是孤立点。 算法步骤如下，对每个p点，计算它的第k个最近邻居的距离，把具有极大值的前个n点作为孤立点。该算法每次处理一个点p，就需要扫描一遍数据库，总共需要扫描N遍（N为数据点数）。 #### 算法应用 + 孤立点分析被广泛地应用于各种行业，如电信和信用卡欺骗（如检查购买金额或购买次数异常等）、贷款审批、药物研究（如用于发现对多种治疗方式的不寻常的反应）、气象预报、金融领域（如检查洗钱等异常行为）、客户分类（如确定极低或极高收入的客户的消费行为）、网络入侵检测等。 #### 相关应用 + 聚类分析、异常监测、异常欺诈、行为异常 #### 优点和缺点 + 优点：应用领域广泛，对异常检测、极端情况的事件发生尤其有用。 缺点：孤立点分析时，有时候得到的结果并不是我们想要的，是数据本身固有的一种属性，如总经理的工资待遇比员工高很多；在时间序列中寻找孤立点时，难度比较大，因为时间序列的数据可能隐藏在趋势、季节性或者其他循环规则变化中。对非整型的数值型数据，孤立点定义及分析需要特殊考虑。 - diff --git a/assets/src/RAM/RAM.0.3.md b/assets/src/RAM/RAM.0.3.md index 84c24d55..649fc75c 100644 --- a/assets/src/RAM/RAM.0.3.md +++ b/assets/src/RAM/RAM.0.3.md @@ -3,7 +3,6 @@ AI的开发离不开算法那我们就接下来开始学习算法吧！ 回归方法是对数值型连续随机变量进行预测和建模的监督学习算法。其特点是标注的数据集具有数值型的目标变量。回归的目的是预测数值型的目标值。 - 常用的回归方法包括: * 线性回归：使用超平面拟合数据集 * 最近邻算法：通过搜寻最相似的训练样本来预测新样本的值 @@ -28,7 +27,7 @@ AI的开发离不开算法那我们就接下来开始学习算法吧！ 如果将$y$看作是样本$x$作为正例的可能性，那么可以得到反应$x$作为正例的相对可能性对数几率（logit）

- +

#### 逻辑回归算法 diff --git a/assets/src/RST/RST.md b/assets/src/RST/RST.md index 426b31da..69c8d75b 100644 --- a/assets/src/RST/RST.md +++ b/assets/src/RST/RST.md @@ -1,4 +1,5 @@ ### Deeplearning Algorithms tutorial + 谷歌的人工智能位于全球前列，在图像识别、语音识别、无人驾驶等技术上都已经落地。而百度实质意义上扛起了国内的人工智能的大旗，覆盖无人驾驶、智能助手、图像识别等许多层面。苹果业已开始全面拥抱机器学习，新产品进军家庭智能音箱并打造工作站级别Mac。另外，腾讯的深度学习平台Mariana已支持了微信语音识别的语音输入法、语音开放平台、长按语音消息转文本等产品，在微信图像识别中开始应用。全球前十大科技公司全部发力人工智能理论研究和应用的实现，虽然入门艰难，但是一旦入门，高手也就在你的不远处！ AI的开发离不开算法那我们就接下来开始学习算法吧！ @@ -39,9 +40,9 @@ D在C上的依赖度定义为：