一、随机森林算法简介：
       在机器学习中，随机森林是一个包含多个决策树的分类器， 并且其输出的类别是由个别树输出的类别的众数而定。 Leo Breiman和Adele Cutler发展出推论出随机森林的算法。而 "Random Forests" 是他们的商标。 这个术语是1995年由贝尔实验室的Tin Kam Ho所提出的随机决策森林（random decision forests）而来的。这个方法则是结合Breimans 的 "Bootstrap aggregating" 想法和 Ho 的"randomsubspace method"以建造决策树的集合。
       根据下列算法而建造每棵树 ：

 
1.   用M来表示训练用例（样本）的个数，N表示特征数目。
 
2.   输入特征数目n，用于确定决策树上一个节点的决策结果；其中n应远小于N。
 
3.   从M个训练用例（样本）中以有放回抽样的方式，取样k次，形成一个训练集（即bootstrap取样），并用未抽到的用例（样本）作预测，评估其误差。
 
4.   对于每一个节点，随机选择n个特征，每棵决策树上每个节点的决定都是基于这些特征确定的。根据这n个特征，计算其最佳的分裂方式。
 
5.   每棵树都会完整成长而不会剪枝，这有可能在建完一棵正常树状分类器后会被采用。
 
6.   最后测试数据，根据每棵树，以多胜少方式决定分类。

     在构建随机森林时，需要做到两个方面：数据的随机性选取，以及待选特征的随机选取，来消除过拟合问题。
     首先，从原始的数据集中采取有放回的抽样，构造子数据集，子数据集的数据量是和原始数据集相同的。不同子数据集的元素可以重复，同一个子数据集中的元素也可以重复。第二，利用子数据集来构建子决策树，将这个数据放到每个子决策树中，每个子决策树输出一个结果。最后，如果有了新的数据需要通过随机森林得到分类结果，就可以通过对子决策树的判断结果的投票，得到随机森林的输出结果了。如下图，假设随机森林中有3棵子决策树，2棵子树的分类结果是A类，1棵子树的分类结果是B类，那么随机森林的分类结果就是A类。
     与数据集的随机选取类似，随机森林中的子树的每一个分裂过程并未用到所有的待选特征，而是从所有的待选特征中随机选取一定的特征，之后再在随机选取的特征中选取最优的特征。这样能够使得随机森林中的决策树都能够彼此不同，提升系统的多样性，从而提升分类性能。
     优点：
    随机森林的既可以用于回归也可以用于分类任务，并且很容易查看模型的输入特征的相对重要性。随机森林算法被认为是一种非常方便且易于使用的算法，因为它是默认的超参数通常会产生一个很好的预测结果。超参数的数量也不是那么多，而且它们所代表的含义直观易懂。
    随机森林有足够多的树，分类器就不会产生过度拟合模型。
    缺点：
    由于使用大量的树会使算法变得很慢，并且无法做到实时预测。一般而言，这些算法训练速度很快，预测十分缓慢。越准确的预测需要越多的树，这将导致模型越慢。在大多数现实世界的应用中，随机森林算法已经足够快，但肯定会遇到实时性要求很高的情况，那就只能首选其他方法。当然，随机森林是一种预测性建模工具，而不是一种描述性工具。也就是说，如果您正在寻找关于数据中关系的描述，那建议首选其他方法。
    适用范围：
    随机森林算法可被用于很多不同的领域，如银行，股票市场，医药和电子商务。在银行领域，它通常被用来检测那些比普通人更高频率使用银行服务的客户，并及时偿还他们的债务。同时，它也会被用来检测那些想诈骗银行的客户。在金融领域，它可用于预测未来股票的趋势。在医疗保健领域，它可用于识别药品成分的正确组合，分析患者的病史以识别疾病。除此之外，在电子商务领域中，随机森林可以被用来确定客户是否真的喜欢某个产品。
二、sklearn中随机森林算法应用举例：
    （1）基本步骤：
    ①选择数据：将你的数据分成三组：训练数据、验证数据和测试数据
    ②模型数据：使用训练数据来构建使用相关特征的模型
    ③验证模型：使用你的验证数据接入你的模型
    ④测试模型：使用你的测试数据检查被验证的模型的表现
     ⑤使用模型：使用完全训练好的模型在新数据上做预测
    ⑥调优模型：使用更多数据、不同的特征或调整过的参数来提升算法的性能表现
    为方便大家使用，代码如下：
import csv
import numpy asnp
fromsklearn.ensemble import RandomForestRegressor
from sklearnimport preprocessing
from sklearn.metricsimport mean_squared_error, explained_variance_score
importmatplotlib.pyplot as plt
#---------------------------------------------------------------------------------
defload_dataset(filename):
    file_reader = csv.reader(open(filename,'rb'), delimiter=',')
    X, y = [], []
    for row in file_reader:
        X.append(row[2:13])
        y.append(row[-1])
    # Extract feature names
    feature_names = np.array(X[0])
    return np.array(X[1:]).astype(np.float32),np.array(y[1:]).astype(np.float32), feature_names
if__name__=='__main__':
    X, y, feature_names =load_dataset("d:\\bike_day.csv")
    X, y = shuffle(X, y, random_state=7) 
    num_training = int(0.9 * len(X))
    X_train, y_train = X[:num_training],y[:num_training]
    X_test, y_test = X[num_training:],y[num_training:]
    rf_regressor =RandomForestRegressor(n_estimators=1000, max_depth=10, min_samples_split=1)
    rf_regressor.fit(X_train, y_train)
    y_pred = rf_regressor.predict(X_test)
    mse = mean_squared_error(y_test, y_pred)
    evs = explained_variance_score(y_test,y_pred) 
    from AdaBoostRegressor importplot_feature_importances
   plot_feature_importances(rf_regressor.feature_importances_, 'RandomForest regressor', feature_names)
         数据集格式如下：
