监督学习之knn、naive bayes、决策树算法实验

机器学习的流程：

机器学习定义：
A computer program is said to learn from experience E with respect to some class of tasks T and performance measure P, if its performance at tasks in T, as measured by P, improves with experience E.

也就是说，利用经验E使得任务T的性能P改善，那么我们就说程序对E进行了学习

机器学习算法分类
机器学习发展历史
判别模型与生成模型
偏差与方差
常见函数
经验风险
损失函数
常用分类算法的优缺点
k折交叉验证
训练集、验证集和测试集作用

==========================================================

机器学习算法分类

监督学习

根据样本数据是否带有标签值（label），可以将机器学习算法分成有监督学习和无监督学习两类。

在所有深度学习框架中，卷积神经网络应用最为广泛，在机器视觉等具有空间结构的数据问题上取得了成功。标准的卷积神经网络由卷积层，池化层，全连接层构成。可以看做是权重共享的全连接神经网络。

循环神经网络是仅次于卷积神经网络的第二大深度神经网络结构，在语音识别、自然语言处理等问题上取得了成功。

生成对抗网络（Generative Adversarial Network，简称 GAN）是用机器学习的方法来解决数据生成问题的一种框架，它的目标是生成服从某种随机分布的数据，由 Goodfellow 在 2014 年提出。这种模型能够找出样本数据内部的概率分布规律，并根据这种规律产生出新的数据。

AdaBoost 算法的原则是关注之前被错分的样本，准确率高的弱分类器有更大的权重。

无监督学习：聚类和降维

聚类算法可以分为层次距离，基于质心的聚类，基于概率分布的距离，基于密度的聚类，基于图的聚类这几种类型。它们从不同的角度定义簇（cluster）。基于质心的聚类典型代表是 k 均值算法。基于概率分布的聚类典型代表是 EM 算法。基于密度的聚类典型代表是 DBSCAN 算法，OPTICS 算法，Mean shift 算法。基于图的聚类典型代表是谱聚类算法。

强化学习

强化学习是一类特殊的机器学习算法，它根据输入数据确定要执行的动作，在这里。输入数据是环境参数。和有监督学习算法类似，这里也有训练过程中。在训练时，对于正确的动作做出奖励，对错误的动作做出惩罚，训练完成之后就用得到的模型进行预测。

参考：机器学习算法地图

---------

另一种划分方法：

机器学习发展历史

机器学习并不是人工智能一开始就采用的方法。人工智能的发展经历了逻辑推理，知识工程，机器学习三个阶段。

第一阶段的重点是逻辑推理，例如数学定理的证明。这类方法采用符号逻辑来模拟人的智能。

第二阶段的代表是专家系统，这类方法为各个领域的问题建立专家知识库，利用这些知识来完成推理和决策。如果要让人工智能做疾病诊断，那就要把医生的诊断知识建成一个库，然后用这些知识对病人进行判断。不具有通用性，可扩展性差。

第三阶段是机器学习。

机器学习与之前基于人工规则的模型相比，无需人工给出规则，而是让程序自动从大量的样本中抽象、归纳出知识与规则。因此，它具有更好的通用性，采用这种统一的处理框架，人们可以将机器学习算法用于各种不同的领域。

虽然机器学习这一名词以及其中某些零碎的方法可以追溯到1958年甚至更早，但真正作为一门独立的学科要从1980年算起，在这一年诞生了第一届机器学习的学术会议和期刊。到目前为止，机器学习的发展经历了3个阶段：

1980年代是正式成形期，尚不具备影响力。1990-2010年代是蓬勃发展期，诞生了众多的理论和算法，真正走向了实用。2012年之后是深度学习时期，深度学习技术诞生并急速发展，较好的解决了现阶段AI的一些重点问题，并带来了产业界的快速发展。

上图展示了过去近40年里机器学习领域诞生的主要算法（重点是有监督学习）

1980s：登上历史舞台

1980年机器学习作为一支独立的力量登上了历史舞台。在这之后的10年里出现了一些重要的方法和理论，典型的代表是：

1984：分类与回归树（CART）
1986：反向传播算法
1989：卷积神经网络

1990-2012：走向成熟和应用

在这20多年里机器学习的理论和方法得到了完善和充实，可谓是百花齐放的年代。代表性的重要成果有：

1995：支持向量机（SVM）[5]

1997：AdaBoost算法[7]

1997：循环神经网络（RNN）和LSTM[9]

2000：流形学习[8]

2001：随机森林[6]

2012：深度学习时代

神经网络卷土重来？

参考：机器学习-波澜壮阔40年

判别模型与生成模型

判别方法：由数据直接学习决策函数 Y = f（X），或者由条件分布概率 P（Y|X）作为预测模型，即判别模型。

