? ? ? 之前在https://blog.csdn.net/fengbingchun/article/details/75351323 介紹過梯度下降，常見的梯度下降有三種形式：BGD、SGD、MBGD，它們的不同之處在于我們使用多少數據來計算目標函數的梯度。

? ? ? 大多數深度學習算法都涉及某種形式的優化。優化指的是改變x以最小化或最大化某個函數f(x)的任務。我們通常以最小化f(x)指代大多數最優化問題。我們把要最小化或最大化的函數稱為目標函數(objective function)或準則(criterion)。當我們對其進行最小化時，我們也把它稱為成本函數(cost function)、損失函數(loss function)或誤差函數(error function)。

? ? ? 梯度下降是深度學習中一種常用的優化技術。梯度是函數的斜率。它衡量一個變量響應另一個變量的變化而變化的程度。在數學上，梯度下降是一個凸函數，其輸出是輸入的一組參數的偏導數。梯度越大，坡度越陡(the greater the gradient, the steeper the slope)。從初始值開始，迭代運行梯度下降以找到參數的最佳值，以找到給定成本函數的最小可能值。

? ? ? 梯度下降是一種優化算法，通常用于尋找深度學習算法中的權值及系數(weights or coefficients)，如邏輯回歸。它的工作原理是讓模型對訓練數據進行預測，并使用預測中的error來更新模型從而減少error(It works by having the model make predictions on training data and using the error on the predictions to update the model in such a way as to reduce the error)。

? ? ? 該算法的目標是找到使模型在訓練數據集上的誤差最小化的模型參數(e.g. coefficients or weights)。它通過對模型進行更改，使其沿著誤差的梯度或斜率向下移動到最小誤差值來實現這一點。這使該算法獲得了"梯度下降"的名稱。

? ? ? 梯度下降是深度學習中非常流行的優化算法。它的目標是搜索目標函數或成本函數(objective function or cost function)的全局最小值。這只有在目標函數是凸函數時才有可能，這間接意味著該函數將是碗形的。在非凸函數的情況下，梯度下降會找到最近的最小值，這個函數的最小值稱為局部最小值。

? ? ? 梯度下降是一種一階優化算法。這意味著在更新參數時它只考慮函數的一階導數。我們的主要目標是在每次迭代中使梯度沿最陡斜率的方向行進，我們在與目標函數的梯度相反的方向上更新參數。

? ? ? 圖解說明：假設只有weight沒有bias。如果weight(w)的特定值的斜率>0，則表示我們在最優w*的右側，在這種情況下，更新將是負數，并且w將開始接近最優w*。但是，如果weight(w)的特定值的斜率<0，則更新將為正值，并將當前值增加到w以收斂到w*的最佳值。以下截圖來自于https://www.machinelearningman.com：重復該方法，直到成本函數收斂。

? ? ? 在https://blog.csdn.net/fengbingchun/article/details/79370310中有梯度下降應用于二分類的公式推導。

? ? ? MBGD(Mini-Batch Gradient Descent, MBGD)：小批量梯度下降，它將訓練數據集分成小批量用于計算模型誤差和更新模型參數。小批量梯度下降尋求在隨機梯度下降的魯棒性和批量梯度下降的效率之間找到平衡。它是深度學習領域中最常見的梯度下降實現。

? ? ? 梯度下降是一種最小化目標函數的方法：θ為模型的參數，J(θ)為目標函數，以下截圖來自:https://arxiv.org/pdf/1609.04747.pdf

? ? ?

? ? ? ?有時提到SGD的時候，其實指的是MBGD。

? ? ? 小批量的大小通常由以下幾個因素決定：

? ? ? (1).更大的批量會計算更精確的梯度估計，但是回報卻是小于線性的。

? ? ? (2).極小批量通常難以充分利用多核架構。這促使我們使用一些絕對最小批量，低于這個值的小批量處理不會減少計算時間。

? ? ? (3).如果批量處理中的所有樣本可以并行地處理(通常確是如此)，那么內存消耗和批量大小會正比。對于很多硬件設施，這是批量大小的限制因素。

