用Numpy搭建神經網絡第二期：梯度下降法的實現
大數據文摘出品作者：蔣寶尚小夥伴們大家好呀~~用Numpy搭建神經網絡，我們已經來到第二期了。第一期文摘菌教大家如何用Numpy搭建一個簡單的神經網絡，完...
"
鑑於本篇文章有大量乾貨內容，建議大家先收藏再觀看，看到一半也不要退出，文末有驚喜哦。給大家分享一張可愛的圖片活躍一下心情就開始這篇文章吧。
"
鑑於本篇文章有大量乾貨內容，建議大家先收藏再觀看，看到一半也不要退出，文末有驚喜哦。給大家分享一張可愛的圖片活躍一下心情就開始這篇文章吧。
對於數據分析而言，我們總是極力找數學模型來描述數據發生的規律， 有的數據我們在二維空間就可以描述，有的數據則需要映射到更高維的空間。數據表現出來的分佈可能是完全離散的，也可能是聚集成堆的，那麼機器學習的任務就是讓計算機自己在數據中學習到數據的規律。那麼這個規律通常是可以用一些函數來描述，函數可能是線性的，也可能是非線性的，怎麼找到這些函數，是機器學習的首要問題。
本篇博客嘗試用梯度下降法，找到線性函數的參數，來擬合一個數據集。
假設我們有如下函數
"
鑑於本篇文章有大量乾貨內容，建議大家先收藏再觀看，看到一半也不要退出，文末有驚喜哦。給大家分享一張可愛的圖片活躍一下心情就開始這篇文章吧。
對於數據分析而言，我們總是極力找數學模型來描述數據發生的規律， 有的數據我們在二維空間就可以描述，有的數據則需要映射到更高維的空間。數據表現出來的分佈可能是完全離散的，也可能是聚集成堆的，那麼機器學習的任務就是讓計算機自己在數據中學習到數據的規律。那麼這個規律通常是可以用一些函數來描述，函數可能是線性的，也可能是非線性的，怎麼找到這些函數，是機器學習的首要問題。
本篇博客嘗試用梯度下降法，找到線性函數的參數，來擬合一個數據集。
假設我們有如下函數
，其中x是一個三個維度，
"
鑑於本篇文章有大量乾貨內容，建議大家先收藏再觀看，看到一半也不要退出，文末有驚喜哦。給大家分享一張可愛的圖片活躍一下心情就開始這篇文章吧。
對於數據分析而言，我們總是極力找數學模型來描述數據發生的規律， 有的數據我們在二維空間就可以描述，有的數據則需要映射到更高維的空間。數據表現出來的分佈可能是完全離散的，也可能是聚集成堆的，那麼機器學習的任務就是讓計算機自己在數據中學習到數據的規律。那麼這個規律通常是可以用一些函數來描述，函數可能是線性的，也可能是非線性的，怎麼找到這些函數，是機器學習的首要問題。
本篇博客嘗試用梯度下降法，找到線性函數的參數，來擬合一個數據集。
假設我們有如下函數
，其中x是一個三個維度，
寫一個java程序來，隨機產生100筆數據作為訓練集。
Random random = new Random();
double[] results = new double[100];
double[][] features = new double[100][3];
for (int i = 0; i < 100; i++) {
for (int j = 0; j < features[i].length; j++) {
features[i][j] = random.nextDouble();
}
results[i] = 3 * features[i][0] + 4 * features[i][1] + 5 * features[i][2] + 10;
}
上面的程序中results就是函數的值，features的第二維就是隨機產生的3個x。
有了訓練集，我們的任務就變成了如何求出3個各種的係數3、4、5，以及偏移量10，係數和偏移量可以取任意值，那麼我們就得到了一個函數集，任務轉化一下就變成了找出一個函數作用於訓練集之後，與真實值的誤差最小，如何評判誤差的大小呢？我們需要定義一個函數來評判，那麼給這個函數取一個名字，叫損失函數。這裡，損失函數定義為
"
鑑於本篇文章有大量乾貨內容，建議大家先收藏再觀看，看到一半也不要退出，文末有驚喜哦。給大家分享一張可愛的圖片活躍一下心情就開始這篇文章吧。
對於數據分析而言，我們總是極力找數學模型來描述數據發生的規律， 有的數據我們在二維空間就可以描述，有的數據則需要映射到更高維的空間。數據表現出來的分佈可能是完全離散的，也可能是聚集成堆的，那麼機器學習的任務就是讓計算機自己在數據中學習到數據的規律。那麼這個規律通常是可以用一些函數來描述，函數可能是線性的，也可能是非線性的，怎麼找到這些函數，是機器學習的首要問題。
本篇博客嘗試用梯度下降法，找到線性函數的參數，來擬合一個數據集。
假設我們有如下函數
，其中x是一個三個維度，
寫一個java程序來，隨機產生100筆數據作為訓練集。
Random random = new Random();
double[] results = new double[100];
double[][] features = new double[100][3];
for (int i = 0; i < 100; i++) {
for (int j = 0; j < features[i].length; j++) {
features[i][j] = random.nextDouble();
}
results[i] = 3 * features[i][0] + 4 * features[i][1] + 5 * features[i][2] + 10;
}
上面的程序中results就是函數的值，features的第二維就是隨機產生的3個x。
有了訓練集，我們的任務就變成了如何求出3個各種的係數3、4、5，以及偏移量10，係數和偏移量可以取任意值，那麼我們就得到了一個函數集，任務轉化一下就變成了找出一個函數作用於訓練集之後，與真實值的誤差最小，如何評判誤差的大小呢？我們需要定義一個函數來評判，那麼給這個函數取一個名字，叫損失函數。這裡，損失函數定義為
，其中
"
鑑於本篇文章有大量乾貨內容，建議大家先收藏再觀看，看到一半也不要退出，文末有驚喜哦。給大家分享一張可愛的圖片活躍一下心情就開始這篇文章吧。
對於數據分析而言，我們總是極力找數學模型來描述數據發生的規律， 有的數據我們在二維空間就可以描述，有的數據則需要映射到更高維的空間。數據表現出來的分佈可能是完全離散的，也可能是聚集成堆的，那麼機器學習的任務就是讓計算機自己在數據中學習到數據的規律。那麼這個規律通常是可以用一些函數來描述，函數可能是線性的，也可能是非線性的，怎麼找到這些函數，是機器學習的首要問題。
本篇博客嘗試用梯度下降法，找到線性函數的參數，來擬合一個數據集。
假設我們有如下函數
，其中x是一個三個維度，
寫一個java程序來，隨機產生100筆數據作為訓練集。
Random random = new Random();
double[] results = new double[100];
double[][] features = new double[100][3];
for (int i = 0; i < 100; i++) {
for (int j = 0; j < features[i].length; j++) {
features[i][j] = random.nextDouble();
}
results[i] = 3 * features[i][0] + 4 * features[i][1] + 5 * features[i][2] + 10;
}
上面的程序中results就是函數的值，features的第二維就是隨機產生的3個x。
有了訓練集，我們的任務就變成了如何求出3個各種的係數3、4、5，以及偏移量10，係數和偏移量可以取任意值，那麼我們就得到了一個函數集，任務轉化一下就變成了找出一個函數作用於訓練集之後，與真實值的誤差最小，如何評判誤差的大小呢？我們需要定義一個函數來評判，那麼給這個函數取一個名字，叫損失函數。這裡，損失函數定義為
，其中
為真實值，問題就轉化為在訓練集中求如下函數：
"
鑑於本篇文章有大量乾貨內容，建議大家先收藏再觀看，看到一半也不要退出，文末有驚喜哦。給大家分享一張可愛的圖片活躍一下心情就開始這篇文章吧。
對於數據分析而言，我們總是極力找數學模型來描述數據發生的規律， 有的數據我們在二維空間就可以描述，有的數據則需要映射到更高維的空間。數據表現出來的分佈可能是完全離散的，也可能是聚集成堆的，那麼機器學習的任務就是讓計算機自己在數據中學習到數據的規律。那麼這個規律通常是可以用一些函數來描述，函數可能是線性的，也可能是非線性的，怎麼找到這些函數，是機器學習的首要問題。
本篇博客嘗試用梯度下降法，找到線性函數的參數，來擬合一個數據集。
假設我們有如下函數
，其中x是一個三個維度，
寫一個java程序來，隨機產生100筆數據作為訓練集。
Random random = new Random();
double[] results = new double[100];
double[][] features = new double[100][3];
for (int i = 0; i < 100; i++) {
for (int j = 0; j < features[i].length; j++) {
features[i][j] = random.nextDouble();
}
results[i] = 3 * features[i][0] + 4 * features[i][1] + 5 * features[i][2] + 10;
}
上面的程序中results就是函數的值，features的第二維就是隨機產生的3個x。
有了訓練集，我們的任務就變成了如何求出3個各種的係數3、4、5，以及偏移量10，係數和偏移量可以取任意值，那麼我們就得到了一個函數集，任務轉化一下就變成了找出一個函數作用於訓練集之後，與真實值的誤差最小，如何評判誤差的大小呢？我們需要定義一個函數來評判，那麼給這個函數取一個名字，叫損失函數。這裡，損失函數定義為
，其中
為真實值，問題就轉化為在訓練集中求如下函數：
如何求這個函數的極小值呢？如果我們計算能力無限大，直接窮舉就完了，但是這不是高效的辦法，這時候就說的了梯度下降法，我們來看看數學裡對梯度的定義。
在微積分裡面，對多元函數的參數求∂偏導數，把求得的各個參數的偏導數以向量的形式寫出來，就是梯度。比如函數f(x,y), 分別對x,y求偏導數，求得的梯度向量就是(∂f/∂x, ∂f/∂y)T,簡稱grad f(x,y)或者▽f(x,y)。
梯度告訴我們兩件事情：
1、函數增大的方向
2、我們走向增大的方向，應該走多大步幅
求極小值，我們反方向走即可，加個負號，但是這個步幅有個問題，如果過大，參數就直接飛出去了，就很難在找到最小值，如果太小，則很有可能卡在局部極小值的地方。所以，我們設計了一個係數來調節步幅，我們叫它學習速率learningRate。
好了，為了好描述，我們把上面的函數泛化一下，表示成如下公式：
"
鑑於本篇文章有大量乾貨內容，建議大家先收藏再觀看，看到一半也不要退出，文末有驚喜哦。給大家分享一張可愛的圖片活躍一下心情就開始這篇文章吧。
對於數據分析而言，我們總是極力找數學模型來描述數據發生的規律， 有的數據我們在二維空間就可以描述，有的數據則需要映射到更高維的空間。數據表現出來的分佈可能是完全離散的，也可能是聚集成堆的，那麼機器學習的任務就是讓計算機自己在數據中學習到數據的規律。那麼這個規律通常是可以用一些函數來描述，函數可能是線性的，也可能是非線性的，怎麼找到這些函數，是機器學習的首要問題。
本篇博客嘗試用梯度下降法，找到線性函數的參數，來擬合一個數據集。
假設我們有如下函數
，其中x是一個三個維度，
寫一個java程序來，隨機產生100筆數據作為訓練集。
Random random = new Random();
double[] results = new double[100];
double[][] features = new double[100][3];
for (int i = 0; i < 100; i++) {
for (int j = 0; j < features[i].length; j++) {
features[i][j] = random.nextDouble();
}
results[i] = 3 * features[i][0] + 4 * features[i][1] + 5 * features[i][2] + 10;
}
上面的程序中results就是函數的值，features的第二維就是隨機產生的3個x。
有了訓練集，我們的任務就變成了如何求出3個各種的係數3、4、5，以及偏移量10，係數和偏移量可以取任意值，那麼我們就得到了一個函數集，任務轉化一下就變成了找出一個函數作用於訓練集之後，與真實值的誤差最小，如何評判誤差的大小呢？我們需要定義一個函數來評判，那麼給這個函數取一個名字，叫損失函數。這裡，損失函數定義為
，其中
為真實值，問題就轉化為在訓練集中求如下函數：
如何求這個函數的極小值呢？如果我們計算能力無限大，直接窮舉就完了，但是這不是高效的辦法，這時候就說的了梯度下降法，我們來看看數學裡對梯度的定義。
在微積分裡面，對多元函數的參數求∂偏導數，把求得的各個參數的偏導數以向量的形式寫出來，就是梯度。比如函數f(x,y), 分別對x,y求偏導數，求得的梯度向量就是(∂f/∂x, ∂f/∂y)T,簡稱grad f(x,y)或者▽f(x,y)。
梯度告訴我們兩件事情：
1、函數增大的方向
2、我們走向增大的方向，應該走多大步幅
求極小值，我們反方向走即可，加個負號，但是這個步幅有個問題，如果過大，參數就直接飛出去了，就很難在找到最小值，如果太小，則很有可能卡在局部極小值的地方。所以，我們設計了一個係數來調節步幅，我們叫它學習速率learningRate。
好了，為了好描述，我們把上面的函數泛化一下，表示成如下公式：
損失函數對每個參數求偏導數，根據偏導數值，當然求導的過程需要用到鏈式法則，,這裡我們直接給出參數更新公式如下：
對於BGD（批量梯度下降法）：
"
鑑於本篇文章有大量乾貨內容，建議大家先收藏再觀看，看到一半也不要退出，文末有驚喜哦。給大家分享一張可愛的圖片活躍一下心情就開始這篇文章吧。
對於數據分析而言，我們總是極力找數學模型來描述數據發生的規律， 有的數據我們在二維空間就可以描述，有的數據則需要映射到更高維的空間。數據表現出來的分佈可能是完全離散的，也可能是聚集成堆的，那麼機器學習的任務就是讓計算機自己在數據中學習到數據的規律。那麼這個規律通常是可以用一些函數來描述，函數可能是線性的，也可能是非線性的，怎麼找到這些函數，是機器學習的首要問題。
本篇博客嘗試用梯度下降法，找到線性函數的參數，來擬合一個數據集。
假設我們有如下函數
，其中x是一個三個維度，
寫一個java程序來，隨機產生100筆數據作為訓練集。
Random random = new Random();
double[] results = new double[100];
double[][] features = new double[100][3];
for (int i = 0; i < 100; i++) {
for (int j = 0; j < features[i].length; j++) {
features[i][j] = random.nextDouble();
}
results[i] = 3 * features[i][0] + 4 * features[i][1] + 5 * features[i][2] + 10;
}
上面的程序中results就是函數的值，features的第二維就是隨機產生的3個x。
有了訓練集，我們的任務就變成了如何求出3個各種的係數3、4、5，以及偏移量10，係數和偏移量可以取任意值，那麼我們就得到了一個函數集，任務轉化一下就變成了找出一個函數作用於訓練集之後，與真實值的誤差最小，如何評判誤差的大小呢？我們需要定義一個函數來評判，那麼給這個函數取一個名字，叫損失函數。這裡，損失函數定義為
，其中
為真實值，問題就轉化為在訓練集中求如下函數：
如何求這個函數的極小值呢？如果我們計算能力無限大，直接窮舉就完了，但是這不是高效的辦法，這時候就說的了梯度下降法，我們來看看數學裡對梯度的定義。
在微積分裡面，對多元函數的參數求∂偏導數，把求得的各個參數的偏導數以向量的形式寫出來，就是梯度。比如函數f(x,y), 分別對x,y求偏導數，求得的梯度向量就是(∂f/∂x, ∂f/∂y)T,簡稱grad f(x,y)或者▽f(x,y)。
梯度告訴我們兩件事情：
1、函數增大的方向
2、我們走向增大的方向，應該走多大步幅
求極小值，我們反方向走即可，加個負號，但是這個步幅有個問題，如果過大，參數就直接飛出去了，就很難在找到最小值，如果太小，則很有可能卡在局部極小值的地方。所以，我們設計了一個係數來調節步幅，我們叫它學習速率learningRate。
好了，為了好描述，我們把上面的函數泛化一下，表示成如下公式：
損失函數對每個參數求偏導數，根據偏導數值，當然求導的過程需要用到鏈式法則，,這裡我們直接給出參數更新公式如下：
對於BGD（批量梯度下降法）：
"
鑑於本篇文章有大量乾貨內容，建議大家先收藏再觀看，看到一半也不要退出，文末有驚喜哦。給大家分享一張可愛的圖片活躍一下心情就開始這篇文章吧。
對於數據分析而言，我們總是極力找數學模型來描述數據發生的規律， 有的數據我們在二維空間就可以描述，有的數據則需要映射到更高維的空間。數據表現出來的分佈可能是完全離散的，也可能是聚集成堆的，那麼機器學習的任務就是讓計算機自己在數據中學習到數據的規律。那麼這個規律通常是可以用一些函數來描述，函數可能是線性的，也可能是非線性的，怎麼找到這些函數，是機器學習的首要問題。
本篇博客嘗試用梯度下降法，找到線性函數的參數，來擬合一個數據集。
假設我們有如下函數
，其中x是一個三個維度，
寫一個java程序來，隨機產生100筆數據作為訓練集。
Random random = new Random();
double[] results = new double[100];
double[][] features = new double[100][3];
for (int i = 0; i < 100; i++) {
for (int j = 0; j < features[i].length; j++) {
features[i][j] = random.nextDouble();
}
results[i] = 3 * features[i][0] + 4 * features[i][1] + 5 * features[i][2] + 10;
}
上面的程序中results就是函數的值，features的第二維就是隨機產生的3個x。
有了訓練集，我們的任務就變成了如何求出3個各種的係數3、4、5，以及偏移量10，係數和偏移量可以取任意值，那麼我們就得到了一個函數集，任務轉化一下就變成了找出一個函數作用於訓練集之後，與真實值的誤差最小，如何評判誤差的大小呢？我們需要定義一個函數來評判，那麼給這個函數取一個名字，叫損失函數。這裡，損失函數定義為
，其中
為真實值，問題就轉化為在訓練集中求如下函數：
如何求這個函數的極小值呢？如果我們計算能力無限大，直接窮舉就完了，但是這不是高效的辦法，這時候就說的了梯度下降法，我們來看看數學裡對梯度的定義。
在微積分裡面，對多元函數的參數求∂偏導數，把求得的各個參數的偏導數以向量的形式寫出來，就是梯度。比如函數f(x,y), 分別對x,y求偏導數，求得的梯度向量就是(∂f/∂x, ∂f/∂y)T,簡稱grad f(x,y)或者▽f(x,y)。
梯度告訴我們兩件事情：
1、函數增大的方向
2、我們走向增大的方向，應該走多大步幅
求極小值，我們反方向走即可，加個負號，但是這個步幅有個問題，如果過大，參數就直接飛出去了，就很難在找到最小值，如果太小，則很有可能卡在局部極小值的地方。所以，我們設計了一個係數來調節步幅，我們叫它學習速率learningRate。
好了，為了好描述，我們把上面的函數泛化一下，表示成如下公式：
損失函數對每個參數求偏導數，根據偏導數值，當然求導的過程需要用到鏈式法則，,這裡我們直接給出參數更新公式如下：
對於BGD（批量梯度下降法）：
"
鑑於本篇文章有大量乾貨內容，建議大家先收藏再觀看，看到一半也不要退出，文末有驚喜哦。給大家分享一張可愛的圖片活躍一下心情就開始這篇文章吧。
對於數據分析而言，我們總是極力找數學模型來描述數據發生的規律， 有的數據我們在二維空間就可以描述，有的數據則需要映射到更高維的空間。數據表現出來的分佈可能是完全離散的，也可能是聚集成堆的，那麼機器學習的任務就是讓計算機自己在數據中學習到數據的規律。那麼這個規律通常是可以用一些函數來描述，函數可能是線性的，也可能是非線性的，怎麼找到這些函數，是機器學習的首要問題。
本篇博客嘗試用梯度下降法，找到線性函數的參數，來擬合一個數據集。
假設我們有如下函數
，其中x是一個三個維度，
寫一個java程序來，隨機產生100筆數據作為訓練集。
Random random = new Random();
double[] results = new double[100];
double[][] features = new double[100][3];
for (int i = 0; i < 100; i++) {
for (int j = 0; j < features[i].length; j++) {
features[i][j] = random.nextDouble();
}
results[i] = 3 * features[i][0] + 4 * features[i][1] + 5 * features[i][2] + 10;
}
上面的程序中results就是函數的值，features的第二維就是隨機產生的3個x。
有了訓練集，我們的任務就變成了如何求出3個各種的係數3、4、5，以及偏移量10，係數和偏移量可以取任意值，那麼我們就得到了一個函數集，任務轉化一下就變成了找出一個函數作用於訓練集之後，與真實值的誤差最小，如何評判誤差的大小呢？我們需要定義一個函數來評判，那麼給這個函數取一個名字，叫損失函數。這裡，損失函數定義為
，其中
為真實值，問題就轉化為在訓練集中求如下函數：
如何求這個函數的極小值呢？如果我們計算能力無限大，直接窮舉就完了，但是這不是高效的辦法，這時候就說的了梯度下降法，我們來看看數學裡對梯度的定義。
在微積分裡面，對多元函數的參數求∂偏導數，把求得的各個參數的偏導數以向量的形式寫出來，就是梯度。比如函數f(x,y), 分別對x,y求偏導數，求得的梯度向量就是(∂f/∂x, ∂f/∂y)T,簡稱grad f(x,y)或者▽f(x,y)。
梯度告訴我們兩件事情：
1、函數增大的方向
2、我們走向增大的方向，應該走多大步幅
求極小值，我們反方向走即可，加個負號，但是這個步幅有個問題，如果過大，參數就直接飛出去了，就很難在找到最小值，如果太小，則很有可能卡在局部極小值的地方。所以，我們設計了一個係數來調節步幅，我們叫它學習速率learningRate。
好了，為了好描述，我們把上面的函數泛化一下，表示成如下公式：
損失函數對每個參數求偏導數，根據偏導數值，當然求導的過程需要用到鏈式法則，,這裡我們直接給出參數更新公式如下：
對於BGD（批量梯度下降法）：
"
鑑於本篇文章有大量乾貨內容，建議大家先收藏再觀看，看到一半也不要退出，文末有驚喜哦。給大家分享一張可愛的圖片活躍一下心情就開始這篇文章吧。
對於數據分析而言，我們總是極力找數學模型來描述數據發生的規律， 有的數據我們在二維空間就可以描述，有的數據則需要映射到更高維的空間。數據表現出來的分佈可能是完全離散的，也可能是聚集成堆的，那麼機器學習的任務就是讓計算機自己在數據中學習到數據的規律。那麼這個規律通常是可以用一些函數來描述，函數可能是線性的，也可能是非線性的，怎麼找到這些函數，是機器學習的首要問題。
本篇博客嘗試用梯度下降法，找到線性函數的參數，來擬合一個數據集。
假設我們有如下函數
，其中x是一個三個維度，
寫一個java程序來，隨機產生100筆數據作為訓練集。
Random random = new Random();
double[] results = new double[100];
double[][] features = new double[100][3];
for (int i = 0; i < 100; i++) {
for (int j = 0; j < features[i].length; j++) {
features[i][j] = random.nextDouble();
}
results[i] = 3 * features[i][0] + 4 * features[i][1] + 5 * features[i][2] + 10;
}
上面的程序中results就是函數的值，features的第二維就是隨機產生的3個x。
有了訓練集，我們的任務就變成了如何求出3個各種的係數3、4、5，以及偏移量10，係數和偏移量可以取任意值，那麼我們就得到了一個函數集，任務轉化一下就變成了找出一個函數作用於訓練集之後，與真實值的誤差最小，如何評判誤差的大小呢？我們需要定義一個函數來評判，那麼給這個函數取一個名字，叫損失函數。這裡，損失函數定義為
，其中
為真實值，問題就轉化為在訓練集中求如下函數：
如何求這個函數的極小值呢？如果我們計算能力無限大，直接窮舉就完了，但是這不是高效的辦法，這時候就說的了梯度下降法，我們來看看數學裡對梯度的定義。
在微積分裡面，對多元函數的參數求∂偏導數，把求得的各個參數的偏導數以向量的形式寫出來，就是梯度。比如函數f(x,y), 分別對x,y求偏導數，求得的梯度向量就是(∂f/∂x, ∂f/∂y)T,簡稱grad f(x,y)或者▽f(x,y)。
梯度告訴我們兩件事情：
1、函數增大的方向
2、我們走向增大的方向，應該走多大步幅
求極小值，我們反方向走即可，加個負號，但是這個步幅有個問題，如果過大，參數就直接飛出去了，就很難在找到最小值，如果太小，則很有可能卡在局部極小值的地方。所以，我們設計了一個係數來調節步幅，我們叫它學習速率learningRate。
好了，為了好描述，我們把上面的函數泛化一下，表示成如下公式：
損失函數對每個參數求偏導數，根據偏導數值，當然求導的過程需要用到鏈式法則，,這裡我們直接給出參數更新公式如下：
對於BGD（批量梯度下降法）：
對於SGD（隨機梯度下降法），SGD與BGD不同的是每筆數據，我們都更新一次參數，效率比較低下。公式和上面類似，去掉求和符號和除以N即可。
下面是具體的代碼實現
import java.util.Random;
public class LinearRegression {
public static void main(String[] args) {
// y=3*x1+4*x2+5*x3+10
Random random = new Random();
double[] results = new double[100];
double[][] features = new double[100][3];
for (int i = 0; i < 100; i++) {
for (int j = 0; j < features[i].length; j++) {
features[i][j] = random.nextDouble();
}
results[i] = 3 * features[i][0] + 4 * features[i][1] + 5 * features[i][2] + 10;
}
double[] parameters = new double[] { 1.0, 1.0, 1.0, 1.0 };
double learningRate = 0.01;
for (int i = 0; i < 30; i++) {
SGD(features, results, learningRate, parameters);
}
parameters = new double[] { 1.0, 1.0, 1.0, 1.0 };
System.out.println("==========================");
for (int i = 0; i < 3000; i++) {
BGD(features, results, learningRate, parameters);
}
}
private static void SGD(double[][] features, double[] results, double learningRate, double[] parameters) {
for (int j = 0; j < results.length; j++) {
double gradient = (parameters[0] * features[j][0] + parameters[1] * features[j][1]
+ parameters[2] * features[j][2] + parameters[3] - results[j]) * features[j][0];
parameters[0] = parameters[0] - 2 * learningRate * gradient;
gradient = (parameters[0] * features[j][0] + parameters[1] * features[j][1] + parameters[2] * features[j][2]
+ parameters[3] - results[j]) * features[j][1];
parameters[1] = parameters[1] - 2 * learningRate * gradient;
gradient = (parameters[0] * features[j][0] + parameters[1] * features[j][1] + parameters[2] * features[j][2]
+ parameters[3] - results[j]) * features[j][2];
parameters[2] = parameters[2] - 2 * learningRate * gradient;
gradient = (parameters[0] * features[j][0] + parameters[1] * features[j][1] + parameters[2] * features[j][2]
+ parameters[3] - results[j]);
parameters[3] = parameters[3] - 2 * learningRate * gradient;
}
double totalLoss = 0;
for (int j = 0; j < results.length; j++) {
totalLoss = totalLoss + Math.pow((parameters[0] * features[j][0] + parameters[1] * features[j][1]
+ parameters[2] * features[j][2] + parameters[3] - results[j]), 2);
}
System.out.println(parameters[0] + " " + parameters[1] + " " + parameters[2] + " " + parameters[3]);
System.out.println("totalLoss:" + totalLoss);
}
private static void BGD(double[][] features, double[] results, double learningRate, double[] parameters) {
double sum = 0;
for (int j = 0; j < results.length; j++) {
sum = sum + (parameters[0] * features[j][0] + parameters[1] * features[j][1]
+ parameters[2] * features[j][2] + parameters[3] - results[j]) * features[j][0];
}
double updateValue = 2 * learningRate * sum / results.length;
parameters[0] = parameters[0] - updateValue;
sum = 0;
for (int j = 0; j < results.length; j++) {
sum = sum + (parameters[0] * features[j][0] + parameters[1] * features[j][1]
+ parameters[2] * features[j][2] + parameters[3] - results[j]) * features[j][1];
}
updateValue = 2 * learningRate * sum / results.length;
parameters[1] = parameters[1] - updateValue;
sum = 0;
for (int j = 0; j < results.length; j++) {
sum = sum + (parameters[0] * features[j][0] + parameters[1] * features[j][1]
+ parameters[2] * features[j][2] + parameters[3] - results[j]) * features[j][2];
}
updateValue = 2 * learningRate * sum / results.length;
parameters[2] = parameters[2] - updateValue;
sum = 0;
for (int j = 0; j < results.length; j++) {
sum = sum + (parameters[0] * features[j][0] + parameters[1] * features[j][1]
+ parameters[2] * features[j][2] + parameters[3] - results[j]);
}
updateValue = 2 * learningRate * sum / results.length;
parameters[3] = parameters[3] - updateValue;
double totalLoss = 0;
for (int j = 0; j < results.length; j++) {
totalLoss = totalLoss + Math.pow((parameters[0] * features[j][0] + parameters[1] * features[j][1]
+ parameters[2] * features[j][2] + parameters[3] - results[j]), 2);
}
System.out.println(parameters[0] + " " + parameters[1] + " " + parameters[2] + " " + parameters[3]);
System.out.println("totalLoss:" + totalLoss);
}
}
運行結果如下：
同樣是更新3000次參數。
1、SGD結果：
參數分別為：3.087332784857909 、4.075233812033048 、5.06020828348889、 9.89116046652793
totalLoss:0.13515381461776949
2、BGD結果：
參數分別為：3.0819123489025344 、4.064145151461403、5.046862571520019、 9.899847277313173
totalLoss:0.1050937019067582
可以看出，BGD有更好的表現。
快樂源於分享。大家可以私信我”學習“領取學習資料。
"
"
鑑於本篇文章有大量乾貨內容，建議大家先收藏再觀看，看到一半也不要退出，文末有驚喜哦。給大家分享一張可愛的圖片活躍一下心情就開始這篇文章吧。
對於數據分析而言，我們總是極力找數學模型來描述數據發生的規律， 有的數據我們在二維空間就可以描述，有的數據則需要映射到更高維的空間。數據表現出來的分佈可能是完全離散的，也可能是聚集成堆的，那麼機器學習的任務就是讓計算機自己在數據中學習到數據的規律。那麼這個規律通常是可以用一些函數來描述，函數可能是線性的，也可能是非線性的，怎麼找到這些函數，是機器學習的首要問題。
本篇博客嘗試用梯度下降法，找到線性函數的參數，來擬合一個數據集。
假設我們有如下函數
，其中x是一個三個維度，
寫一個java程序來，隨機產生100筆數據作為訓練集。
Random random = new Random();
double[] results = new double[100];
double[][] features = new double[100][3];
for (int i = 0; i < 100; i++) {
for (int j = 0; j < features[i].length; j++) {
features[i][j] = random.nextDouble();
}
results[i] = 3 * features[i][0] + 4 * features[i][1] + 5 * features[i][2] + 10;
}
上面的程序中results就是函數的值，features的第二維就是隨機產生的3個x。
有了訓練集，我們的任務就變成了如何求出3個各種的係數3、4、5，以及偏移量10，係數和偏移量可以取任意值，那麼我們就得到了一個函數集，任務轉化一下就變成了找出一個函數作用於訓練集之後，與真實值的誤差最小，如何評判誤差的大小呢？我們需要定義一個函數來評判，那麼給這個函數取一個名字，叫損失函數。這裡，損失函數定義為
，其中
為真實值，問題就轉化為在訓練集中求如下函數：
如何求這個函數的極小值呢？如果我們計算能力無限大，直接窮舉就完了，但是這不是高效的辦法，這時候就說的了梯度下降法，我們來看看數學裡對梯度的定義。
在微積分裡面，對多元函數的參數求∂偏導數，把求得的各個參數的偏導數以向量的形式寫出來，就是梯度。比如函數f(x,y), 分別對x,y求偏導數，求得的梯度向量就是(∂f/∂x, ∂f/∂y)T,簡稱grad f(x,y)或者▽f(x,y)。
梯度告訴我們兩件事情：
1、函數增大的方向
2、我們走向增大的方向，應該走多大步幅
求極小值，我們反方向走即可，加個負號，但是這個步幅有個問題，如果過大，參數就直接飛出去了，就很難在找到最小值，如果太小，則很有可能卡在局部極小值的地方。所以，我們設計了一個係數來調節步幅，我們叫它學習速率learningRate。
好了，為了好描述，我們把上面的函數泛化一下，表示成如下公式：
損失函數對每個參數求偏導數，根據偏導數值，當然求導的過程需要用到鏈式法則，,這裡我們直接給出參數更新公式如下：
對於BGD（批量梯度下降法）：
對於SGD（隨機梯度下降法），SGD與BGD不同的是每筆數據，我們都更新一次參數，效率比較低下。公式和上面類似，去掉求和符號和除以N即可。
下面是具體的代碼實現
import java.util.Random;
public class LinearRegression {
public static void main(String[] args) {
// y=3*x1+4*x2+5*x3+10
Random random = new Random();
double[] results = new double[100];
double[][] features = new double[100][3];
for (int i = 0; i < 100; i++) {
for (int j = 0; j < features[i].length; j++) {
features[i][j] = random.nextDouble();
}
results[i] = 3 * features[i][0] + 4 * features[i][1] + 5 * features[i][2] + 10;
}
double[] parameters = new double[] { 1.0, 1.0, 1.0, 1.0 };
double learningRate = 0.01;
for (int i = 0; i < 30; i++) {
SGD(features, results, learningRate, parameters);
}
parameters = new double[] { 1.0, 1.0, 1.0, 1.0 };
System.out.println("==========================");
for (int i = 0; i < 3000; i++) {
BGD(features, results, learningRate, parameters);
}
}
private static void SGD(double[][] features, double[] results, double learningRate, double[] parameters) {
for (int j = 0; j < results.length; j++) {
double gradient = (parameters[0] * features[j][0] + parameters[1] * features[j][1]
+ parameters[2] * features[j][2] + parameters[3] - results[j]) * features[j][0];
parameters[0] = parameters[0] - 2 * learningRate * gradient;
gradient = (parameters[0] * features[j][0] + parameters[1] * features[j][1] + parameters[2] * features[j][2]
+ parameters[3] - results[j]) * features[j][1];
parameters[1] = parameters[1] - 2 * learningRate * gradient;
gradient = (parameters[0] * features[j][0] + parameters[1] * features[j][1] + parameters[2] * features[j][2]
+ parameters[3] - results[j]) * features[j][2];
parameters[2] = parameters[2] - 2 * learningRate * gradient;
gradient = (parameters[0] * features[j][0] + parameters[1] * features[j][1] + parameters[2] * features[j][2]
+ parameters[3] - results[j]);
parameters[3] = parameters[3] - 2 * learningRate * gradient;
}
double totalLoss = 0;
for (int j = 0; j < results.length; j++) {
totalLoss = totalLoss + Math.pow((parameters[0] * features[j][0] + parameters[1] * features[j][1]
+ parameters[2] * features[j][2] + parameters[3] - results[j]), 2);
}
System.out.println(parameters[0] + " " + parameters[1] + " " + parameters[2] + " " + parameters[3]);
System.out.println("totalLoss:" + totalLoss);
}
private static void BGD(double[][] features, double[] results, double learningRate, double[] parameters) {
double sum = 0;
for (int j = 0; j < results.length; j++) {
sum = sum + (parameters[0] * features[j][0] + parameters[1] * features[j][1]
+ parameters[2] * features[j][2] + parameters[3] - results[j]) * features[j][0];
}
double updateValue = 2 * learningRate * sum / results.length;
parameters[0] = parameters[0] - updateValue;
sum = 0;
for (int j = 0; j < results.length; j++) {
sum = sum + (parameters[0] * features[j][0] + parameters[1] * features[j][1]
+ parameters[2] * features[j][2] + parameters[3] - results[j]) * features[j][1];
}
updateValue = 2 * learningRate * sum / results.length;
parameters[1] = parameters[1] - updateValue;
sum = 0;
for (int j = 0; j < results.length; j++) {
sum = sum + (parameters[0] * features[j][0] + parameters[1] * features[j][1]
+ parameters[2] * features[j][2] + parameters[3] - results[j]) * features[j][2];
}
updateValue = 2 * learningRate * sum / results.length;
parameters[2] = parameters[2] - updateValue;
sum = 0;
for (int j = 0; j < results.length; j++) {
sum = sum + (parameters[0] * features[j][0] + parameters[1] * features[j][1]
+ parameters[2] * features[j][2] + parameters[3] - results[j]);
}
updateValue = 2 * learningRate * sum / results.length;
parameters[3] = parameters[3] - updateValue;
double totalLoss = 0;
for (int j = 0; j < results.length; j++) {
totalLoss = totalLoss + Math.pow((parameters[0] * features[j][0] + parameters[1] * features[j][1]
+ parameters[2] * features[j][2] + parameters[3] - results[j]), 2);
}
System.out.println(parameters[0] + " " + parameters[1] + " " + parameters[2] + " " + parameters[3]);
System.out.println("totalLoss:" + totalLoss);
}
}
運行結果如下：
同樣是更新3000次參數。
1、SGD結果：
參數分別為：3.087332784857909 、4.075233812033048 、5.06020828348889、 9.89116046652793
totalLoss:0.13515381461776949
2、BGD結果：
參數分別為：3.0819123489025344 、4.064145151461403、5.046862571520019、 9.899847277313173
totalLoss:0.1050937019067582
可以看出，BGD有更好的表現。
快樂源於分享。大家可以私信我”學習“領取學習資料。
相關推薦
十年程序員分享：java線程池的實現原理深入分析
前言線程是稀缺資源，如果被無限制的創建，不僅會消耗系統資源，還會降低系統的穩定性，合理的使用線程池對線程進行統一分配、調優和監控，有以下好處： 1、降低資...
教程：採用梯度下降算法實現線性迴歸！
點擊上方關注，All in AI中國作者：Adarsh Menon在這個教程中，你可以瞭解梯度下降算法將如何工作，並在python中從頭開始實現。首先我們...
機器學習：Deeplearning.ai筆記——logistic迴歸梯度下降法
回顧logistic損失函數上圖是logistic迴歸的一般形式，其中L(a,y)是loss function，具體原因如下圖，詳情可看我之前寫的其他文章...
Java關鍵字volatile的理解與正確使用｜乾貨分享
概述Java語言中關鍵字 volatile 被稱作輕量級的 synchronized，與synchronized相比，volatile編碼相對簡單且運行的...
「純乾貨」成為Java高手，您做技術迴歸了沒有？
曾記得在以前學電腦操作時有一個小諺語“高手之路，DOS起步”，如今十幾年過去了，對該說法，更加的深以為然。現在JAVA語言仍舊佔據著開發界的半壁江山，自然...
純乾貨分享 Java必備基礎知識點（十）
76、 如何使用Java讀寫系統屬性？讀：System.setProperties(props);77、 簡述properties文件的結構和基本用法結構...
純乾貨分享 Java必備基礎知識點（八）
64、 static修飾符的功能是？可以用在什麼地方？怎麼訪問？static 修飾符功能:（1） 共用一塊內存區域，也就是用static修飾的變量或成員方...
純乾貨分享 Java必備基礎知識點（七）
56、 如何實現繼承？繼承的規則？public class A extends B{}（1） 單繼承性（2） 構造方法不能繼承（3） super引用父類，...
乾貨滿滿！360李振煒分享SparkSQL海量數據庫設計實現
5月11日，第八屆中國數據庫技術大會(DTCC 2017)在北京國際會議中心盛大開幕。本屆DTCC大會以“數據驅動·價值發現”為主題，作為國內最受關注，規...
Java實現解壓和壓縮jar、zip、rar等壓縮包源碼分享
有的時候在修改服務器項目中jar包配置時比較費事，相信開發過一定時間的碼農們都遇到過類似的問題吧，需要重新打包再上傳替換jar包，這樣相對比較費事還有可能...
java上傳圖片和分享功能的實現
前一陣子寫了一篇說會寫一個java圖片上傳的功能，這幾天比較忙，就耽擱了，今天趁有時間把補上，上篇文章說到我做圖片上傳時遇到了這樣一個問題，就是別人惡意攻...
2017年做微商草根也可實現輕鬆月入上萬的項目乾貨分享
大家好，首先自我介紹一下，我是淘果團隊的創始人，也是一名全職微商小7，如果你今年真想選擇一個好的微商項目，開始發展你的微商之路，那就請認真仔細閱讀一下以...
梯度下降法與反向傳播
一、梯度下降法1.什麼是梯度下降法順著梯度下滑，找到最陡的方向，邁一小步，然後再找當前位，置最陡的下山方向，再邁一小步…通過比較以上兩個圖，可以會發現，由...
機器學習
2017-04-18
Java Web大數據分佈式等技術乾貨分享，不看會後悔！
不管是Java、C++、PHP、HTML5還是大數據分佈式等技術相信大家都很感興趣！俗話說的不錯聞道有先後，達者為先，我認為不管是資深還是初級程序員都對技...
推薦中...