机器学习---1

存在大量引用
线性回归感性认识

from numpy import *   
from sklearn.datasets import load_iris     # import datasets  
    # load the dataset: iris  
iris = load_iris()   
samples = iris.data  
    #print samples   
target = iris.target   
    # import the LogisticRegression  
from sklearn.linear_model import LogisticRegression   
classifier = LogisticRegression()  # 使用类，参数全是默认的  
classifier.fit(samples, target)  # 训练数据来学习，不需要返回值  
x = classifier.predict(array([11, 11, 11, 1.5]).reshape(1,-1))   # 测试数据，分类返回标记  
print(+x)

一 机器如何学习

机器学习就是通过自身运行，习得（学习）事物的规律和事物间的关联
让一段程序了解客观世界变化万千的事物，则必须将这些事物数值化，将事物的变化和不同事物之间的关联转化为运算

说到数值，大家可能本能地想到 int、double、 float……但实际上，如果将一个语言要素对应成一个标量的话，太容易出现两个原本相差甚远的概念经过简单运算相等的情况。
假设“苹果“被转化为2，而“香蕉”被转化为4，难道说两个苹果等于一个香蕉吗？
因此，一般在处理时会将自然语言转化成 n 维向量。只要转化方式合理，规避向量之间因为简单运算而引起歧义的情况还是比较容易的。

概念 <-> 数值、关系 <-> 运算的映射，造就了机器可以自主学习获得事物规律的可能

二 机器学习三要素：数据、模型、算法

算法通过在数据上进行运算产生模型

特征工程：
1.确定用哪些特征来表示数据；
2.确定用什么方式表达这些特征。

模型是机器学习的结果，这个学习过程，称为训练（Train）一个已经训练好的模型，可以被理解成一个函数： y=f(x)。
输出结果可能是一个数值（回归），也可能是一个标签（分类）
模型是基于数据，经由训练得到的。
训练就是：根据已经被指定的 f(x) 的具体形式——模型类型，结合训练数据，计算出其中各个参数的具体取值的过程。
训练过程需要依据某种章法进行运算。这个章法，就是算法
有监督学习的目标就是：让训练数据的所有 x 经过 f(x) 计算后，获得的 y’ 与它们原本对应的 y 的差别尽量小。
我们需要用一个函数来描述 y’ 与 y 之间的差别，这个函数叫做损失函数（Loss Function）L（y, y’）= L(y, f(x))。
Loss 函数针对一个训练数据，对于所有的训练数据，我们用代价函数（Cost Function）来描述整体的损失。

代价函数一般写作：J（theta）——注意，代价函数的自变量不再是 y 和 f(x)，而是变成了 theta，theta 表示 f(x) 中所有待定的参数（theta 也可以是一个向量，每个维度表示一个具体的参数）

因此，我们也就有了学习的目标（也称为目标函数）：argmin J（theta）—— 最小化J（theta）

怎么能够找到让 J（theta） 最小的 theta 呢？这就需要用到优化算法了。
具体的优化算法有很多，比如：梯度下降法（Gradient Descent）、共轭梯度法（Conjugate Gradient）、牛顿法和拟牛顿法、模拟退火法（Simulated Annealing） 等等。

最常用的是梯度下降法

算法工程师的职责包括：研发新算法；针对现实问题构造目标函数，选取并优化算法求解；将他人研究的最新算法应用到自己的业务问题上

要得到高质量的模型，算法很重要，但往往（尤其是在应用经典模型时）更重要的是数据。

三 模型的获取和改进

为了构建一个模型，我们需要经历以下步骤。

Step-1：数据准备。

Step-1.1 数据预处理：收集数据、清洗数据、标注数据。
Step-1.2 构建数据的向量空间模型（将文本、图片、音频、视频等格式的数据转换为向量）。
Step-1.3 将构建好向量空间模型的数据分为训练集、验证集和测试集。
Step-2：训练——将训练集输入给训练程序，进行运算。训练程序的核心是算法，所有输入的向量化数据都会按该训练程序所依据的算法进行运算。训练程序输出的结果，就是模型。

Step-3：测试——将测试集数据输入给训练获得的模型，得到预测结果；再将预测结果与这些数据原本预期的结果进行比较。

将全部数据分割成训练集、验证集和测试集。这些集合都是做什么的呢？