生成方法：由数据学习联合概率密度分布函数 P（X,Y）,然后求出条件概率分布P(Y|X)作为预测的模型，即生成模型。

可见，区分的关键是是否涉及到联合概率密度函数的求取

由生成模型可以得到判别模型，但由判别模型得不到生成模型。

-------------------------------------

常见的判别模型有：

1 K-means ：详细介绍请参考机器学习|K-Means算法

2 SVM，请参考：BAT面试题1：请简要介绍下SVM

3 决策树，请参考：机器学习：谈谈决策树

4 感知机

5 线性判别分析（LDA）

6 线性回归，请参考：机器学习之线性回归：算法兑现为python代码

7 传统的神经网络，请参考：足够惊艳：神经网络可以逼近任意函数吗？

8 逻辑斯蒂回归，请参考：机器学习逻辑回归：算法兑现为python代码

9 boosting，请参考：机器学习：提升树（boosting tree）算法的思想

10 条件随机场

常见的生成模型有：

1朴素贝叶斯，请参考：朴素贝叶斯分类器：例子解释

2 隐马尔可夫模型，请参考：纯享福利：5步公式推导隐马前向概率算法

3 高斯混合模型，请参考：机器学习高斯混合模型：聚类原理分析（前篇）

4 文档主题生成模型（LDA）

5 限制玻尔兹曼机

参考：

机器学习---生成模型与判别模型https://blog.csdn.net/u012101561/article/details/52814571
BAT面试题9：谈谈判别式模型和生成式模型？

偏差与方差

下图解释:

通过n次采样得到n个大小为m的训练样本集合，训练出n个模型，然后对同一个样本进行预测得到。不同的打靶点，表示不同模型对同一个样本点的预测结果。

在有监督学习中，模型的泛化误差来源于两个方面——偏差和方差。

偏差，是由于对训练样本学习不足。高偏差表现在图中，就是21，靶点的均值离靶心远

方差，由于模型过于复杂，过拟合所致。高方差表现在图中，就是12，打靶点分散。

------------------------------------

偏差和方差的关系和模型容量（模型复杂度）、欠拟合和过拟合的概念紧密相联：

存在一个最佳的模型复杂度，对应于偏差和方差之和（泛化误差）最小

参考：

Understanding the Bias-Variance Tradeoff

常见函数

sgn(x)，阶跃函数
S函数
sign(x)，符号函数。（感知机、SVM里采用）

经验风险最小化：

其中，

$R_{\theta}$ 为损失函数：

但是，因为用来训练的样本往往是真实数据的一个很小的子集或者包含一定的噪声数据，不能很好地反映全部数据的真实分布。

经验风险最小化原则很容易导致模型在训练集上错误率很低，但是在未知数据上错误率很高。

也就是说，经验风险最小化容易过拟合，引入正则项：

这就是结构化风险最小化原则。此处的

$||\theta||_2$ 是

$L_2$ 范数的正则化项，λ 用来控制正则化的强度。

正则化项也可以使用其它函数，比如 L1 范数。L1 范数的引入通常会使得参数有一定稀疏性，因此在很多算法中也经常使用。在 Bayes 估计的角度来讲，正则化是假设了参数的先验分布，不完全依赖训练数据。

损失函数

针对分类和回归，有不同的损失函数^[1]。

回归问题：

L2：

$(\tilde{y}-y)^2$

L1：

$|\tilde{y}-y|$

Pseudo-Huber Loss：

$其中，a = (\tilde{y}-y)$

图像如下：

import matplotlib.pyplot as plt
import tensorflow as tf
from tensorflow.python.framework import ops
ops.reset_default_graph()sess = tf.Session()   #创建会话# Various Predicted X-values
x_vals = tf.linspace(-3., 3., 500)   #生成500个数# Create our target of zero
target = tf.constant(0.)# L2损失
# L2 loss
# L = (pred - actual)^2
l2_y_vals = tf.square(target - x_vals)
l2_y_out = sess.run(l2_y_vals)# L1损失
# L1 loss
# L = abs(pred - actual)
l1_y_vals = tf.abs(target - x_vals)
l1_y_out = sess.run(l1_y_vals)# Pseudo-Huber Loss
# L = delta^2 * (sqrt(1 + ((pred - actual)/delta)^2) - 1)# Pseudo-Huber with delta = 0.25
delta1 = tf.constant(0.25)
phuber1_y_vals = tf.multiply(tf.square(delta1), tf.sqrt(1. + tf.square((target - x_vals)/delta1)) - 1.)
phuber1_y_out = sess.run(phuber1_y_vals)# Pseudo-Huber with delta = 5
delta2 = tf.constant(5.)
phuber2_y_vals = tf.multiply(tf.square(delta2), tf.sqrt(1. + tf.square((target - x_vals)/delta2)) - 1.)
phuber2_y_out = sess.run(phuber2_y_vals)x_array = sess.run(x_vals)
plt.plot(x_array, l2_y_out, 'b-', label='L2 Loss')
plt.plot(x_array, l1_y_out, 'r--', label='L1 Loss')
plt.plot(x_array, phuber1_y_out, 'k-.', label='P-Huber Loss (0.25)')
plt.plot(x_array, phuber2_y_out, 'g:', label='P-Huber Loss (5.0)')
plt.ylim(-0.2, 5)
plt.legend(loc='lower right', prop={'size': 11})
plt.grid()
plt.show()