? ? ? (4).在某些硬件上使用特定大小的數組時，運行時間會更少。尤其是在使用GPU時，通常使用2的冪數作為批量大小可以獲得更少的運行時間。一般，2的冪數的取值范圍是32到256，16有時>在嘗試大模型時使用。

? ? ? (5).可能是由于小批量在學習過程中加入了噪聲，它們會有一些正則化效果。泛化誤差通常在批量大小為1時最好。因為梯度估計的高方差，小批量訓練需要較小的學習率以保持穩定性。因

? ? ? 為降低的學習率和消耗更多步驟來遍歷整個訓練集都會產生更多的步驟，所以會導致總的運行時間非常大。

? ? ? 小批量是隨機抽取的這點也很重要。從一組樣本中計算出梯度期望的無偏估計要求這些樣本是獨立的。我們也希望兩個連續的梯度估計是互相獨立的，因此兩個連續的小批量樣本也應該是>彼此獨立的。很多現實的數據集自然排列，從而使得連續的樣本之間具有高度相關性。實踐中通常將樣本順序打亂一次，然后按照這個順序存儲起來就足夠了。之后訓練模型時會用到的一>組組小批量連續樣本是固定的，每個獨立的模型每次遍歷訓練數據時都會重復使用這個順序。

? ? ? 優點：

? ? ? (1).模型更新頻率高于批量梯度下降，這允許更穩健的收斂，避免局部極小值。

? ? ? (2).批量更新提供了比隨機梯度下降計算上更有效的過程。

? ? ? (3).批量處理既可以提高內存中沒有所有訓練數據的效率，也可以實現算法。

? ? ? 缺點：

? ? ? (1).小批量需要為學習算法配置一個額外的"mini-batch size"超參數。

? ? ? (2).錯誤信息(error information)必須在像批量梯度下降這樣的小批量訓練樣本中累積。

? ? ? 一般"batch size"為32、64、128、256等的2的冪。"batch size"是學習過程中的一個滑塊(slider)。較小的值會提供一個快速收斂的學習過程，但會以訓練過程中的噪聲為代價。較大的值會給出一個緩慢收斂的學習過程并準確估計誤差梯度。

? ? ? 以上內容主要參考：

? ? ? 1. https://arxiv.org/pdf/1609.04747.pdf?

? ? ? 2. https://machinelearningmastery.com/

? ? ? 3.?https://www.machinelearningman.com

? ? ? 以下的測試代碼以https://blog.csdn.net/fengbingchun/article/details/79346691中邏輯回歸實現的基礎上進行調整：

? ? ? logistic_regression2.hpp：

#ifndef FBC_SRC_NN_LOGISTIC_REGRESSION2_HPP_
#define FBC_SRC_NN_LOGISTIC_REGRESSION2_HPP_#include <cstdlib>
#include <ctime>
#include <vector>
#include <string>
#include <memory>namespace ANN {enum class ActivationFunction {Sigmoid // logistic sigmoid function
};enum class LossFunction {MSE // Mean Square Error
};enum class Optimization {BGD, // Batch Gradient DescentSGD, // Stochastic Gradient DescentMBGD // Mini-batch Gradient Descent
};struct Database {Database() = default;std::vector<std::vector<float>> samples; // training setstd::vector<int> labels; // ground truth labels
};class LogisticRegression2 { // two categories
public:LogisticRegression2(Optimization optim = Optimization::BGD, int batch_size = 1) : optim_(optim), batch_size_(batch_size) {}int init(std::unique_ptr<Database> data, int feature_length, float learning_rate = 0.00001, int epochs = 1000);int train(const std::string& model);int load_model(const std::string& model);float predict(const float* data, int feature_length) const; // y = 1/(1+exp(-(wx+b)))void set_error(float error) { error_ = error; }private:int store_model(const std::string& model) const;float calculate_z(const std::vector<float>& feature) const;  // z(i)=w^T*x(i)+bfloat calculate_cost_function() const;static int generate_random(int i) { return std::rand()%i; }float calculate_activation_function(float value) const;float calculate_loss_function() const;float calculate_loss_function_derivative() const;float calculate_loss_function_derivative(float predictive_value, float true_value) const;void calculate_gradient_descent(int start = 0, int end = 0);std::unique_ptr<Database> data_; // train data(images, labels)std::vector<int> random_shuffle_; // shuffle the training data at every epochstd::vector<float> o_; // predict valueint epochs_ = 100; // epochsint m_ = 0; // train samples numint feature_length_ = 0; // weights lengthfloat alpha_ = 0.00001; // learning ratestd::vector<float> w_; // weightsfloat b_ = 0.; // thresholdfloat error_ = 0.00001;int batch_size_ = 1;ActivationFunction activation_func_ = ActivationFunction::Sigmoid;LossFunction loss_func_ = LossFunction::MSE;Optimization optim_ = Optimization::BGD;
}; // class LogisticRegression2} // namespace ANN#endif // FBC_SRC_NN_LOGISTIC_REGRESSION2_HPP_