训练集（Train Set）：用来做训练的数据的集合。

验证集（Validation Set）：在训练的过程中，每个训练轮次结束后用来验证当前模型性能，为进一步优化模型提供参考的数据的集合。

测试集（Test Set）：用来测试的数据的集合，用于检验最终得出的模型的性能。

Step-2 训练，又可以细化为几个步骤。

Step-2.1： 编写训练程序。

 Step-2.1.1： 选择模型类型；
 Step-2.1.2： 选择优化算法；
 Step-2.1.3： 根据模型类型和算法编写程序。

Step-2.2： 训练 -> 获得临时模型。

Step-2.3： 在训练集上运行临时模型，获得训练集预测结果。

Step-2.4： 在验证集上运行临时模型，获得验证集预测结果。

Step-2.5： 综合参照 Step-2.3 和 Step-2.4 的预测结果，改进模型。

Step-2.6： Step-2.2 到 Step-2.5 反复迭代，直至获得让我们满意，或者已经无法继续优化的模型。

如何优化模型
对照机器学习三要素，模型的优化可以从三个方面来进行：数据、调参和模型类型。

数据：

有限的数据上，我们能做些什么来尽量提高其质量呢？大概有如下手段：
1.对数据进行归一化（Normalization，又译作正规化、标准化）等操作。
2.采用 Bootstrap 等采样方法处理有限的训练/测试数据，以达到更好的运算效果。
3.根据业务进行特征选取：从业务角度区分输入数据包含的特征，并理解这些特征对结果的贡献。

调参：

调整超参数，例如用梯度下降方法学习 LR 模型时的步长（Alpha），用 BFGS 方法学习 Linear-chain CRF 时的权重（w）等。

调参本身有点像一个完整的 Project，需要经历:

制定目标
制定策略
执行
验证
调整策略 -> 3
这样一个完整的过程，其中 3-5 往往要经由多次迭代

调参有许多现成的方法可循（比如 Grid Search），应用这些方法，使得制定和调整“调参策略”有章可循，也可以减少许多工作量。

调参这一步很多时候没有一定之规。特别是在超参数比较多的时候，如何组合调参简直可以称为一门艺术。

只有当调参工程师对于模型的理论原理和算法的执行细节有深入了解的时候，才有可能找到正确的调参方向。
模型类型选择

换模型

有的时候，训练数据已经确定，而某个模型再怎么调参，都无法满足在某个特定指标上的要求。那就只好换个模型试试了。

比如，对于某个分类问题，Logistic Regression 不行，可以换 Decision Tree 或者 SVM 试试。

对于深度模型（CNN、DNN、RNN、LSTM 等等），训练时间普遍较长，可解释性极弱，一旦出现问题，很难 Debug。因此再次建议大家：在应用场景下，不要迷信 Cutting-edge Technology，无论工具还是方法，选合适的

四 模型的评价指标和质量

分类模型评判指标： Precision、Recall 和 F1Score
对于分类而言，最简单也是最常见的验证指标：精准率（Precision）和召回率（Recall），为了综合这两个指标并得出量化结果，又发明了 F1Score。

当一个测试集全部被预测完之后，相对于 Class_A，会有一些实际是 Class_A 的数据被预测为其他类，也会有一些其实不是 Class_A 的，被预测成 Class_A，这样的话就导致了下面这个结果：

精准率：Precision=TP/（TP+FP），即在所有被预测为 Class_A 的测试数据中，预测正确的比率。

召回率：Recall=TP/（TP+FN），即在所有实际为 Class_A 的测试数据中，预测正确的比率。

F1Score = 2*(Precision * Recall)/(Precision + Recall)

显然上面三个值都是越大越好，但往往在实际当中 P 和 R 是矛盾的，很难保证双高。

此处需要注意，P、R、F1Score 在分类问题中都是对某一个类而言的

假设这个模型总共可以分10个类，那么对于每一个类都有一套独立的 P、R、F1Score 的值。衡量模型整体质量，要综合看所有10套指标，而不是只看一套。

这套指标还和测试数据有关。同样的模型，换一套测试数据后，很可能 P、R、F1Score 会有变化，如果这种变化超过了一定幅度，就要考虑是否存在 bias 或者 overfitting 的情况