instant,dteday,season,yr,mnth,holiday,weekday,workingday,weathersit,temp,atemp,hum,windspeed,casual,registered,cnt
1,2011-01-01,1,0,1,0,6,0,2,0.344167,0.363625,0.805833,0.160446,331,654,985
2,2011-01-02,1,0,1,0,0,0,2,0.363478,0.353739,0.696087,0.248539,131,670,801
3,2011-01-03,1,0,1,0,1,1,1,0.196364,0.189405,0.437273,0.248309,120,1229,1349
以下数据省略。
 

 
博文目录
 
1. 概述
2. 梯度下降算法
2.1 场景假设
2.2 梯度下降
2.2.1 微分
2.2.2 梯度
      
2.3 数学解释
2.3.1 α
2.3.2 梯度要乘以一个负号
     
     
3. 实例
3.1 单变量函数的梯度下降
3.2 多变量函数的梯度下降
     
4. 代码实现
4. 1 场景分析
4. 2 代码
     
5. 小结
   
  
 

 
1. 概述
 
梯度下降（gradient descent）在机器学习中应用十分的广泛，不论是在线性回归还是Logistic回归中，它的主要目的是通过迭代找到目标函数的最小值，或者收敛到最小值。
 本文将从一个下山的场景开始，先提出梯度下降算法的基本思想，进而从数学上解释梯度下降算法的原理，解释为什么要用梯度，最后实现一个简单的梯度下降算法的实例！
 
2. 梯度下降算法
 
2.1 场景假设
 
梯度下降法的基本思想可以类比为一个下山的过程。
 假设这样一个场景：一个人被困在山上，需要从山上下来(找到山的最低点，也就是山谷)。但此时山上的浓雾很大，导致可视度很低；因此，下山的路径就无法确定，必须利用自己周围的信息一步一步地找到下山的路。这个时候，便可利用梯度下降算法来帮助自己下山。怎么做呢，首先以他当前的所处的位置为基准，寻找这个位置最陡峭的地方，然后朝着下降方向走一步，然后又继续以当前位置为基准，再找最陡峭的地方，再走直到最后到达最低处；同理上山也是如此，只是这时候就变成梯度上升算法了
 
 
2.2 梯度下降
 
梯度下降的基本过程就和下山的场景很类似。
 
首先，我们有一个可微分的函数。这个函数就代表着一座山。我们的目标就是找到这个函数的最小值，也就是山底。根据之前的场景假设，最快的下山的方式就是找到当前位置最陡峭的方向，然后沿着此方向向下走，对应到函数中，就是找到给定点的梯度 ，然后朝着梯度相反的方向，就能让函数值下降的最快！因为梯度的方向就是函数之变化最快的方向(在后面会详细解释)
 所以，我们重复利用这个方法，反复求取梯度，最后就能到达局部的最小值，这就类似于我们下山的过程。而求取梯度就确定了最陡峭的方向，也就是场景中测量方向的手段。那么为什么梯度的方向就是最陡峭的方向呢？接下来，我们从微分开始讲起：
 
2.2.1 微分
 
看待微分的意义，可以有不同的角度，最常用的两种是：
 
函数图像中，某点的切线的斜率
函数的变化率
 几个微分的例子：
 
1.单变量的微分，函数只有一个变量时
 
$\frac{d(x^2)}{dx}=2x$
 
$\frac{d(-2y^5)}{dy}=-10y^4$
 
$\frac{d(5-\theta {)}^2}{d\theta }=-2(5-\theta )$
 
2.多变量的微分，当函数有多个变量的时候，即分别对每个变量进行求微分
 
$\frac{\partial }{\partial x}(x^2{y}^2)=2x{y}^2$
 
$\frac{\partial }{\partial y}(-2y^5+z^2)=-10y^4$
 
$\frac{\partial }{\partial {\theta }_2}(5{\theta }_1+2{\theta }_2-12{\theta }_3)=2$
 
$\frac{\partial }{\partial {\theta }_2}(0.55-(5{\theta }_1+2{\theta }_2-12{\theta }_3))=-2$
 
2.2.2 梯度
 
梯度实际上就是多变量微分的一般化。
 下面这个例子：
 
$J(\Theta )=0.55-(5{\theta }_1+2{\theta }_2-12{\theta }_3)$
 
$▽J(\Theta )=⟨\frac{\partial J}{\partial {\theta }_1},\frac{\partial J}{\partial {\theta }_2},\frac{\partial J}{\partial {\theta }_3}⟩=(-5,-2,12)$
 
我们可以看到，梯度就是分别对每个变量进行微分，然后用逗号分割开，梯度是用<>包括起来，说明梯度其实一个向量。
 
梯度是微积分中一个很重要的概念，之前提到过梯度的意义
 
在单变量的函数中，梯度其实就是函数的微分，代表着函数在某个给定点的切线的斜率
在多变量函数中，梯度是一个向量，向量有方向，梯度的方向就指出了函数在给定点的上升最快的方向
 
这也就说明了为什么我们需要千方百计的求取梯度！我们需要到达山底，就需要在每一步观测到此时最陡峭的地方，梯度就恰巧告诉了我们这个方向。梯度的方向是函数在给定点上升最快的方向，那么梯度的反方向就是函数在给定点下降最快的方向，这正是我们所需要的。所以我们只要沿着梯度的方向一直走，就能走到局部的最低点！
 
2.3 数学解释
 
首先给出数学公式：
 
${\Theta }^1={\Theta }^0+\alpha ▽J(\Theta )\to evaluatedat{\Theta }^0$
 