? ? ? logistic_regression2.cpp:

#include "logistic_regression2.hpp"
#include <fstream>
#include <algorithm>
#include <random>
#include <cmath>
#include "common.hpp"namespace ANN {int LogisticRegression2::init(std::unique_ptr<Database> data, int feature_length, float learning_rate, int epochs)
{CHECK(data->samples.size() == data->labels.size());m_ = data->samples.size();if (m_ < 2) {fprintf(stderr, "logistic regression train samples num is too little: %d\n", m_);return -1;}if (learning_rate <= 0) {fprintf(stderr, "learning rate must be greater 0: %f\n", learning_rate);return -1;}if (epochs < 1) {fprintf(stderr, "number of epochs cannot be zero or a negative number: %d\n", epochs);return -1;}alpha_ = learning_rate;epochs_ = epochs;feature_length_ = feature_length;data_ = std::move(data);o_.resize(m_);return 0;
}int LogisticRegression2::train(const std::string& model)
{w_.resize(feature_length_, 0.);generator_real_random_number(w_.data(), feature_length_, -0.01f, 0.01f, true);generator_real_random_number(&b_, 1, -0.01f, 0.01f);if (optim_ == Optimization::BGD) {for (int iter = 0; iter < epochs_; ++iter) {calculate_gradient_descent();auto cost_value = calculate_cost_function();fprintf(stdout, "epochs: %d, cost function: %f\n", iter, cost_value);if (cost_value < error_) break;}} else {random_shuffle_.resize(data_->samples.size(), 0);for (int i = 0; i < data_->samples.size(); ++i)random_shuffle_[i] = i;float cost_value = 0.;for (int iter = 0; iter < epochs_; ++iter) {std::srand(unsigned(std::time(0)));std::random_shuffle(random_shuffle_.begin(), random_shuffle_.end(), generate_random);int loop = (m_ + batch_size_ - 1) / batch_size_;for (int i = 0; i < loop; ++i) {int start = i * batch_size_;int end = start + batch_size_ > m_ ? m_ : start + batch_size_;calculate_gradient_descent(start, end);for (int i = 0; i < m_; ++i)o_[i] = calculate_activation_function(calculate_z(data_->samples[i]));cost_value = calculate_cost_function();fprintf(stdout, "epochs: %d, loop: %d, cost function: %f\n", iter, i, cost_value);if (cost_value < error_) break;}if (cost_value < error_) break;}}CHECK(store_model(model) == 0);return 0;
}int LogisticRegression2::load_model(const std::string& model)
{std::ifstream file;file.open(model.c_str(), std::ios::binary);if (!file.is_open()) {fprintf(stderr, "open file fail: %s\n", model.c_str());return -1;}int length{ 0 };file.read((char*)&length, sizeof(length));w_.resize(length);feature_length_ = length;file.read((char*)w_.data(), sizeof(float)*w_.size());file.read((char*)&b_, sizeof(float));file.close();return 0;
}float LogisticRegression2::predict(const float* data, int feature_length) const
{CHECK(feature_length == feature_length_);float value{0.};for (int t = 0; t < feature_length_; ++t) {value += data[t] * w_[t];}value += b_;return (calculate_activation_function(value));
}int LogisticRegression2::store_model(const std::string& model) const
{std::ofstream file;file.open(model.c_str(), std::ios::binary);if (!file.is_open()) {fprintf(stderr, "open file fail: %s\n", model.c_str());return -1;}int length = w_.size();file.write((char*)&length, sizeof(length));file.write((char*)w_.data(), sizeof(float) * w_.size());file.write((char*)&b_, sizeof(float));file.close();return 0;
}float LogisticRegression2::calculate_z(const std::vector<float>& feature) const
{float z{0.};for (int i = 0; i < feature_length_; ++i) {z += w_[i] * feature[i];}z += b_;return z;
}float LogisticRegression2::calculate_cost_function() const
{/*// J+=-1/m([y(i)*loga(i)+(1-y(i))*log(1-a(i))])// Note: log0 is not definedfloat J{0.};for (int i = 0; i < m_; ++i)J += -(data_->labels[i] * std::log(o_[i]) + (1 - labels[i]) * std::log(1 - o_[i]) );return J/m_;*/float J{0.};for (int i = 0; i < m_; ++i)J += 1./2*std::pow(data_->labels[i] - o_[i], 2);return J/m_;
}float LogisticRegression2::calculate_activation_function(float value) const
{switch (activation_func_) {case ActivationFunction::Sigmoid:default: // Sigmoidreturn (1. / (1. + std::exp(-value))); // y = 1/(1+exp(-value))}
}float LogisticRegression2::calculate_loss_function() const
{switch (loss_func_) {case LossFunction::MSE:default: // MSEfloat value = 0.;for (int i = 0; i < m_; ++i) {value += 1/2.*std::pow(data_->labels[i] - o_[i], 2);}return value/m_;}
}float LogisticRegression2::calculate_loss_function_derivative() const
{switch (loss_func_) {case LossFunction::MSE:default: // MSEfloat value = 0.;for (int i = 0; i < m_; ++i) {value += o_[i] - data_->labels[i];}return value/m_;}
}float LogisticRegression2::calculate_loss_function_derivative(float predictive_value, float true_value) const
{switch (loss_func_) {case LossFunction::MSE:default: // MSEreturn (predictive_value - true_value);}
}void LogisticRegression2::calculate_gradient_descent(int start, int end)
{float db = 0.;std::vector<float> dw(feature_length_, 0.);switch (optim_) {case Optimization::SGD:case Optimization::MBGD: {int len = end - start;std::vector<float> z(len, 0), dz(len, 0);for (int i = start, x = 0; i < end; ++i, ++x) {z[x] = calculate_z(data_->samples[random_shuffle_[i]]);dz[x] = calculate_loss_function_derivative(calculate_activation_function(z[x]), data_->labels[random_shuffle_[i]]);for (int j = 0; j < feature_length_; ++j) {dw[j] += data_->samples[random_shuffle_[i]][j] * dz[x]; // dw(i)+=x(i)(j)*dz(i)}db += dz[x]; // db+=dz(i)}for (int j = 0; j < feature_length_; ++j) {dw[j] /= len;w_[j] -= alpha_ * dw[j];}b_ -= alpha_*(db/len);}break;case Optimization::BGD:default: // BGDstd::vector<float> z(m_, 0), dz(m_, 0);for (int i = 0; i < m_; ++i) {z[i] = calculate_z(data_->samples[i]);o_[i] = calculate_activation_function(z[i]);dz[i] = calculate_loss_function_derivative(o_[i], data_->labels[i]);for (int j = 0; j < feature_length_; ++j) {dw[j] += data_->samples[i][j] * dz[i]; // dw(i)+=x(i)(j)*dz(i)}db += dz[i]; // db+=dz(i)}for (int j = 0; j < feature_length_; ++j) {dw[j] /= m_;w_[j] -= alpha_ * dw[j];}b_ -= alpha_*(db/m_);}
}} // namespace ANN

? ? ? test_logistic_regression2_gradient_descent：以MNIST為數據集，取0和1，在訓練時取訓練集各5000張，預測時取測試集各900張

int test_logistic_regression2_gradient_descent()
{fprintf(stdout,"Warning: first generate test images: execute demo/DatasetToImage/DatasetToImage: MNISTtoImage\n");fprintf(stdout, "load train images ...\n");
#ifdef _MSC_VERconst std::vector<std::string> image_path{ "E:/GitCode/NN_Test/data/tmp/MNIST/train_images/", "E:/GitCode/NN_Test/data/tmp/MNIST/test_images/"};const std::string model{ "E:/GitCode/NN_Test/data/logistic_regression2.model" };
#elseconst std::vector<std::string> image_path{ "data/tmp/MNIST/train_images/", "data/tmp/MNIST/test_images/"};const std::string model{ "data/logistic_regression2.model" };
#endifconst int image_size = 28*28;const int samples_single_class_num = 5000;auto data1 = std::make_unique<ANN::Database>();data1->samples.resize(samples_single_class_num*2);data1->labels.resize(samples_single_class_num*2);if (read_images(image_path[0], samples_single_class_num, image_size, data1) == -1) return -1;fprintf(stdout, "start train ...\n");auto start = std::chrono::steady_clock::now();//ANN::LogisticRegression2 lr(ANN::Optimization::BGD, samples_single_class_num * 2); // Batch Gradient Descent, epochs = 10000, correct rete: 0.997778//ANN::LogisticRegression2 lr(ANN::Optimization::SGD, 1); // Stochastic Gradient Descent,  epochs = 5, correct rete: 0.998889ANN::LogisticRegression2 lr(ANN::Optimization::MBGD, 128); // Mini-batch Gradient Descent,  epochs = 100, correct rete: 0.997778lr.set_error(0.0002);int ret = lr.init(std::move(data1), image_size, 0.00001, 5);if (ret != 0) {fprintf(stderr, "logistic regression init fail: %d\n", ret);return -1;}ret = lr.train(model);if (ret != 0) {fprintf(stderr, "logistic regression train fail: %d\n", ret);return -1;}auto end = std::chrono::steady_clock::now();fprintf(stdout, "train elapsed time: %d seconds\n", std::chrono::duration_cast<std::chrono::seconds>(end - start).count());fprintf(stdout, "start predict ...\n");const int test_single_class_num = 900;const std::vector<std::string> prefix_name {"0_", "1_"};ANN::LogisticRegression2 lr2;lr2.load_model(model);int count = 0;for (int i = 1; i <= test_single_class_num; ++i) {for (const auto& prefix : prefix_name) {std::string name = std::to_string(i);if (i < 10) {name = "0000" + name;} else if (i < 100) {name = "000" + name;} else if (i < 1000) {name = "00" + name;}name = image_path[1] + prefix + name + ".jpg";cv::Mat mat = cv::imread(name, 0);if (mat.empty()) {fprintf(stderr, "read image fail: %s\n", name.c_str());return -1;}if (mat.cols * mat.rows != image_size || mat.channels() != 1) {fprintf(stderr, "image size fail: width: %d, height: %d, channels: %d\n", mat.cols, mat.rows, mat.channels());return -1;}mat.convertTo(mat, CV_32F);float probability = lr2.predict((float*)mat.data, image_size);int label = prefix == "0_" ? 0 : 1;if ((probability > 0.5 &&  label == 1) || (probability < 0.5 && label == 0)) ++count;}}float correct_rate = count / (test_single_class_num * 2.);fprintf(stdout, "correct rate: %f\n", correct_rate);return 0;
}

? ? ? ?執行結果如下：訓練時，MBGD成本函數error值并不向BGD一樣逐漸減少，偶爾會波動，但是總體上還是逐漸減少；設置相同的error，MBGD比SGD訓練時間少好多；預測準確率為99.83%

? ? ? GitHub：?https://github.com/fengbingchun/NN_Test

總結

以上是生活随笔為你收集整理的深度学习中的优化算法之MBGD的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。