欠拟合还是过拟合

一个机器学习模型的质量问题，从对训练集样本拟合程度的角度，可以分为两类：欠拟合（Underfitting）和过拟合 （Overfitting）。

如何严格定义欠拟合还是过拟合，还要涉及几个概念：bias、error 和 variance

以下是感性认识：

如果一个模型，在训练集上的预测结果就不佳，指标偏低，那一般是欠拟合的问题。

如果在训练集上指标很好，而在验证/测试集上指标偏低，则很可能是过拟合问题。

甚至有时候，在训练集和验证/测试集上效果都不错，一到真实环境却预测误差较大，这种情况也是过拟合。

对于两种不同的问题，解决方法各不相同。

欠拟合多数情况下是因为选定模型类型太过简单，特征选取不够导致的。而过拟合则相反，可能是模型太过复杂，特征选择不当（过多或组合不当）造成的。

相应的解法，当然是有针对性地选择更复杂/简单的模型类型；增加/减少特征；或者减小/增大正则项比重等。

但有一点，无论哪种问题，增大训练数据量都可能会有所帮助。

五 最常用的优化算法—梯度下降法

从抽象角度，先好好解释一下优化算法
每一个机器学习模型都有一个目标函数，而学习的目标，就是最小化目标函数
直观而言，当我们已经获得了一个函数，最小化该函数其实就是，在其自变量取值范围内，找到使得因变量最小的那个自变量取值点。
注意的训练模型涉及两个函数，一个是模型函数、一个是目标函数，这里说的是目标函数
是不是所有目标函数都能够在自变量参数取值范围内找到因变量参数的最小值呢？显然不是。

比如，这个多项式函数：y=x，x 属于实数——这样的函数就没有最小值。
因为，x 的取值范围是整个实数域，x 越小 y 也就越小，x 取值可以无限小下去，一直 到负无穷，y 同样可以到负无穷。可惜负无穷并不是一个数值，y 实际上是没有最小值的。

一般使用梯度下降法进行优化的模型的目标函数，或者其他一些经典的机器学习模型的目标函数都是凸函数，函数的凸性保证了其最小值。

什么是凸函数：
定义：某个向量空间的凸子集（区间）上的实值函数，如果在其定义域上的任意两点 ，有 f(tx + (1-t)y) <= tf(x) + (1-t)f(y)，则称其为该区间上的凸函数。（凸是使用的外文定义，在国内一般为凹）

已经知道了学习的目标就是最小化目标函数的取值，而目标函数又是凸函数，那么学习的目标自然转化成了寻找某个凸函数的最小值
因为本课都是讲解经典机器学习模型，所以，前人的工作已经保证我们用到的目标函数都是凸函数。如果未来在应用中构建自己的目标函数，那么千万记得在直接应用任何优化算法之前，应该先确定它是凸函数。

1.随机取一个自变量的值X0
2.对应求出因变量值：f(x0)
3.计算f(x0)出目标函数发f(x)的导数
4.从f(x0)开始，沿着该处目标函数导数的反方向，按一定步长α向前走一步，走到的位置对应于自变量的取值为x1
5.继续重复2-3-4，达到指定迭代次数或近似收敛到最优解，退出迭代。

上面讲了梯度下降法，其中的 α，又叫做步长，它决定了为了找到最小值点而尝试在目标函数上前进的步伐到底走多大。
步长是算法自己学习不出来的，它必须由外界指定。
这种算法不能学习，需要人为设定的参数，就叫做超参数。

不过大步伐也不是没有优点。步伐越大，每一次前进得越多。步伐太小，虽然不容易“跨过”极值点，但需要的迭代次数也多，相应需要的运算时间也就越多。

为了平衡大小步伐的优缺点，也可以在一开始的时候先大步走，当所到达点斜率逐渐下降——函数梯度下降的趋势越来越缓和——以后，逐步调整，缩小步伐

梯度下降的难点

那是不是只要步伐合适，就一定能找到最小值点呢？也不一定。

如果目标函数有多个极小值点（多个向下的“弯儿”），那么如果开始位置不妥，很可能导致最终是走到了一个局部极小值就无法前进了。比如下图的 Postion1 和 Position2。

这种情况确实很难克服，是梯度下降算法的一大挑战。