分析：

当预测值距离真实值愈远时，L2损失函数的惩罚力度越大，因此其对异常点较敏感；

L1更鲁棒一些，但是可导性差；

综合考虑，可以采用Pseudo-Huber 损失，针对不同的δ取值，可以得到不同效果

========================

不同学习率下L1 、L2表现：

从图可以看出，在小的学习率下，L1 、L2均可收敛，但是具体时间可能会比较慢

但是如果增大学习率，虽然下降的快了，但是最终有可能发散

代码展示：

# Linear Regression: L1 vs L2
#----------------------------------
#
# This function shows how to use TensorFlow to
# solve linear regression via the matrix inverse.import matplotlib.pyplot as plt
import numpy as np
import tensorflow as tf
from sklearn import datasets
from tensorflow.python.framework import ops
ops.reset_default_graph()# Create graph
sess = tf.Session()# Load the data
# iris.data = [(Sepal Length, Sepal Width, Petal Length, Petal Width)]
iris = datasets.load_iris()
x_vals = np.array([x[3] for x in iris.data])
y_vals = np.array([y[0] for y in iris.data])# Declare batch size and number of iterations
batch_size = 25
learning_rate = 0.05 # Will not converge with learning rate at 0.4
iterations = 50# Initialize placeholders
x_data = tf.placeholder(shape=[None, 1], dtype=tf.float32)
y_target = tf.placeholder(shape=[None, 1], dtype=tf.float32)# Create variables for linear regression
A = tf.Variable(tf.random_normal(shape=[1,1]))
b = tf.Variable(tf.random_normal(shape=[1,1]))# Declare model operations
model_output = tf.add(tf.matmul(x_data, A), b)# Declare loss functions
loss_l1 = tf.reduce_mean(tf.abs(y_target - model_output))# Declare optimizers
my_opt_l1 = tf.train.GradientDescentOptimizer(learning_rate)
train_step_l1 = my_opt_l1.minimize(loss_l1)# Initialize variables
init = tf.global_variables_initializer()
sess.run(init)# Training loop
loss_vec_l1 = []
for i in range(iterations):rand_index = np.random.choice(len(x_vals), size=batch_size)rand_x = np.transpose([x_vals[rand_index]])rand_y = np.transpose([y_vals[rand_index]])sess.run(train_step_l1, feed_dict={x_data: rand_x, y_target: rand_y})temp_loss_l1 = sess.run(loss_l1, feed_dict={x_data: rand_x, y_target: rand_y})loss_vec_l1.append(temp_loss_l1)if (i+1)%25==0:print('Step #' + str(i+1) + ' A = ' + str(sess.run(A)) + ' b = ' + str(sess.run(b)))# L2 Loss
# Reinitialize graph
ops.reset_default_graph()# Create graph
sess = tf.Session()# Initialize placeholders
x_data = tf.placeholder(shape=[None, 1], dtype=tf.float32)
y_target = tf.placeholder(shape=[None, 1], dtype=tf.float32)# Create variables for linear regression
A = tf.Variable(tf.random_normal(shape=[1,1]))
b = tf.Variable(tf.random_normal(shape=[1,1]))# Declare model operations
model_output = tf.add(tf.matmul(x_data, A), b)# Declare loss functions
loss_l2 = tf.reduce_mean(tf.square(y_target - model_output))# Declare optimizers
my_opt_l2 = tf.train.GradientDescentOptimizer(learning_rate)
train_step_l2 = my_opt_l2.minimize(loss_l2)# Initialize variables
init = tf.global_variables_initializer()
sess.run(init)loss_vec_l2 = []
for i in range(iterations):rand_index = np.random.choice(len(x_vals), size=batch_size)rand_x = np.transpose([x_vals[rand_index]])rand_y = np.transpose([y_vals[rand_index]])sess.run(train_step_l2, feed_dict={x_data: rand_x, y_target: rand_y})temp_loss_l2 = sess.run(loss_l2, feed_dict={x_data: rand_x, y_target: rand_y})loss_vec_l2.append(temp_loss_l2)if (i+1)%25==0:print('Step #' + str(i+1) + ' A = ' + str(sess.run(A)) + ' b = ' + str(sess.run(b)))# Plot loss over time
plt.plot(loss_vec_l1, 'k-', label='L1 Loss')
plt.plot(loss_vec_l2, 'r--', label='L2 Loss')
plt.title('L1 and L2 Loss per Generation')
plt.xlabel('Generation')
plt.ylabel('L1 Loss')
plt.legend(loc='upper right')
plt.show()