此公式的意义是：J是关于Θ的一个函数，我们当前所处的位置为Θ0点，要从这个点走到J的最小值点，也就是山底。首先我们先确定前进的方向，也就是梯度的反向，然后走一段距离的步长，也就是α，走完这个段步长，就到达了Θ1这个点！
 
 
2.3.1 α
 
α在梯度下降算法中被称作为学习率或者步长，意味着我们可以通过α来控制每一步走的距离，以保证不要步子跨的太大扯着蛋，哈哈，其实就是不要走太快，错过了最低点。同时也要保证不要走的太慢，导致太阳下山了，还没有走到山下。所以α的选择在梯度下降法中往往是很重要的！α不能太大也不能太小，太小的话，可能导致迟迟走不到最低点，太大的话，会导致错过最低点！
 
2.3.2 梯度要乘以一个负号
 
梯度前加一个负号，就意味着朝着梯度相反的方向前进！我们在前文提到，梯度的方向实际就是函数在此点上升最快的方向！而我们需要朝着下降最快的方向走，自然就是负的梯度的方向，所以此处需要加上负号；那么如果时上坡，也就是梯度上升算法，当然就不需要添加负号了。
 
3. 实例
 
我们已经基本了解了梯度下降算法的计算过程，那么我们就来看几个梯度下降算法的小实例，首先从单变量的函数开始，然后介绍多变量的函数。
 
3.1 单变量函数的梯度下降
 
我们假设有一个单变量的函数
 
$J(\theta )={\theta }^2$
 
函数的微分，直接求导就可以得到
 
$J^{\prime }(\theta )=2\theta$
 
初始化，也就是起点，起点可以随意的设置，这里设置为1
 
${\theta }^0=1$
 
学习率也可以随意的设置，这里设置为0.4
 
$\alpha =0.4$
 
根据梯度下降的计算公式
 
${\Theta }^1={\Theta }^0+\alpha ▽J(\Theta )\to evaluatedat{\Theta }^0$
 
我们开始进行梯度下降的迭代计算过程：
 
${\theta }^0=1$
 
${\theta }^1={\theta }^0-\alpha \ast J^{\prime }({\theta }^0)=1-0.4\ast 2=0.2$
 
${\theta }^2={\theta }^1-\alpha \ast J^{\prime }({\theta }^1)=0.2-0.4\ast 0.4=0.04$
 
${\theta }^3=0.008$
 
${\theta }^4=0.0016$
 
如图，经过四次的运算，也就是走了四步，基本就抵达了函数的最低点，也就是山底
 
 
3.2 多变量函数的梯度下降
 
我们假设有一个目标函数
 
$J(\Theta )={\theta }_1^2+{\theta }_2^2$
 
现在要通过梯度下降法计算这个函数的最小值。我们通过观察就能发现最小值其实就是 (0，0)点。但是接下来，我们会从梯度下降算法开始一步步计算到这个最小值！
 我们假设初始的起点为：
 
${\Theta }^0=(1,3)$
 
初始的学习率为：
 
$\alpha =0.1$
 
函数的梯度为：
 
$▽J(\Theta )=⟨2{\theta }_1,2{\theta }_2⟩$
 
进行多次迭代：
 
${\Theta }^0=(1,3)$
 
${\Theta }^1={\Theta }^0-\alpha ▽J(\Theta )=(1,3)-0.1\ast (2,6)=(0.8,2.4)$
 
${\Theta }^2=(0.8,2.4)-0.1\ast (1.6,4.8)=(0.64,1.92)$
 
${\Theta }^3=(0.5124,1.536)$
 
${\Theta }^4=(0.4096,1.228800000000001)$
 $⋮$
 ${\Theta }^{10}=(0.1073741824000003,0.32212254720000005)$
 $⋮$
 ${\Theta }^{50}=(1.141798154164342e^{-05},3.42539442494306e^{-05})$
 $⋮$
 ${\Theta }^{100}=(1.6296287810675902e^{-10},4.8888886343202771e^{-10})$
 
我们发现，已经基本靠近函数的最小值点
 
 
4. 代码实现
 
4. 1 场景分析
 
下面我们将用python实现一个简单的梯度下降算法。场景是一个简单的线性回归的例子：假设现在我们有一系列的点，如下图所示：
 
 我们将用梯度下降法来拟合出这条直线！
 
首先，我们需要定义一个代价函数，在此我们选用均方误差代价函数（也称平方误差代价函数）
 
$J(\Theta )=\frac{1}{2m}{\sum }_{i=1}^m(h_{\theta }(x^{(i)})-y^{(i)}{)}^2$
 
此公式中
 
m是数据集中数据点的个数，也就是样本数
½是一个常量，这样是为了在求梯度的时候，二次方乘下来的2就和这里的½抵消了，自然就没有多余的常数系数，方便后续的计算，同时对结果不会有影响
y 是数据集中每个点的真实y坐标的值，也就是类标签
h 是我们的预测函数（假设函数），根据每一个输入x，根据Θ 计算得到预测的y值，即
 
$h_{\Theta }(x^{(i)})={\Theta }_0+{\Theta }_1{x}_1^{(i)}$
 
我们可以根据代价函数看到，代价函数中的变量有两个，所以是一个多变量的梯度下降问题，求解出代价函数的梯度，也就是分别对两个变量进行微分
 
$▽J(\Theta )=⟨\frac{\delta J}{\delta {\Theta }_0},\frac{\delta J}{\delta {\Theta }_1}⟩$
 
$\frac{\delta J}{\delta {\Theta }_0}=\frac{1}{m}{\sum }_{i=1}^m(h_{\Theta }(x^{(i)})-y^{(i)})$
 
$\frac{\delta J}{\delta {\Theta }_1}=\frac{1}{m}{\sum }_{i=1}^m(h_{\Theta }(x^{(i)})-y^{(i)})x_1^{(i)}$
 