如果目标函数不能确定只有一个极小值，而获得的模型结果又不令人满意时，就该考虑是否是在学习的过程中，优化算法进入了局部而非全局最小值。

这种情况下，可以尝试几个不同的起始点。甚至尝试一下大步长，说不定反而能够跨出局部最小值点所在的凸域。

六 线性回归

数据


机器学习三要素：数据、算法与模型
根据数据 ，选择算法，生成模型
所以在进行机器学习建模过程中，首先最重要的就是对数据进行分析，进而选择什么模型。
从上表的数据，我们显然可以发现x,y成某种一元线性关系（即成一条直线的关系）

既然我们认为 x 和 y 满足线性相关关系，那么线性函数： y = a + bx，就是我们的模型函数。其中 y 也可以用 f(x) 来表示。
我们要做的是综合利用所有的训练数据（工作年限从0-5的部分）求出 y = a + bx 中常数 a 和 b 的值。

综合利用的原则是什么呢？就是我们要求的这个 a 和 b，在将训练样本的 x 逐个带入后，得出的预测年薪 y’ = a + bx 与真实年薪 y 整体的差异最小。

怎么衡量这个整体差距呢？

Cost Function，形式如下（其中 m 为样本的个数，在本例中 m 取值为6）：

在 y = a + bx 这个模型函数中，a 和 b 是常量参数，x 是自变量，而 y 是因变量。
但到了 J(a,b) 中，x(i) 和y(i) 是常量参数（也就是 m 个样本各自的 x 和 y 值），而 a 和 b 成了自变量，J(a,b) 是因变量。能够让因变量 J(a, b) 取值最小的自变量 a 和 b，就是最好的 a 和 b。

我们要做的，就是找到最好的 a 和 b。
讲求解 a，b 之前，我们先要特别强调一个概念——线性。
线性=直线？

线性概念的混淆

为什么要说线性呢？

因为，很多人简单认为“线性回归模型假设输入数据和预测结果遵循一条直线的关系”。

这种理解是一叶障目，是愚蠢的，是低级的。

线性回归模型是：利用线性函数对一个或多个自变量 （x 或 (x1,x2,…xk)）和因变量（y）之间的关系进行拟合的模型。
线性回归模型构建成功后，这个模型表现为线性函数的形式。
线性函数的定义是：一阶（或更低阶）多项式，或零多项式。

总结一下：特征是一维的，线性模型在二维空间构成一条直线；特征是二维的，线性模型在三维空间中构成一个平面；若特征是三维的，则最终模型在四维空间中构成一个体，以此类推。

但是他们可以映射回一维空间即平面，其表现为一条曲线

用线性回归模型拟合非线性关系

在输入特征只有一个的情况下，是不是只能在二维空间拟合直线呢？其实也不一定。

比如，有一些样本，只有一个特征，我们把特征和结果作图以后发现，是这个样子的：

这些样本特征和结果关系的走势，根本不是直线嘛。看起来还挺像二阶曲线的。

这个时候，我们完全可以把特征从一个“变成”两个：


这样一来，我们只需要在二维向量空间里训练
f(X)=a+BX，就可以了。

当然，这种操作也不限于在一维到二维之间的转换，一维也可以转为三维、四维、n 维；或者原本的 k 维也可以每一维都求平方后作为新特征引入，转为 2k 维，如此种种……依需要而取就好。

七 线性回归—梯度下降法求解目标函数

y = a + bx 的目标函数为：
其实线性回归的目标函数都可以为上式，因为由上式中的计算方法和线性函数构成的目标函数能证明是凸函数。

斜率、导数和偏微分

梯度下降法：从任意点开始，在该点对目标函数求导，沿着导数方向（梯度）“走”（下降）一个给定步长，如此循环迭代，直至“走”到导数为0的位置（最优点位置），则达到极小值。

为什么要求导呢？从下图可以看到：曲线表示一个函数，它在一个点处的导数值就是经过这个点的函数曲线切线的斜率。
导数表现的是函数 f(x) 在 x 轴上某一点 x0 处，沿着 x 轴正方向的变化率/变化趋势，记作 f′(x0)。
在 x 轴上某一点处，如果f′(x0)>0 ，说明 f(x) 的函数值在 x0 点沿 x 轴正方向是趋于增加的；如果 f′(x0)<0，说明 f(x) 的函数值在 x0 点沿 x 轴正方向是趋于减少的。