0.05学习率下

已经发散了：

0.4学习率下

分类问题

此时，横坐标画的：

$(\tilde{y}*y)$

在统一标签的情况下，（3.102）推导见下：【这里一篇文章写得很好^[2]^[3]】

其实，不用推导，可以直接看出来。采用【-1，1】标签后，损失函数更加的简洁。关键是明白前面的指示函数 I 的含义，我们只关心标签值的概率大小，并且只有两种标签。我们采用S函数算的永远是属于 +1 的概率

import matplotlib.pyplot as plt
import tensorflow as tf
from tensorflow.python.framework import ops
ops.reset_default_graph()sess = tf.Session()   #创建会话# best
#   upper right
#   upper left
#   lower left
#   lower right
#   right
#   center left
#   center right
#   lower center
#   upper center
#   center# Various predicted X values
x_vals = tf.linspace(-3., 5., 500)# Target of 1.0
target = tf.constant(1.)      #预测目标值为1
targets = tf.fill([500,], 1.)# 1 Hinge loss
# Use for predicting binary (-1, 1) classes
# L = max(0, 1 - (pred * actual))
hinge_y_vals = tf.maximum(0., 1. - tf.multiply(target, x_vals))
hinge_y_out = sess.run(hinge_y_vals)# 2 感知机 loss
p_y_vals = tf.maximum(0., - tf.multiply(target, x_vals))
p_y_out = sess.run(p_y_vals)# 3. Cross entropy loss   交叉熵损失，LR采用
# L = -actual * (log(sigmoid(pred))) - (1-actual)(log(1-sigmoid(pred)))
# or
# L = max(actual, 0) - actual * pred + log(1 + exp(-abs(actual)))
x_val_input = tf.expand_dims(x_vals, 1)
target_input = tf.expand_dims(targets, 1)
xentropy_sigmoid_y_vals = tf.nn.sigmoid_cross_entropy_with_logits(logits=x_val_input, labels=target_input)
xentropy_sigmoid_y_out = sess.run(xentropy_sigmoid_y_vals)# Weighted (softmax) cross entropy loss
# L = -actual * (log(pred)) * weights - (1-actual)(log(1-pred))
# or
# L = (1 - pred) * actual + (1 + (weights - 1) * pred) * log(1 + exp(-actual))
weight = tf.constant(0.5)
xentropy_weighted_y_vals = tf.nn.weighted_cross_entropy_with_logits(logits=x_vals,targets=targets,pos_weight=weight)
xentropy_weighted_y_out = sess.run(xentropy_weighted_y_vals)# Plot the output
x_array = sess.run(x_vals)
plt.plot(x_array, hinge_y_out, 'b-', label='Hinge Loss')
plt.plot(x_array, p_y_out, 'r--', label='perceptron Loss')
plt.plot(x_array, xentropy_sigmoid_y_out, 'k-.', label='Cross Entropy Sigmoid Loss')
plt.plot(x_array, xentropy_weighted_y_out, 'g:', label='Weighted Cross Entropy Loss (x0.5)')
plt.ylim(-1.5, 3)
plt.legend(loc='lower right', prop={'size': 11})
plt.grid()
plt.show()

注意，此处的的横坐标为 f*【wx+b】

常用分类算法的优缺点

k折交叉验证

当我们有多个模型可以选择时，可以采用交叉验证的方法确实最优的模型

10 折交叉验证示意图

具体思路如下^[4]：

训练集、验证集和测试集作用

在机器学习中，开发模型时总需要调节模型的参数，比如改变权重、选择层数或每层的大小，这个调节过程需要在训练的模型上通过验证集数据的表现来提供一个反馈信号，去修改网络模型及参数。这就是验证集的作用，这也会造成验证集的信息泄露，反馈的越多，信息泄露的越多，即模型就更清楚的认识验证集，最终会造成模型在验证集上过拟合，这时就需要一个对于模型完全陌生的数据集-----测试集来衡量模型的好坏。【机器学习：为什么需要验证集？。】

参考

^常见的损失函数(loss function)总结 https://zhuanlan.zhihu.com/p/58883095
^简单的交叉熵损失函数，你真的懂了吗？ https://www.jianshu.com/p/756baa220882
^简单的交叉熵损失函数，你真的懂了吗？ https://zhuanlan.zhihu.com/p/38241764
^机器学习中的交叉验证（cross-validation） https://blog.csdn.net/lhx878619717/article/details/49079785