明确了代价函数和梯度，以及预测的函数形式。我们就可以开始编写代码了。但在这之前，需要说明一点，就是为了方便代码的编写，我们会将所有的公式都转换为矩阵的形式，python中计算矩阵是非常方便的，同时代码也会变得非常的简洁。
 为了转换为矩阵的计算，我们观察到预测函数的形式
 
$h_{\Theta }(x^{(i)})={\Theta }_0+{\Theta }_1{x}^{(i)}$
 
我们有两个变量，为了对这个公式进行矩阵化，我们可以给每一个点x增加一维，这一维的值固定为1，这一维将会乘到Θ0上。这样就方便我们统一矩阵化的计算
 
$(x_1^{(i)},y^{(i)})\to (x_0^{(i)},x_1^{(i)},y^{(i)})with{x}_0^{(i)}=1{\forall }_i$
 
然后我们将代价函数和梯度转化为矩阵向量相乘的形式
 
$J(\Theta )=\frac{1}{2m}(X\Theta -\vec{y}{)}^T(X\Theta -\vec{y})$
 
$▽J(\Theta )=\frac{1}{m}{X}^T(X\Theta -\vec{y}))$
 
4. 2 代码
 
首先，我们需要定义数据集和学习率
 
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# @Time    : 2019/1/21 21:06
# @Author  : Arrow and Bullet
# @FileName: gradient_descent.py
# @Software: PyCharm
# @Blog    ：https://blog.csdn.net/qq_41800366

from numpy import *

# 数据集大小 即20个数据点
m = 20
# x的坐标以及对应的矩阵
X0 = ones((m, 1))  # 生成一个m行1列的向量，也就是x0，全是1
X1 = arange(1, m+1).reshape(m, 1)  # 生成一个m行1列的向量，也就是x1，从1到m
X = hstack((X0, X1))  # 按照列堆叠形成数组，其实就是样本数据
# 对应的y坐标
y = np.array([
    3, 4, 5, 5, 2, 4, 7, 8, 11, 8, 12,
    11, 13, 13, 16, 17, 18, 17, 19, 21
]).reshape(m, 1)
# 学习率
alpha = 0.01
 
接下来我们以矩阵向量的形式定义代价函数和代价函数的梯度
 
# 定义代价函数
def cost_function(theta, X, Y):
    diff = dot(X, theta) - Y  # dot() 数组需要像矩阵那样相乘，就需要用到dot()
    return (1/(2*m)) * dot(diff.transpose(), diff)


# 定义代价函数对应的梯度函数
def gradient_function(theta, X, Y):
    diff = dot(X, theta) - Y
    return (1/m) * dot(X.transpose(), diff)
 
最后就是算法的核心部分，梯度下降迭代计算
 
# 梯度下降迭代
def gradient_descent(X, Y, alpha):
    theta = array([1, 1]).reshape(2, 1)
    gradient = gradient_function(theta, X, Y)
    while not all(abs(gradient) <= 1e-5):
        theta = theta - alpha * gradient
        gradient = gradient_function(theta, X, Y)
    return theta


optimal = gradient_descent(X, Y, alpha)
print('optimal:', optimal)
print('cost function:', cost_function(optimal, X, Y)[0][0])
 
当梯度小于1e-5时，说明已经进入了比较平滑的状态，类似于山谷的状态，这时候再继续迭代效果也不大了，所以这个时候可以退出循环！
 运行代码，计算得到的结果如下：
 
print('optimal:', optimal)  # 结果 [[0.51583286][0.96992163]]
print('cost function:', cost_function(optimal, X, Y)[0][0])  # 1.014962406233101
 
通过matplotlib画出图像，
 
# 根据数据画出对应的图像
def plot(X, Y, theta):
    import matplotlib.pyplot as plt
    ax = plt.subplot(111)  # 这是我改的
    ax.scatter(X, Y, s=30, c="red", marker="s")
    plt.xlabel("X")
    plt.ylabel("Y")
    x = arange(0, 21, 0.2)  # x的范围
    y = theta[0] + theta[1]*x
    ax.plot(x, y)
    plt.show()


plot(X1, Y, optimal)
 
所拟合出的直线如下
 
 全部代码如下，大家有兴趣的可以复制下来跑一下看一下结果：
 
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# @Time    : 2019/1/21 21:06
# @Author  : Arrow and Bullet
# @FileName: gradient_descent.py
# @Software: PyCharm
# @Blog    ：https://blog.csdn.net/qq_41800366

from numpy import *

# 数据集大小 即20个数据点
m = 20
# x的坐标以及对应的矩阵
X0 = ones((m, 1))  # 生成一个m行1列的向量，也就是x0，全是1
X1 = arange(1, m+1).reshape(m, 1)  # 生成一个m行1列的向量，也就是x1，从1到m
X = hstack((X0, X1))  # 按照列堆叠形成数组，其实就是样本数据
# 对应的y坐标
Y = array([
    3, 4, 5, 5, 2, 4, 7, 8, 11, 8, 12,
    11, 13, 13, 16, 17, 18, 17, 19, 21
]).reshape(m, 1)
# 学习率
alpha = 0.01


# 定义代价函数
def cost_function(theta, X, Y):
    diff = dot(X, theta) - Y  # dot() 数组需要像矩阵那样相乘，就需要用到dot()
    return (1/(2*m)) * dot(diff.transpose(), diff)


# 定义代价函数对应的梯度函数
def gradient_function(theta, X, Y):
    diff = dot(X, theta) - Y
    return (1/m) * dot(X.transpose(), diff)


# 梯度下降迭代
def gradient_descent(X, Y, alpha):
    theta = array([1, 1]).reshape(2, 1)
    gradient = gradient_function(theta, X, Y)
    while not all(abs(gradient) <= 1e-5):
        theta = theta - alpha * gradient
        gradient = gradient_function(theta, X, Y)
    return theta