一元函数在某一点处沿 x 轴正方向的变化率称为导数。但如果是二元或更多元的函数（自变量维度 >=2），则某一点处沿某一维度坐标轴正方向的变化率称为偏导数。

导数/偏导数表现的是变化率，而变化本身，用另一个概念来表示，这个概念就是微分（对应偏导数，二元及以上函数有偏微分）。

直观而不严格的来说，（偏）微分就是沿着（偏）导数的方向，产生了一个无穷小的增量。
记住常用规则中最常用的几条

梯度下降法最重要的就是梯度
梯度就是方向，就是目标函数中所有因变量【即模型函数参数（其实就是模型，模型就是模型参数，即y=ax+b中的a和b）】沿着各自的维度坐标的单位变化。方向就是各维度上的最大单位变化值（增加变化）。所以进行优化时，需要进行反梯度方向。
线性回归代码

import matplotlib.pyplot as plt
import numpy as np
from sklearn import datasets, linear_model
from sklearn.metrics import mean_squared_error, r2_score

experiences = np.array([0,1,2,3,4,5,6,7,8,9,10])
salaries = np.array([103100, 104900, 106800, 108700, 110400, 112300, 114200, 116100, 117800, 119700, 121600])

    # 将特征数据集分为训练集和测试集，除了最后 4 个作为测试用例，其他都用于训练
X_train = experiences[:7]
X_train = X_train.reshape(-1,1)
X_test = experiences[7:]
X_test = X_test.reshape(-1,1)

    # 把目标数据（特征对应的真实值）也分为训练集和测试集
y_train = salaries[:7]
y_test = salaries[7:]

    # 创建线性回归模型
regr = linear_model.LinearRegression()

    # 用训练集训练模型——看就这么简单，一行搞定训练过程
regr.fit(X_train, y_train)

    # 用训练得出的模型进行预测
diabetes_y_pred = regr.predict(X_test)

    # 将测试结果以图标的方式显示出来
plt.scatter(X_test, y_test,  color='black')
plt.plot(X_test, diabetes_y_pred, color='blue', linewidth=3)

plt.xticks(())
plt.yticks(())
plt.show()

多元线性回归

八 朴素贝叶斯分类器

讲朴素贝叶斯模型之前，必须讲贝叶斯定理：

贝叶斯公式怎么推呢？

条件概率：

在B条件下A发生的概率=AB同时发生的概率/B发生的概率
此公式非常容易理解通过下图：

从而推导出了乘法公式：

补充：

在满足上图中三个性质就是概率
从条件概率和乘法公式可以推导出贝叶斯公式：

一般化的贝叶斯公式：
假设对样本空间A进行子集划分为

证明一下的话就是：
先讲一下全概率公式：


直观解释一下假设A区，被分为了A1，A2…An区，B为发生的某事件，比如smj遇见了zzj，那么事件在Ai区发生的概率 ，自然是（在Ai区的概率*在Ai区发生事件的概率）/事件发生的概率P(B)

l连续概率的贝叶斯定理形式：

朴素贝叶斯分类器（Naïve Bayes Classifier）
“朴素贝叶斯”（Naïve Bayes）既可以是一种算法——朴素贝叶斯算法，也可以是一种模型——朴素贝叶斯分类模型（分类器）。

首先我们来讲作为算法的 Naïve Bayes，朴素贝叶斯算法可以直接利用贝叶斯定理来实现。
先来看简洁版的贝叶斯定理：

假设，影响 B 的因素有 n 个，分别是 b1,b2,…,bn。

A 的先验概率 P(A) 和多个因素的联合概率 P(b1,b2,…,bn) 都是可以单独计算的，与 A 和 bi 之间的关系无关，因此这两项都可以被看作常数。

对于求解
P(A|b1,b2,…,bn)，最关键的是
P(b1,b2,…,bn|A)。根据链式法则，可得：

如果从b1到bn这些特征之间，在概率分布式上是条件独立的，也就是每一个特征与其他特征都不相关
那么在 i不等于j的情况下，有

上式中b1到bn是特征，而A是最终的类别，所以
换一个写法

这个公式也就是我们的朴素贝叶斯分类器的模型函数！

