典型梯度下降法

这几天在看《统计学习方法》这本书，发现 梯度下降法 在 感知机 等机器学习算法中有很重要的应用，所以就特别查了些资料。 　　

   一.介绍

      梯度下降法（gradient descent）是求解无约束最优化问题的一种常用方法，有实现简单的优点。梯度下降法是迭代算法，每一步需要求解目标函数的梯度向量。

 

   二.应用场景

     1.给定许多组数据（x_i, y_i），x_i （向量）为输入，y_i为输出。设计一个线性函数y=h（x）去拟合这些数据。

     2.感知机：感知机（perceptron）为二类分类的线性分类模型。 输入为实例的特征向量，输出为实例的类别， 取+1 和 -1 二值。

 

     下面分别对这两种应用场景进行分析。

     1.对于第一种场景:

        既然是线性函数，在此不妨设为 h(x) = w0*x0 + w1*x1。

        此时我们遇到的问题就是如何确定w0和w1这两个参数，即w=（w0，w1）这个向量。

        既然是拟合，则拟合效果可以用平方损失函数：E(w)=∑ [ h(x)- y ] ^2 / 2 来衡量。

        其中w是权重二维向量，x是输入二维向量，x和y都是训练集的数据，即已知。

        至于后面除于2只是为了之后的推导过程中对E求导时候可以消除系数，暂时可以不管。

        因此该问题变成了求E(w)最小值的无约束最优化问题

      2.对于第二种场景:

        假设输入空间(特征向量)为x，输出空间为y = {+1, -1},由输入空间到输出空间的如下函数

                        f(x) = sign(w · x + b)       w∈Rⁿ     其中 w 叫做权值或者权值向量, b叫做偏振。w · x 表示向量w和x的点积

         感知机sign(w · x + b)的损失函数为  L(w, b) = -∑y_i(w · x_i + b)              x ∈M, M为误分类点集合。

        因此该问题变成了求L(w, b)最小值的无约束最优化问题

 

   三.梯度下降方法

       梯度其实就是高数求导方法，对E这个公式针对每个维数（w0，w1）求偏导后的向量▽E(w)=（∂E/∂w0,∂E/∂w1）

       1. 对于第一种场景

          对E这个公式针对每个维数（w0，w1）求偏导后的向量▽E(w)=（∂E/∂w0,∂E/∂w1）

          梯度为最陡峭上升的方向，对应的梯度下降的训练法则为： w=w-η▽E(w)     这里的η代表学习速率，决定梯度下降搜索中的步长 。

          上式的w是向量，即可用将该式写成分量形式为:wi=wi-η*∂E/∂wi

          现在关键就使计算∂E/∂wi：

          推导过程很简单，书上写的很详细，这里只记录结论(其实就是对目标函数求导):

          ∂E/∂wi=∑（h(x)-y）*(x_i)

          这里的∑是对样本空间，即训练集进行一次遍历，耗费时间较大，可以使用梯度下降的随机近似：

       2. 对于第二种场景

           感知机学习算法是误分类驱动的，具体采用随机梯度下降方法

           ▽wL(w, b) =   -∑y_ix_i       

           ▽_bL(w, b) =   -∑y_i

           随机选取一个误分类点（x_i,   y_i), 对w, b进行更新：

            w  <——   w - η * (-y_ix_i)

            b  <——    b - η * (-y_i)                 式中η(0 < η <= 1)是步长，在统计学习中又称为学习率（learning rate）

  

   四.随机梯度下降的随机近似：

      既然是随机近似，则顾名思义，肯定是用近似方法来改善梯度下降时候的时间复杂度问题。

      正如上所说，在∂E/∂wi=∑（h(x)-y）*(xi) 的时候∑耗费了大量的时间，特别是在训练集庞大的时候。

      所以肯定有人会猜想，如果把求和去掉如何，即变为∂E/∂wi=（h(x)-y）*(xi)。

      幸运的是，猜想成立了。

      只是要注意一下标准的梯度下降和随机梯度下降的区别：

　　　　1.标准下降时在权值更新前汇总所有样例得到的标准梯度，随机下降则是通过考察每次训练实例来更新。

　　　　2.对于步长 η的取值，标准梯度下降的η比随机梯度下降的大。

　　　　因为标准梯度下降的是使用准确的梯度，理直气壮地走，随机梯度下降使用的是近似的梯度，就得小心翼翼地走，怕一不小心误入歧途南辕北辙了。

　　　　3.当E（w）有多个局部极小值时，随机梯度反而更可能避免进入局部极小值中。

 四.代码及实例：

  1. 对于第一种场景（批量梯度下降）：

        第一步：对（x[0,0]，x1[0,1]），(x[1,0],x[1,1]).........(x[n,0],x[n,1])进行梯度计算之后得出W0、W1,

        第二步：对函数进行损失衡量（误差达到标准就退出，不达到标准就进行第三步）

        第三步：对（x[0,0]，x1[0,1]），(x[1,0],x[1,1]).........(x[n,0],x[n,1])进行梯度计算之后得出W0、W1,

        第四步：对函数进行损失衡量（误差达到标准就退出，不达到标准就进行第五步）

        。。。。。知道达到误差标准就退出

#include "stdio.h"

