梯度下降

最近打算学习机器学习，首先遇到的知识点就是梯度下降，我从网上查看了一些博客，在这里把有用地内容整理一下，作为备忘。

  首先，梯度下降法适用于线性可分的数据，例子可以参考斯坦福大学机器学习里面第一节课中的房屋价格的问题。

我们用一个式子来拟合训练集，在这个例子中，只有两个影响因素，那么不同地参数会分配不同地权重，我们得到的线性方程如下所示

 其中，我们假设x0=1，那么可以得到

我们后续的目标是对参数前面的权重进行调整，直至得到一个较为准确地预测为止。

梯度下降方法中，以训练集作为样本对上述方程进行训练，每次会计算训练误差，然后会权重进行调整。一般会采用以下的式子

这个方程地好处是在于能够较好地反应偏差地情况，以及求偏微分也较为容易。推倒过程可以参考《机器学习》中地证明部分。

对于第j个参数地权重，有如下地推导公式

其中m 为训练集地大小，也就说每调整一个参数地权重就需要循环整个m个训练集，而当训练集地规模比较大时，这个算法地效率就不是很高了。a为学习速率，是人为设置地参数，如果取值很大，可能会错过最佳的解；同样也不会取地过小，有可能经过很久才会收敛。

当训练集非常大时，会用到下面这种方式来进行训练，用样也是在不断调整权值，但是基本单位是其中的一个样本，一次循环中，对n个参数的权重进行调整。这样相对于上一种，算法复杂度就下来了，同样也能够达到训练地目的。

梯度下降法常用地有两种类别：1.批量梯度下降 2 随机梯度下降

二者地区别在于一个循环地单元是一个参数的权重，一个是训练地样本。在训练集不是很大地情况下，二者差别不大。随机梯度适合处理大量地训练集。

参考书中有写到，随机地方法更有可能得到最优解，有待证明。

放上在网上找到地例子以供参考，下面地代码我看懂了，有机会会实际敲一遍加深理解。

批梯度下降：

package algorithm;


/**
 * 批量梯度下降
 * 
 * @author Administrator
 *
 */
public class BatchGradient {
public void batchGradientDescent() {
double inputDataMatrix[][] = { { 1, 4 }, { 2, 5 }, { 5, 1 }, { 4, 2 } }; // X输入
double expectResult[] = { 19, 26, 19, 20 }; // 期望输出值
double w[] = { 2, 6 }; // 权重参数 因为这里只涉及到两个变量 ，即X为两列输入
double learningRate = 0.01;
double loss = 100; // 损失值
for (int i = 0; i < 500 && loss > 0.0001; i++) {
double err_sum = 0;
for (int j = 0; j < 4; j++) { //这里要循环所有地变量，因此 数量过大不建议这个方法
double h = 0;
for (int k = 0; k < 2; k++) {
h = h + inputDataMatrix[j][k] * w[k];
}


err_sum = expectResult[j] - h;


for (int k = 0; k < 2; k++) {
w[k] = w[k] + learningRate * err_sum
* inputDataMatrix[j][k]; // 权值每次改变的幅度，这个公式是通过梯度下降得到的
}


}
System.out
.println("此时的w权值为：" + "w0:" + w[0] + "---" + "w1:" + w[1]);
double loss_sum = 0;
for (int j = 0; j < 4; j++) {
double sum = 0;
for (int k = 0; k < 2; k++) {
sum = sum + inputDataMatrix[j][k] * w[k];
}


loss_sum += (expectResult[j] - sum) * (expectResult[j] - sum);
}
System.out.println("loss:" + loss_sum);


}
}


public static void main(String[] args) {
BatchGradient bg = new BatchGradient();
bg.batchGradientDescent();


}
}

随机梯度下降

package algorithm;


public class StochasticGradientDescent {
public void StochasticGradient() {
double inputDataMatrix[][] = { { 1, 4 }, { 2, 5 }, { 5, 1 }, { 4, 2 } }; // X输入
double expectResult[] = { 19, 26, 19, 20 }; // 期望输出值
double w[] = { 4, 6 }; // 权重参数 因为这里只涉及到两个变量 ，即X为两列输入
double learningRate = 0.01;
double loss = 100; // 损失值
for (int i = 0; i < 500 && loss > 0.0001; i++) {
double err_sum = 0;
int j = i % 4;//不停地测试。。
double h = 0;
for (int k = 0; k < 2; k++) {
h = h + inputDataMatrix[j][k] * w[k];
}


err_sum = expectResult[j] - h;


for (int k = 0; k < 2; k++) {
w[k] = w[k] + learningRate * err_sum * inputDataMatrix[j][k]; // 权值每次改变的幅度，这个公式是通过梯度下降得到的
}


System.out
.println("此时的w权值为：" + "w0:" + w[0] + "---" + "w1:" + w[1]);
double loss_sum = 0;
for (int g = 0; g < 4; g++) {
double sum = 0;
for (int k = 0; k < 2; k++) {
sum = sum + inputDataMatrix[g][k] * w[k];
}


loss_sum += (expectResult[g] - sum) * (expectResult[g] - sum);
}
System.out.println("loss:" + loss_sum);


}
}


public static void main(String[] args) {
StochasticGradientDescent sgd = new StochasticGradientDescent();
sgd.StochasticGradient();
}


}

由于训练集不是很大，随机梯度中需要重复地不断使用有限地几个训练集去训练目标函数，这个是需要稍微注意一下的点。

ps.貌似在ubuntu下截图都挂了,,之前的图也找不到了，各位看官去到《机器学习》这本书里能够找到对应的公式我就不再贴到这篇文章中了。

下面放上自己写的梯度下降，当然还是按照上面的例子的思路去实现的。

package neuroNetwork;


public class StochasticGradient {
double inputDataMatrix[][] = { { 1, 4 }, { 2, 5 }, { 5, 1 }, { 4, 2 } }; // X输入
double expectResult[] = { 19, 26, 19, 20 }; // 期望输出值
double w[] = { 4, 6 }; // 权重参数 因为这里只涉及到两个变量 ，即X为两列输入
double learningRate = 0.01;
double loss = 100; // 损失值


public void method() {
// 随机梯度
for (int i = 0; i < 500; i++) {
// 先计算误差


int j = i % 4;


double tempResult = 0;
for (int k = 0; k < 2; k++) {
// 对每个参数的权值进行调整
tempResult += inputDataMatrix[j][k] * w[k];


}


double delta = 0;
delta = -(tempResult - expectResult[j]);// 第j个变量的期望值


// 更新w[i]


for (int k = 0; k < 2; k++) {


w[k] = w[k] + learningRate * delta * inputDataMatrix[j][k];


}


System.out.println("参数权重： w[0]= " + w[0] + "  w[1]= " + w[1]);


}


}
}