下面比较重要：NB（朴素贝叶斯是如何做分类的）
1.有一个朴素贝叶斯分类器模型器，它能够区分k个类别
（c1、c2…ck），用来分类的特征有n个：（F1、F2…Fn）
2.现在有个样本s,我们要用NB分类器对它做预测，则需要先提取出这个样本的所有特征值F1到Fn,将其带入到下式中进行K次运算：

3.然后比较这k次的结果，选出使得运算结果达到最大值的那个cj,这个cj就是对应类别的预测值。

实例化一个：
假设我们当前有一个模型，总共只有两个类别：c1 和 c2；有三个 Feature：F1、F2和F3。F1 有两种可能性取值：
f11 和 f12，F2 有三种可能性取值：f21、f22、f23；F3 也有两种可能性取值：f31、f32。

把这些概率值都计算出来以后，就可以用来做预测了。
比如我们有样本X，它的特征值分别是f11,f22,f31,那么：

两者都算出来以后，只需要对比谁更大，那么就是对应类别。
上面那些先验概率和条件概率是如何得到的呢？通过在训练样本中间做统计，就可以直接获得了！
再将抽象例子实例化：

假设有一家小公司招收机器学习工程师，为了在更广泛的范围内筛选人才，他们写了一些爬虫，去各个招聘平台、职场社交平台爬取简历，然后又写了一个简单的分类器，来筛选他们感兴趣的候选人。

这个筛选分类器是朴素贝叶斯分类器，训练数据是现在公司里的机器学习工程师和之前来面试过这一职位，没有被录取的人员的简历。

数据收集如下：

根据数据进行计算 ：


假设这时候一个样本x的特征值为f11,f22,f31(985毕业，硕士，掌握c++)，那么：

思路：在训练的样本的基础上做一系列概率运算，然后用这些算出来的概率按朴素贝叶斯公式拼装成分类模型—这就成就了朴素贝叶斯分类器。

有人惊了！！！！！
妈呀。训练过程连从模型函数退出目标函数都不需要的吗？我喜欢，哈哈啥哈哈哈！！！
这里有重点，目标函数一般都是依据模型函数进进行设计和选择的。

上述例子之所以这样简单，是因为我们简单地将频率当成了概率。但在现实应用中，这种方法往往不可行，因为这种方法实际上默认了“未被观测到”的就是“出现概率为0”的。这样做显然是不合理的。
（这里有重点，频率的稳定性值是概率的直观解释，那概率的严格定义是啥？）

比如：上面例子中，由于样本量太小，“博士”候选人只有两位，而且全部被录取，因此对于“未被录用”的情况而言，学历是博士的条件概率就变成了0。这种情况使得学历是否是博士成了唯一决定因素，显然不合理。

虽然我们可以靠做一些简单的变换——比如加一平滑法（就是把概率计算为：对应类别样本中该特征值出现次数 + 1 /对应类别样本总数）——来规避除以0的情况，但是这样做的“准确性”仍然非常不可靠。

我们有没有更加精准的方法呢？当然有！

九 朴素贝叶斯分类器—条件概率的参数估计

不再简单地将频率当作概率、
已知朴素贝叶斯公式：

其中，Fi 表示样本的第 i 个特征，C 为类别标签。P(Fi|C) 表示样本被判定为类别 C 前提下，第 i 个特征的条件概率。之前，对于 P(Fi|C) 我们用频率来作为概率的估计，就如同上面例子中做的那样：

现在我们要采用另一种方式
通过该特征在数据样本中的分布来计算该特征的条件概率。
首先明确一下符号：

假设：

那么：

然后：利用 D 求出 θc,i 的值。

高斯分布又名正态分布（在二维空间内形成钟形曲线），每一个高斯分布由两个参数——均值和方差，即上式中的
μc,i 和σc,i ——决定，也就是说 θc,i=(μc,i，σc,i)。

如果我们认定特征xi具有高斯分布的形式，又知道了 μc,i 和 σc,i 的取值，我们也就获得了对应 xi 的具体概率分布函数。直接带入 xi 的值计算相应条件概率，再进一步计算所有特征条件概率的积，就可以得出当前样本的后验概率了。

问题来了：我们不知道 θc,i 即（μc,i 和 σc,i）的值，因此首先需要求出它们。