optimal = gradient_descent(X, Y, alpha)
print('optimal:', optimal)
print('cost function:', cost_function(optimal, X, Y)[0][0])


# 根据数据画出对应的图像
def plot(X, Y, theta):
    import matplotlib.pyplot as plt
    ax = plt.subplot(111)  # 这是我改的
    ax.scatter(X, Y, s=30, c="red", marker="s")
    plt.xlabel("X")
    plt.ylabel("Y")
    x = arange(0, 21, 0.2)  # x的范围
    y = theta[0] + theta[1]*x
    ax.plot(x, y)
    plt.show()


plot(X1, Y, optimal)
 
5. 小结
 
至此，就基本介绍完了梯度下降法的基本思想和算法流程，并且用python实现了一个简单的梯度下降算法拟合直线的案例！
 最后，我们回到文章开头所提出的场景假设:
 这个下山的人实际上就代表了反向传播算法，下山的路径其实就代表着算法中一直在寻找的参数Θ，山上当前点的最陡峭的方向实际上就是代价函数在这一点的梯度方向，场景中观测最陡峭方向所用的工具就是微分 。在下一次观测之前的时间就是有我们算法中的学习率α所定义的。
 可以看到场景假设和梯度下降算法很好的完成了对应！
 
本文部分内容来自一位前辈，非常感谢分享！谢谢！

目录
 
机器学习
 
机器学习的步骤
 
01  线性回归
 
02 逻辑回归
 
03 线性判别分析
 
04 分类和回归树
 
05 朴素贝叶斯
 
06 K近邻
 
07 学习矢量量化
 
08 支持向量机
 
09 bagging和随机森林
 
10 Boosting和AdaBoost
 
 每文一语
 

机器学习
 
机器学习是一门多领域交叉学科，涉及概率论、统计学、逼近论、凸分析、算法复杂度理论等多门学科。专门研究计算机怎样模拟或实现人类的学习行为，以获取新的知识或技能，重新组织已有的知识结构使之不断改善自身的性能。它是人工智能的基础，更是我们现在社会进步的源泉。
 
 
随着社会的进步和发展，我们在科技领域不断的创新，当人类的第一台计算机诞生之后，技术的迭代就已经被装上了风火轮了。我们希望计算机可以帮助我们计算我们人类无法涉及到的领域，但是野心永远是人类进化的动力，我们还希望我们的机器可以帮助我们解决我们的工作，那么机器学习就应运而生了。
 
 
 
 
人工智能是追求目标，机器学习是实现手段，深度学习是其中一种方法
 
机器学习的步骤
 
作为一个初学者，机器学习需要掌握怎样的技术呢？首先必须要有一门熟练的编程语言
 
Python，Java，R语言.....其实Python主要在一些大数据集模型背后占有强大的优势，而R语言在科研统计比较的吃香，因为R语言拥有很多个第三方程序包，利用少量简洁的代码就可以解决我们的科研工作。
 
 
1. 选择一个合适的模型，这通常需要依据实际问题而定，针对不同的问题和任务需要选取恰当的模型，模型就是一组函数的集合。
 2、判断一个函数的好坏，这需要确定一个衡量标准，也就是我们通常说的损失函数（Loss Function），损失函数的确定也需要依据具体问题而定，如回归问题一般采用欧式距离，分类问题一般采用交叉熵代价函数。
 3、找出“最好”的函数，如何从众多函数中最快的找出“最好”的那一个，这一步是最大的难点，做到又快又准往往不是一件容易的事情。常用的方法有梯度下降算法，最小二乘法等和其他一些技巧（tricks）。
 
这就是为什么我们说机器学习，底层基础是数学理论，其他的应该在编程上面下功夫
 
差不多认识了我们机器学习，接下来我们就开始从机器学习最常见的10大算法入门，介绍它们的概念知识，最后我们将开启机器学习的大门，详细记录我们学习过程中的点点滴滴！
 
 
 
 
在机器学习领域，有种说法叫做“世上没有免费的午餐”，简而言之，它是指没有任何一种算法能在每个问题上都能有最好的效果，这个理论在监督学习方面体现得尤为重要。
 
举个例子来说，你不能说神经网络永远比决策树好，反之亦然。模型运行被许多因素左右，例如数据集的大小和结构。
 
因此，你应该根据你的问题尝试许多不同的算法，同时使用数据测试集来评估性能并选出最优项。
 
当然，你尝试的算法必须和你的问题相切合，其中的门道便是机器学习的主要任务。打个比方，如果你想打扫房子，你可能会用到吸尘器、扫帚或者拖把，但你肯定不会拿把铲子开始挖坑吧。这个道理很多人都懂，哈哈哈。
 
01  线性回归
 
线性回归可能是统计学和机器学习中最知名和最易理解的算法之一。
 
由于预测建模主要关注最小化模型的误差，或者以可解释性为代价来做出最准确的预测。 我们会从许多不同领域借用、重用和盗用算法，其中涉及一些统计学知识。
 
线性回归用一个等式表示，通过找到输入变量的特定权重（B），来描述输入变量（x）与输出变量（y）之间的线性关系。
 
 
Linear Regression
 
 
举例：y = B0 + B1 * x
 
给定输入x，我们将预测y，线性回归学习算法的目标是找到系数B0和B1的值。
 
可以使用不同的技术从数据中学习线性回归模型，例如用于普通最小二乘和梯度下降优化的线性代数解。
 
线性回归已经存在了200多年，并且已经进行了广泛的研究。 如果可能的话，使用这种技术时的一些经验法则是去除非常相似（相关）的变量并从数据中移除噪声。 这是一种快速简单的技术和良好的第一种算法。
 