int main(void)
{
        float matrix[4][2]={{1,4},{2,5},{5,1},{4,2}};
        float result[4]={19,26,19,20};
        float theta[2]={2,5};                   //initialized theta {2,5}, we use the algorithm to get {3,4} to fit the model
        float learning_rate = 0.01;
        float loss = 1000.0;                    //set a loss big enough

        for(int i = 0;i<100&&loss>0.0001;++i)
        {
                float error_sum = 0.0;
                for(int j = 0;j<4;++j)
                {
                        float h = 0.0;
                        for(int k=0;k<2;++k)
                        {
                                h += matrix[j][k]*theta[k];
                        }
                        error_sum = result[j]-h;
                        for(int k=0;k<2;++k)
                        {
                                theta[k] += learning_rate*(error_sum)*matrix[j][k];
                        }
                }
                printf("*************************************\n");
                printf("theta now: %f,%f\n",theta[0],theta[1]);
                loss = 0.0;
                for(int j = 0;j<4;++j)
                {
                        float sum=0.0;
                        for(int k = 0;k<2;++k)
                        {


                                sum += matrix[j][k]*theta[k];
                        }
                        loss += (sum-result[j])*(sum-result[j]);
                }
                printf("loss  now: %f\n",loss);
        }
        return 0;
}

2. 对于第一种场景（随机梯度下降）：

        第一步：对(x[0,0])进行梯度计算之后得出初始W0、W1,

        第二步：对函数进行损失衡量（误差达到标准就退出，不达到标准就进行第三步）

        第三步：对(x[1,0],x[1,1])进行梯度计算之后得出新的W0、W1,

        第四步：对函数进行损失衡量（误差达到标准就退出，不达到标准就进行第五步）

        。。。。。

        第n步：对(x[n,0],x[n,1])进行梯度计算之后得出新的W0、W1,

        第n+1步：对函数进行损失衡量（误差达到标准就退出，不达到标准就进行第n+2步）

        。。。知道达到误差标准就退出

 

/*
 * 随机梯度下降实验：
 * 训练集输入为矩阵：
 * 1,4
 * 2,5
 * 5,1
 * 4,2
 * 输出结果为：
 * 19
 * 26
 * 19
 * 20
 * 需要参数为 w：
 * ？
 * ？
 *
 * 目标函数:y=w0*x0+w1*x1;
 *
 * */
#include<stdio.h>
#include <stdlib.h>
int main()
{
    double matrix[4][2]={{1,4},{2,5},{5,1},{4,2}};
    double result[4]={19,26,19,20};
    double w[2]={0,0};//初始为零向量
    double loss=10.0;
    const double n = 0.01;        //步长 
    for(int i=0;i<100&&loss>0.001;i++)
    {
        double error_sum=0;
        int j=i%4;
        { //这里的作用就是隔离变量j而已，没特殊意义
            double h=0;
            for(int k=0;k<2;k++)
            {
                h+=matrix[j][k]*w[k];
            }
            error_sum = h - result[j];
            for(int k=0;k<2;k++)
            {
                w[k]-= n * (error_sum) * matrix[j][k];//这里是关键
            }
         }
        printf("%lf,%lf\n",w[0],w[1]);
        double loss=0;
        for(int j=0;j<4;j++)
        {
            double sum=0;
            for(int k=0;k<2;k++)
            {
                sum += matrix[j][k] * w[k];
        }
        loss += (sum - result[j]) * (sum-result[j]);
     }
        printf("%lf\n",loss);
    }

    system("pause");
    return 0;
}

 

 

 

3. 对于第二种场景

当x为一维时：

                     w_i =w_i+µy_ix_[i][0]

                     w_i =w_i+µy_ix_{[i][1]  µ:步长}

                     b = b+  µy_i      

当x为二维时：        

                            w_i =w_i+µy_ix_[i]

 

                                  _{b = b+  µyi} 

 

---

 

#include <iostream>
using namespace std;

class perceptron
{
public:
    perceptron() { w[0] = 1; w[1] = 1; b = 1; n = 1; }
    void Init(double (*x)[2],double *y);
    ~perceptron() {}

private:
    double w[2];
    double b;
    double n;
};

void perceptron::Init(double (*x)[2],double *y)
{
    do
    {
        int j=0;
        for ( j = 0; j<3; j++)
        {
            double test=0;
            test = y[j] * (w[0] * x[j][0] + w[1] * x[j][1] + b);
            if (y[j] * (w[0] * x[j][0] + w[1] * x[j][1] + b) <= 0)
                break;
        }
        if (j < 3)
        {
            for (int k = 0; k<2; k++)
                w[k] += n * y[j] * x[j][k];//这里是关键
            b += n * y[j];
        }
        else return;
        cout << "w0=" << w[0] << endl << "w[1]=" << w[1] << endl << "b=" << b<<endl;
    }
    while (true);
}

int main(int argc ,char argv[])
{
    perceptron wjy;
    double a[3][2] = { (3.0,3.0),(4.0,3.0),(1.0,1.0)};
    double y[4] = { 1, 1, -1 };
    wjy.Init(a,y);
    while (1);
    return 0;
}

 

转载：http://www.cnblogs.com/iamccme/archive/2013/05/14/3078418.html

参考：http://blog.csdn.net/pennyliang/article/details/6998517