θc,i 是我们要以 D 为训练数据，通过训练过程得到的结果。
训练中需要用到概率统计中的参数估计的方法。
所以最重要的是参数估计

我们在学习的是朴素贝叶斯分类器，它是一个分类模型，它的模型函数是朴素贝叶斯公式——贝叶斯定理在所有特征全部独立情况下的特例。
贝叶斯定理的名称来自于18世纪的英国数学家托马斯 · 贝叶斯，因为他证明了贝叶斯定理的一个特例

在估计概率分布参数这件事情上，贝叶斯学派和频率学派各自有一套符合自身对世界设想的参数估计方法。

在构造朴素贝叶斯分类器的过程中，当遇到需要求取特征的条件概率分布的时候，我们需要估计该特征对应的条件概率分布的参数。

这时，通常情况下，我们会选用频率学派的做法——极大似然估计法。
参数估计的常用策略是
1.先假定样本特征具备某种特定的概率分布形式
2.再基于训练样本对特征的概率分布参数进行估计

Dc 是训练集中所有被分类为 c 的样本的集合，其中样本数量为 mc；每一个样本都有 n 个特征；每一个特征有一个对应的取值。我们将第 j 个样本的第 i 个特征值记作：xi(j)。

我们已经假设 P(xi|c) 符合某一种形式的分布，该分布被参数 θc,i 唯一确定。为了明确起见，我们把 P(xi|c) 写作
P(xi|θc,i)。现在，我们要做的是，利用 Dc 来估计参数
θc,i。

引入一个新的概念——似然（Likelihood）。似然指某种事件发生的可能，和概率相似。

二者区别在于：概率用在已知参数的情况下，用来预测后续观测所得到的结果。似然则正相反，用于参数未知，但某些观测所得结果已知的情况，用来对参数进行估计。
（其实就是概率中的总体和样本)

极大似然估计，就是去寻找让似然函数 L(θc,i) 的取值达到最大的参数值的估计方法。

关键的是怎么求取

为了便于计算，我们对上面等式取对数，得到 θc,i 的对数似然：

已知，最大化一个似然函数同最大化它的自然对数是等价的。

正态分布的极大似然估计

这样我们就估算出第 i 个特征正态分布的两个参数，第
i 个特征的具体分布也就确定下来了。

注意：虽然我们此处用的是正态分布——一种连续分布，但是实际上，离散特征的分布一样可以用同样的方法来求，只不过把高斯分布公式改成其他的分布公式就好了。

估算出了每一个特征的 θc,i 之后，再将所有求出了具体参数的分布带回到朴素贝叶斯公式中，生成朴素贝叶斯分类器，再用来做预测，就好了。
代码实例

    import pandas as pd
    import numpy as np
    import time
    from sklearn.model_selection import train_test_split
    from sklearn.naive_bayes import GaussianNB

    # Importing dataset. 
    # Please refer to the 【Data】 part after the code for the data file.
    data = pd.read_csv("career_data.csv") 

    # Convert categorical variable to numeric
    data["985_cleaned"]=np.where(data["985"]=="Yes",1,0)
    data["education_cleaned"]=np.where(data["education"]=="bachlor",1,
                                      np.where(data["education"]=="master",2,
                                               np.where(data["education"]=="phd",3,4)
                                              )
                                     )
    data["skill_cleaned"]=np.where(data["skill"]=="c++",1,
                                      np.where(data["skill"]=="java",2,3
                                              )
                                     )
    data["enrolled_cleaned"]=np.where(data["enrolled"]=="Yes",1,0)

    # Split dataset in training and test datasets
    X_train, X_test = train_test_split(data, test_size=0.1, random_state=int(time.time()))

    # Instantiate the classifier
    gnb = GaussianNB()
    used_features =[
        "985_cleaned",
        "education_cleaned",
        "skill_cleaned"
    ]

    # Train classifier
    gnb.fit(
        X_train[used_features].values,
        X_train["enrolled_cleaned"]
    )
    y_pred = gnb.predict(X_test[used_features])

    # Print results
    print("Number of mislabeled points out of a total {} points : {}, performance {:05.2f}%"
          .format(
              X_test.shape[0],
              (X_test["enrolled_cleaned"] != y_pred).sum(),
              100*(1-(X_test["enrolled_cleaned"] != y_pred).sum()/X_test.shape[0])
    ))