02 逻辑回归
 
逻辑回归是机器学习从统计领域借鉴的另一种技术。 这是二分类问题的专用方法（两个类值的问题）。
 
逻辑回归与线性回归类似，这是因为两者的目标都是找出每个输入变量的权重值。 与线性回归不同的是，输出的预测值得使用称为逻辑函数的非线性函数进行变换。
 
逻辑函数看起来像一个大S，并能将任何值转换为0到1的范围内。这很有用，因为我们可以将相应规则应用于逻辑函数的输出上，把值分类为0和1（例如，如果IF小于0.5，那么 输出1）并预测类别值。
 
 
Logistic Regression
 
由于模型的特有学习方式，通过逻辑回归所做的预测也可以用于计算属于类0或类1的概率。这对于需要给出许多基本原理的问题十分有用。
 
与线性回归一样，当你移除与输出变量无关的属性以及彼此非常相似（相关）的属性时，逻辑回归确实会更好。 这是一个快速学习和有效处理二元分类问题的模型。
 
03 线性判别分析
 
传统的逻辑回归仅限于二分类问题。 如果你有两个以上的类，那么线性判别分析算法（Linear Discriminant Analysis，简称LDA）是首选的线性分类技术。
 
LDA的表示非常简单。 它由你的数据的统计属性组成，根据每个类别进行计算。 对于单个输入变量，这包括：
 
 
每类的平均值。
 
 
跨所有类别计算的方差。
 
 
Linear Discriminant Analysis
 
LDA通过计算每个类的判别值并对具有最大值的类进行预测来进行。该技术假定数据具有高斯分布（钟形曲线），因此最好先手动从数据中移除异常值。这是分类预测建模问题中的一种简单而强大的方法。
 
04 分类和回归树
 
决策树是机器学习的一种重要算法。
 
决策树模型可用二叉树表示。对，就是来自算法和数据结构的二叉树，没什么特别。 每个节点代表单个输入变量（x）和该变量上的左右孩子（假定变量是数字）。
 
 
Decision Tree
 
树的叶节点包含用于进行预测的输出变量（y）。 预测是通过遍历树进行的，当达到某一叶节点时停止，并输出该叶节点的类值。
 
决策树学习速度快，预测速度快。 对于许多问题也经常预测准确，并且你不需要为数据做任何特殊准备。
 
05 朴素贝叶斯
 
朴素贝叶斯是一种简单但极为强大的预测建模算法。
 
该模型由两种类型的概率组成，可以直接从你的训练数据中计算出来：1）每个类别的概率; 2）给定的每个x值的类别的条件概率。 一旦计算出来，概率模型就可以用于使用贝叶斯定理对新数据进行预测。 当你的数据是数值时，通常假设高斯分布（钟形曲线），以便可以轻松估计这些概率。
 
 
Bayes Theorem
 
朴素贝叶斯被称为朴素的原因，在于它假设每个输入变量是独立的。 这是一个强硬的假设，对于真实数据来说是不切实际的，但该技术对于大范围内的复杂问题仍非常有效。
 
06 K近邻
 
KNN算法非常简单而且非常有效。KNN的模型用整个训练数据集表示。 是不是特简单？
 
通过搜索整个训练集内K个最相似的实例（邻居），并对这些K个实例的输出变量进行汇总，来预测新的数据点。 对于回归问题，新的点可能是平均输出变量，对于分类问题，新的点可能是众数类别值。
 
成功的诀窍在于如何确定数据实例之间的相似性。如果你的属性都是相同的比例，最简单的方法就是使用欧几里德距离，它可以根据每个输入变量之间的差直接计算。
 
 
K-Nearest Neighbors
 
KNN可能需要大量的内存或空间来存储所有的数据，但只有在需要预测时才会执行计算（或学习）。 你还可以随时更新和管理你的训练集，以保持预测的准确性。
 
距离或紧密度的概念可能会在高维环境（大量输入变量）下崩溃，这会对算法造成负面影响。这类事件被称为维度诅咒。它也暗示了你应该只使用那些与预测输出变量最相关的输入变量。
 
07 学习矢量量化
 
K-近邻的缺点是你需要维持整个训练数据集。 学习矢量量化算法（或简称LVQ）是一种人工神经网络算法，允许你挂起任意个训练实例并准确学习他们。
 
 
Learning Vector Quantization
 
LVQ用codebook向量的集合表示。开始时随机选择向量，然后多次迭代，适应训练数据集。 在学习之后，codebook向量可以像K-近邻那样用来预测。 通过计算每个codebook向量与新数据实例之间的距离来找到最相似的邻居（最佳匹配），然后返回最佳匹配单元的类别值或在回归情况下的实际值作为预测。 如果你把数据限制在相同范围（如0到1之间），则可以获得最佳结果。
 
如果你发现KNN在您的数据集上给出了很好的结果，请尝试使用LVQ来减少存储整个训练数据集的内存要求。
 
08 支持向量机
 
支持向量机也许是最受欢迎和讨论的机器学习算法之一。
 
超平面是分割输入变量空间的线。 在SVM中，会选出一个超平面以将输入变量空间中的点按其类别（0类或1类）进行分离。在二维空间中可以将其视为一条线，所有的输入点都可以被这条线完全分开。SVM学习算法就是要找到能让超平面对类别有最佳分离的系数。
 
 
Support Vector Machine
 
超平面和最近的数据点之间的距离被称为边界，有最大边界的超平面是最佳之选。同时，只有这些离得近的数据点才和超平面的定义和分类器的构造有关，这些点被称为支持向量，他们支持或定义超平面。在具体实践中，我们会用到优化算法来找到能最大化边界的系数值。
 
SVM可能是最强大的即用分类器之一，在你的数据集上值得一试。
 
09 bagging和随机森林
 
随机森林是最流行和最强大的机器学习算法之一。 它是一种被称为Bootstrap Aggregation或Bagging的集成机器学习算法。
 
bootstrap是一种强大的统计方法，用于从数据样本中估计某一数量，例如平均值。 它会抽取大量样本数据，计算平均值，然后平均所有平均值，以便更准确地估算真实平均值。
 
在bagging中用到了相同的方法，但最常用到的是决策树，而不是估计整个统计模型。它会训练数据进行多重抽样，然后为每个数据样本构建模型。当你需要对新数据进行预测时，每个模型都会进行预测，并对预测结果进行平均，以更好地估计真实的输出值。
 
 
Random Forest
 
随机森林是对决策树的一种调整，相对于选择最佳分割点，随机森林通过引入随机性来实现次优分割。
 
因此，为每个数据样本创建的模型之间的差异性会更大，但就自身意义来说依然准确无误。结合预测结果可以更好地估计正确的潜在输出值。
 
如果你使用高方差算法（如决策树）获得良好结果，那么加上这个算法后效果会更好。
 
10 Boosting和AdaBoost
 
Boosting是一种从一些弱分类器中创建一个强分类器的集成技术。 它先由训练数据构建一个模型，然后创建第二个模型来尝试纠正第一个模型的错误。 不断添加模型，直到训练集完美预测或已经添加到数量上限。
 
AdaBoost是为二分类开发的第一个真正成功的Boosting算法，同时也是理解Boosting的最佳起点。 目前基于AdaBoost而构建的算法中最著名的就是随机梯度boosting。
 
 
AdaBoost
 
AdaBoost常与短决策树一起使用。 在创建第一棵树之后，每个训练实例在树上的性能都决定了下一棵树需要在这个训练实例上投入多少关注。难以预测的训练数据会被赋予更多的权重，而易于预测的实例被赋予更少的权重。 模型按顺序依次创建，每个模型的更新都会影响序列中下一棵树的学习效果。在建完所有树之后，算法对新数据进行预测，并且通过训练数据的准确程度来加权每棵树的性能。
 
 
数据的大小，质量和性质; 
 
 
可用的计算时间; 
 
 
任务的紧迫性; 
 
 
你想要对数据做什么。
 
是我们选择那种机器学习算法的关键
 
scikit-learn作为一个丰富的python机器学习库，实现了绝大多数机器学习的算法，有相当多的人在使用，于是我这里很无耻地把machine learning cheat sheet for sklearn搬过来了，原文可以看这里。哈哈，既然讲机器学习，我们就用机器学习的语言来解释一下，这是针对实际应用场景的各种条件限制，对scikit-learn里完成的算法构建的一颗决策树，每一组条件都是对应一条路径，能找到相对较为合适的一些解决方法，具体如下：
 
 每文一语
 
 
 
既然选择，就像当时一样，不问未来
 

英文原文《The Random Forest Algorithm》
专知 编译《机器学习基础算法之随机森林》
【导读】在当今深度学习如此火热的背景下，其他基础的机器学习算法显得黯然失色，但是我们不得不承认深度学习并不能完全取代其他机器学习算法，诸如随机森林之类的算法凭借其灵活、易于使用、具有良好的可解释性等优势在工业界以获得良好的应用。本文主要介绍随机森林的工作原理、特征重要性、优势和劣势、使用例子等，让我们一起了解一下这个简单易用的机器学习基础算法吧。



The Random Forest Algorithm
随机森林算法

随机森林是一种灵活且易于使用的机器学习算法，即使没有进行超参数调整，也可以在大多数情况下产生很好的结果。 它也是最常用的算法之一，因为它很简单，并且可以用于分类和回归任务。 在这篇文章中，您将学习如何使用随机森林算法以及其他一些关于它的重要的事情。


工作机制
随机森林是一个监督学习算法。 就像你已经看到它的名字一样，它创建了一个森林，并以某种方式使它成为随机的。 它构建的“森林”是决策树的集合体，大部分时间都是用“装袋（bagging）”方法训练的。 装袋方法的总体思路是，多个模型通过组合可以显著的比单个模型要好, 可以用来增加整体效果。
简单来说：随机森林建立多个决策树并将它们合并在一起以获得更准确和稳定的预测。
随机森林的一大优势是，它可以应用于分类和回归问题，目前大多数机器学习系统都是围绕这两个问题进行的。 我将在分类问题中讨论随机森林，因为分类问题有时被认为是机器学习的基石。 在下面你可以看到两棵树构成随机森林的样子：



除了少数例外，随机森林分类器具有决策树分类器的所有超参数以及bagging分类器的所有超参数，这些超参数用以控制集合本身。与其构建bagging分类器并将其传递给决策树分类器，您可以仅使用随机森林分类器，这更加方便优化。请注意，还有一个用于回归任务的随机森林回归器。
随机森林算法在树木生长时会给模型带来额外的随机性。不是在分割节点时搜索最佳特征，而是在特征的随机子集中搜索最佳特征。这个过程产生了广泛的多样性，这通常会得到更好的模型。
因此，当您在随机森林中构建一棵树时，仅考虑用于分割节点的随机子集。您甚至可以通过在每个特征上使用随机阈值来使树更随机，而不是像正常的决策树一样搜索最佳阈值。



类比现实生活
想象一下，一个名叫安德鲁的人，想要决定在一年的假期旅行中他应该去哪些地方。他询问认识他的人的建议。首先，他去找一位朋友，他问安德鲁他过去去过的地方，如果他喜欢或不喜欢。基于这些答案，他会给安德鲁一些建议。
这是一种典型的决策树算法方法。安德鲁斯的朋友通过使用安德鲁的答案创建了规则来指导应该推荐什么的决定。
之后，安德鲁开始要求越来越多的朋友给他建议，他们再次问他不同的问题，他们可以从中得到一些建议。然后他选择推荐给他的地方，这是典型的随机森林算法方法。