下列数据直接存储为 career_data.csv 文件：

no,985,education,skill,enrolled

1,Yes,bachlor,C++,No

2,Yes,bachlor,Java,Yes

3,No,master,Java,Yes

4,No,master,C++,No

5,Yes,bachlor,Java,Yes

6,No,master,C++,No

7,Yes,master,Java,Yes

8,Yes,phd,C++,Yes

9,No,phd,Java,Yes

10,No,bachlor,Java,No

十 逻辑回归—由来

Logistic Regression （LR），一般翻译为逻辑回归

LR 是一种简单、高效的常用分类模型。

十一 逻辑回归—用来做分类的回归模型

十二 决策树—既能分类又能回归的模型

线性回归和朴素贝叶斯分类模型。前者只能做回归，后者只能做分类。但本文中要讲的决策树模型，却既可以用于分类，又可以用于回归。

决策树是一种非常基础又常见的机器学习模型。

一颗决策树是一个树结构（二叉树或是非二叉树），每个非叶节点对应一个特征，该节点的每一个分支代表这个特征是一个取值，而每个叶节点存放一个类别或一个回归函数（输出回归值）
使用决策树进行决策的过程就是从根节点开始，提取出待分类项中相应的特征，按照其值选择输出分支，依次向下，直到到达叶子节点，将叶子节点存放的类别或者回归函数的运算结果作为输出（决策）结果

决策树的决策过程非常直观，容易被人理解，运算量相对较少。它在机器学习当中非常重要。绝对可以位列前三。
实例：

这棵树一共有七个节点，四个叶子节点，三个非叶子节点。他是一颗分类树，每个叶子节点对应一共类别。

非叶子节点统称决策节点，每个节点对应一个条件判断，这判断条件，就是特征。

构建决策树

获得一种模型的过程叫训练，那么我们如何训练可以得到一棵决策树呢？
1.准备若干的训练数据（假设有M个样本）
2.表明每个样本预期的类别
3.人为选择一些特征（即决策条件）
4.为每个训练样本对应所有需要的特征生成相应值—数值化特征
5.将通过上面1-4步获得的训练数据输入给训练算法，训练算法通过一定的原则，决定各个特征的重要性程度，然后按照决策重要性从高到低，生成决策树。

那么训练算法到底是怎么样的？决定特征重要程度的原则又是什么呢？

有几种常用算法
决策树的构造过程就是一个迭代的过程。每一次迭代中，采用不同特征作为分裂点，来将样本数据划分成不同的类别。被用作分裂点的特征就是分裂特征。
选择分裂特征的目标，是让各个分裂子集尽可能地“纯”（涉及纯度和信息熵的概念），尽量让一个分裂子集中的样本中样本属于同一类别。

如何使得各个分裂子集“纯”，算法也有多种，这里我们来看几种。
ID３算法
该算法的核心是：以信息增益为度量，选择分裂后信息增益最大的特征进行分裂。

首先了解一下信息熵，
假设一个随机变量X有n种取值,分别为{x1,x2,…xn},每一种取值取到的概率为分别是{p1,p2,…pn}，那么x的信息熵定义为：

熵表示的是信息的混乱程度，信息越混乱，熵值越大。
设S为全部样本的集合，全部的样本一共分为n个类别，则：

其中，pi为属于第i个类别的样本，

十三 SVM—线性可分SVM原理
十四　SVM—直观理解拉格朗日乘子法
十五 SVM对偶学习
十六　线性SVM、间隔由硬到软
十七 非线性SVM和核函数
十八 SVR－一种宽容的回归模型
十九　直观认识SVM和SVR
二十 HMM－定义和假设
二十一　HMM－三个基本问题
二十二　HMM－三个基本问题的计算
二十三　CRF-概率无向图模型到线性链条件随机场
二十四 CRF—三个基本问题
二十五 从有监督到无监督：由KNN引出Kmeans
二十六 K-means—最简单的聚类算法
二十七 谱聚类–无需指定簇数量的聚类
二十八 EM算法－－－估计含有隐变量的概率模型的参数
二十九　GMM—归类样本
三十 GMM－－用EM算法求解ＧＭＭ
三十一　PCA
三十二 PCA
三十三 人工智能和神经网络