特征重要性
随机森林算法的另一个优点是可以很容易地衡量每个特征对预测的相对重要性。 Sklearn提供了一个很好的工具，通过查看有多少使用该特征的树节点（这些树节点使用该特征减少了森林中所有树木的杂质），从而衡量了特征的重要性。它在训练后为每个特征自动计算特征重要性分数并对结果进行归一化，以使所有重要性的总和等于1。
如果你不知道决策树如何工作，如果你不知道叶子或节点是什么，这里有一个来自维基百科的很好的描述：在决策树中，每个内部节点代表一个属性的“测试”（例如每个分支代表测试的结果，并且每个叶节点代表一个类标签（在计算所有属性之后作出的决定），没有孩子的节点是叶子。
通过查看特征的重要性，您可以决定您可能要放弃哪些特征，因为它们对预测过程没有足够贡献或没有贡献。这很重要，因为机器学习的一般规则是您拥有的特征越多，您的模型就越容易过拟合，反之亦然。
下面你可以看到一个表格和一个可视化图表，显示了13个特征的重要性，我在我的监督分类项目中使用了kaggle上著名的Titanic数据集。
https://www.kaggle.com/niklasdonges/end-to-end-project-with-python





决策树和随机森林之间的区别：
就像我之前提到的，随机森林是决策树的集合，但是有一些区别。
如果您将具有特征和标签的训练数据集输入到决策树中，它将制定一些规则集，这些规则被用于预测。
例如，如果您想预测某人是否会点击在线广告，则可以收集该广告的过去点击人员以及描述其决定的某些功能。如果将特征和标签放入决策树中，它将生成节点和一些规则。然后你可以预测广告是否会被点击。当决策树生成节点和规则时，它通常使用信息增益和基尼指数计算。相比之下，随机森林是随机的。
另一个区别是“深度”决策树可能会因过拟合而受到影响。随机森林可防止大部分过拟合，方法是创建随机的特征子集并使用这些子集构建较小的子树。之后，它组合这些子树。请注意，这也会使计算速度变慢，这取决于随机森林构建的子树数量。


重要的超参数
随机森林中的参数要么用来增加模型的预测能力，要么使模型更快。我将在这里讨论sklearns内置的随机森林函数的超参数。

1.提高预测能力
首先，存在“n_estimators”超参数，它是控制随机森林中树的数量。一般来说，树数量越多，性能越好，预测越稳定，但也会减慢计算速度。
另一个重要的超参数是“max_features”，它是允许随机森林在单个树中尝试的最大特征数量。 Sklearn提供了几个选项，在他们的文档中有描述。
http://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestClassifier.html
我们将讨论在速度方面的一个重要的超参数是“min_sample_leaf”。正如其名称所述，这决定了叶子的数量。
2.提高模型速度
“n_jobs”超参数告诉引擎允许使用多少个处理器。如果它的值为1，它只能使用一个处理器。值“-1”表示没有限制。
“random_state”使模型的输出可复制。当它具有一个明确的random_state值并且它已经被赋予了相同的参数和相同的训练数据时，该模型将始终产生相同的结果。
最后，还有一个“oob_score”（也称为oob采样），它是一种随机森林交叉验证方法。在这个抽样中，大约三分之一的数据不用于训练模型，可用于评估其性能。这些样品被称为袋外样品。它与一次性交叉验证方法非常相似，但几乎没有附加的计算负担。



优缺点
就像我之前提到的那样，随机森林的一个优点是它可以用于回归和分类任务，并且很容易查看它分配给输入特征的相对重要性。
随机森林也被认为是一个非常方便和易于使用的算法，因为它是默认的超参数通常会产生一个很好的预测结果。超参数的数量也不是那么高，而且它们很直观易懂。
机器学习中的一个重大问题是过度拟合，但大多数情况下，对于随机森林分类器来说并不容易出现过拟合。那是因为如果森林中有足够的树，分类器将不会过拟合。
随机森林的主要限制是大量的树会使算法变慢不能应对实时预测场景。一般来说，这些算法训练速度很快，但一旦训练完成就很难创建预测。更准确的预测需要更多的树，导致模型更慢。在大多数现实世界的应用中，随机森林算法速度可以满足要求，但在时间性能要求更高的场景中，其他方法可能更受欢迎。
当然，随机森林是一个预测性建模工具，而不是一个描述性工具。这意味着，如果您正在寻找关于数据中关系的描述，其他方法将是首选。


例子
随机森林算法被用于很多不同的领域，如银行，股票市场，医药和电子商务。在银行业中，它被用来检测那些比其他人更频繁地使用银行服务的客户，并及时偿还债务。在这个领域，它也被用来检测欺诈客户，即谁想诈骗银行。在金融领域，它用于确定未来股票的行为。在医疗保健领域，它用于识别医学成分的正确组合，并分析患者的病史以识别疾病。最后，在电子商务中，随机森林被用来确定客户是否真的喜欢这个产品。




总结
随机森林是一个很好的算法，可以在模型开发初期了解它是如何执行的，并且由于其简单性，很难构建“坏”随机森林。如果您需要在短时间内开发模型，该算法也是一个很好的选择。最重要的是，它可以只是您的特征的重要性。
随机森林在性能方面也很难被击败。当然，你可能总能找到一个性能更好的模型，比如神经网络，但是这些模型通常需要更多的时间来开发。最重要的是，它们可以处理许多不同的特征类型，如二元的，数字的。
总的来说，随机森林是一个（基本上）快速，简单和灵活的工具，尽管它有其局限性。