【機器學習】對數線性模型之Logistic迴歸、SoftMax迴歸和最大熵模型

來源 | AI小白入門
作者 | 文傑
編輯 | yuquanle
完整代碼見：原文鏈接

1. Logistic迴歸

​ 分類問題可以看作是在迴歸函數上的一個分類。一般情況下定義二值函數，然而二值函數構成的損失函數非凸，一般採用sigmoid函數平滑擬合（當然也可以看作是一種軟劃分，概率劃分）：從函數圖像我們能看出，該函數有很好的特性，適合二分類問題。至於爲何選擇Sigmoid函數，後面可以從廣義線性模型導出爲什麼是Sigmoid函數。

邏輯迴歸可以看作是在線性迴歸的基礎上構建的分類模型，理解的角度有多種（最好的當然是概率解釋和最小對數損失），而最直接的理解是考慮邏輯迴歸是將線性迴歸值離散化。即一個二分類問題如下：（二值函數）

$h_{\theta}(x^{(i)})=g(\theta^{T}x)=\left\{\begin{matrix} 1 ， if \theta^{T}x \geq t\\ 0， if \theta^{T}x < t \end{matrix}\right.$

1.1 sigmoid函數

$g(z)=\frac{1}{1+e^{-z}},g^{‘}(z)=g(z)(1-g(z))$

$0-1$損失的二分類問題屬於一種硬劃分，即是與否的劃分，而sigmoid函數則將這種硬劃分軟化，以一定的概率屬於某一類（且屬於兩類的加和爲1）。Sigmoid函數將線性迴歸值映射到 $[0,1]$的概率區間，從函數圖像我們能看出，該函數有很好的特性，適合二分類問題。 因此邏輯迴歸模型如下：

$h_{\theta}(x^{(i)})=g(\theta^{T}x)=\frac{1}{1+e^{-\theta^{T}x}}$
​ 這裏對於目標函數的構建不再是最小化函數值與真實值的平方誤差了，按分類原則來講最直接的損失因該是0-1損失，即分類正確沒有損失，分類錯誤損失計數加1。但是0-1損失難以優化，存在弊端。結合sigmoid函數將硬劃分轉化爲概率劃分的特點，採用概率$h_{\theta}(x^{(i)})$的對數損失（概率解釋-N次伯努利分佈加最大似然估計），其目標函數如下：

$J(\theta)=\sum_{i=1}^{m}-\left ( y^{(i)}log(h_{\theta}(x^{(i)}))+(1-y^{(i)})log(1-h_{\theta}(x^{(i)}))\right) \\ \min J(\theta)$

同樣採用梯度下降的方法有：

$\theta _{j}:=\theta_{j} -\alpha \frac{\partial J(\theta )}{\partial \theta _{j}}\\ =\theta_{j} -\alpha \frac{\partial \sum_{i=1}^{m}-\left ( y^{(i)}log(h_{\theta}(x^{(i)}))+(1-y^{(i)})log(1-h_{\theta}(x^{(i)}))\right) }{\partial \theta _{j}} \\ =\theta_{j}-\alpha \left (-\frac{y^{(i)}}{h_{\theta}(x^{(i)})}+ \frac{(1-y^{(i)})}{(1-h_{\theta}(x^{(i)}))} \right )\frac{\partial h_{\theta}(x^{(i)})}{\partial \theta _{j}}\\ =\theta_{j}-\alpha \left( \frac{y^{(i)}-h_{\theta}(x^{(i)})}{h_{\theta}(x^{(i)}) (1-h_{\theta}(x^{(i)}))} \right)\frac{\partial h_{\theta}(x^{(i)})}{\partial \theta _{j}}$

又：

$\frac{\partial h_{\theta}(x)}{\partial \theta}={\left ( \frac{1}{1+e^{-\theta^{T}x}} \right )}'\\ =\frac{\left ( e^{-\theta^{T}x} \right )}{{\left ( \frac{1}{1+e^{-\theta^{T}x}} \right )}^{2}}x\\ =\left ( \frac{1}{1+e^{-\theta^{T}x}}\right )\left (1- \frac{1}{1+e^{-\theta^{T}x}}\right )x\\ =h_{\theta}(x)\left ( 1-h_{\theta}(x) \right )x$

所以有：

$\theta_{j}=\theta_{j}-\alpha \left(y^{(i)}-h_{\theta}(x^{(i)})\right)x$

1.2 概率解釋

​ 邏輯迴歸的概率解釋同線性迴歸模型一致，只是假設不再是服從高斯分佈，而是$p\left ( y|x;\theta \right )$服從0-1分佈，由於 ，假設隨機變量y服從伯努利分佈是合理的 。即：

$p\left ( y=1|x;\theta \right )=h_{\theta}(x)\\ p\left ( y=0|x;\theta \right )=1-h_{\theta}(x)\\ p\left ( y|x;\theta \right )=\left (h_{\theta}(x) \right )^{y}.\left (1-h_{\theta}(x) \right )^{\left (1-y \right )}$

所以最大化似然估計有：

$\max L(\theta)=p\left ( y|x; \theta \right )\\ =\prod_{i=1}^{m}p\left ( y^{(i)}|x^{(i)}; \theta \right )\\ =\prod_{i=1}^{m}\left (h_{\theta}(x^{(i)}) \right )^{y^{(i)}}.\left (1-h_{\theta}(x^{(i)}) \right)^{\left (1-y^{(i)} \right )}\\ \Leftrightarrow \max logL(\theta)\\ \Leftrightarrow \min -logL(\theta)=\sum_{i=1}^{m}-\left ( y^{(i)}log(h_{\theta}(x^{(i)}))+(1-y^{(i)})log(1-h_{\theta}(x^{(i)}))\right)$

1.3 logistic採用對數損失原因

採用對數損失的原因有二：

​ 1) 從概率解釋來看，多次伯努利分佈是指數的形式。由於最大似然估計導出的結果是概率連乘，而概率（sigmoid函數）恆小於1，爲了防止計算下溢，取對數將連乘轉換成連加的形式，而且目標函數和對數函數具備單調性，取對數不會影響目標函數的優化值。

​ 2）從對數損失目標函數來看，取對數之後在求導過程會大大簡化計算量。

2. SoftMax迴歸

2.1 SoftMax迴歸

Softmax迴歸可以看作是Logistic迴歸在多分類上的一個推廣。考慮二分類的另一種表示形式：

$\left [ k_{1},1-k_{1} \right ]\rightarrow \begin{bmatrix} k_{1}\\ k_{2} \end{bmatrix}$

當logistic迴歸採用二維表示的話，那麼其損失函數如下：

$J\left ( \theta \right )=-\sum _{i=1}^{m}\sum _{k=1}^{2}\left ( y^{(ik)} log\left ( \frac{ h_{\theta k}(x^{(i)})}{\sum _{k=1}^{K}h_{\theta k}(x^{(i)})} \right )\right )\\ \min J\left ( \theta \right )$
其中，在邏輯迴歸中兩類分別爲$k_{1}$，$1-k_{1}$二在softmax中採用$k_{1}，$$k_{2}$兩個隨機變量組成二維向量表示，當然隱含約束$k_{1}+k_{2}=1$.爲了更好的表示多分類問題，將$y\in \left \{ 1,2,..K \right \}$（不一定理解爲$y$的取值爲$k$，更應該理解爲$y$可以取$k$類）多分類問題進行如下表示：
$T(k)=\begin{bmatrix} 0\\ 0\\ .\\ 1\\ .\\ 0 \end{bmatrix}$
其中向量的第$k$位爲1，其他位爲$0$，也就是當$y=k$ 時將其映射成向量時對應第$k$位爲$1$。採用多維向量表示之後，那麼對於每一維就變成了一個單獨的二分類問題了，所以softmax函數形式如下：
$h_{\theta}(x^{(i)})=\frac{1}{\sum_{ k=1}^{K}exp\left ( \theta _{k}^{T}x^{(i)} \right )}\begin{bmatrix} exp\left ( \theta _{k}^{T}x^{(i)} \right )\\ exp\left ( \theta _{k}^{T}x^{(i)} \right )\\ .\\ exp\left ( \theta _{k}^{T}x^{(i)} \right ) \end{bmatrix}$
其中函數值是一個$K$維的向量，同樣採用對數損失（N元伯努利分佈和最大似然估計），目標函數形式是logistic迴歸的多維形式。

$J\left ( \theta \right )=-\sum _{i=1}^{m}\sum _{k=1}^{K}\left ( y^{(ik)} log\left ( \frac{ h_{\theta k}(x^{(i)})}{\sum _{k=1}^{K}h_{\theta k}(x^{(i)})} \right )\right )\\ \min J\left ( \theta \right )$

其中$y^{ik}$表示第$i$個樣本的標籤向量化後第$k$維的取值$0$或者$1$.可以看出Softmax的損失是對每一類計算其概率的對數損失，而logistic迴歸是計算兩類的迴歸，其本質是一樣。Logistic迴歸和Softmax迴歸都是基於線性迴歸的分類模型，兩者無本質區別，都是從伯努利分結合最大對數似然估計。只是Logistic迴歸常用於二分類，而Softmax迴歸常用於多分類。而且Logistic迴歸在考慮多分類時只考慮$n-1$類。

2.2 二分類轉多分類思想

對於多分類問題，同樣可以借鑑二分類學習方法，在二分類學習基礎上採用一些策略以實現多分類，基本思路是“拆解法”，假設N個類別$C_{1},C_{2},.C_{i}.,C_{n}$，經典的拆分算法有“一對一”，“一對多”，“多對多”，

​ 一對一的基本思想是從所有類別中選出兩類來實現一個兩分類學習器，即學習出$C_{N}^{2}=N(N-1)/2$個二分類器，然後對新樣本進行預測時，對這 $C_{N}^{2}$個分類器進行投票最終決定屬於那一類。

​ 一對多的基本思想是把所有類別進行二分類，即屬於$C_{i}$類和非$C_{i}$兩類，這樣我們就需要N個分類器，然後對新樣本進行預測時，與每一個分類器比較，最終決定屬於哪一類。這其實就是Softmax的思想，也是SVM多分類的思想。

3. 最大熵模型

​ 之所以把最大熵模型放到這講，是因爲它和Logistic迴歸和SoftMax迴歸實在是驚人的相似，同屬於對數線性模型。

3.1 熵的概念

信息熵：熵是一種對隨機變量不確定性的度量，不確定性越大，熵越大。若隨機變量退化成定值，熵爲0。均勻分佈是“最不確定”的分佈 。

假設離散隨機變量X的概率分佈爲$P(X)$，則其熵爲：
$H(X)=-\sum_{x}P(x)logP(x)$
其中熵滿足不等式$0\leq H(P) \leq log|X|$，$|X|$爲$X$取值數。

聯合熵：對於多個隨機變量的不確定性可以用聯合熵度量

假設離散隨機變量$X,Y$的聯合概率分佈爲$P(X,Y)$，則其熵爲：
$H(X,Y)=-\sum_{x}\sum_{y}P(x,y)logP(x,y)$
條件熵：在給定條件下描述隨機變量的不確定性

假設離散隨機變量$X,Y$，在給定$Y$的條件下$X$的不確定性爲條件熵H(X|Y)，也就等於$H(X,Y)-H(Y)$
$H(X|Y)=-\sum_{x,y}P(x,y)log(P(x|y))$
互信息：衡量兩個隨機變量相關性的大小$I(X,Y)=H(X)+H(Y)-H(X,Y)$
$I(X,Y)=-\sum_{x,y}P(x,y)log\frac{P(x,y)}{P(x)P(y)}$
相對熵（KL散度）：衡量對於同一個隨機變量兩個概率分佈$p(x),q(x)$的差異性
$D(p||q)=\sum_{x}p(x)log\frac{p(x)}{q(x)}=E_{p(x)}log\frac{p(x)}{q(x)}$
有互信息和相對熵的定義有下式：
$I(X,Y)=D(P(X,Y)||P(X)P(Y))$
關於熵的介紹就到此，不細究，雖然上面的這些定義在機器學習中都會遇到，不過後面涉及到的主要還是熵和條件熵，互信息。

3.2 最大熵模型

​ 最大熵原理是概率模型學習中的一個準則。最大熵原理認爲，學習概率模型時，在所有可能的概率模型分佈中（滿足所有條件下），熵最大的模型是最好的模型。熵最大即爲最均勻的分佈，從某種角度講均勻分佈總是符合我們理解的損失風險最小，也就是“不要不所有的雞蛋放到一個籃子裏，均勻的放置”。

​ 給定訓練集$T=\{ (x_{1},y_{1}),(x_{2},y_{2})..(x_{m},y_{m})\}$，假設$X \in \chi \subseteq R^{n}$表示輸入，$y\in \phi$表示輸出，分類模型是一個以條件概率分佈$P(Y|X)$輸出$Y$，也就是說在滿足條件的所有可能集中，條件熵$P(Y|X)$最大的模型即爲最好的模型。其中條件爲隱藏在數據的期望。

​ 一般來講，最大熵模型常用於處理離散化數據集，定義隨機變量$X,Y$的特徵模板，從數據中統計他們的期望作爲最大熵模型的條件

特徵函數：
$f(x,y)=\left\{\begin{matrix} 1，x，y滿足某一事實\\ 0，否則 \end{matrix}\right.$
約束條件：對於任意的特徵函數$f$，我們可以統計其在數據中的經驗分佈$\widetilde{P}(x,y)$的期望：
$E_{\widetilde{p}}(f)=\sum_{x,y}\widetilde{P}(x,y)f(x,y)$
特徵函數$f$關於模型$P(Y|X)$和先驗$\widetilde{P}(X)$的條件期望：
$E_{p}(f)=\sum_{x,y}\widetilde{P}(x)P(y|x)f(x,y)$
所以，滿足約束條件的模型集合爲：
$\Omega \equiv \{ P\in \boldsymbol{P}| E_{p}(f_{i})=E_{\widetilde{p}}(f_{i}),i=1..n\}$
因此最大熵模型的形式化表示如下：
$\max_{P\in C} H(P)=-\sum_{x,y}\widetilde{P}(x)P(y|x)logp(y|x)\\ \Leftrightarrow \min_{P\in C} -H(P)=\sum_{x,y}\widetilde{P}(x)P(y|x)logp(y|x)\\ s.t. E_{p}(f_{i})=E_{\widetilde{p}}(f_{i}) ,i=1..n\\ \sum_{y}P(y|x)=1$

由拉格讓日乘子法，引入拉格讓日乘子，定義拉格讓日函數：

$L(P,w)=-H(P)+w_{0}(1-\sum_{y}P(y|x))+\sum_{i}w_{i}(E_{p}(f_{i})-E_{\widetilde{p}}(f_{i}))\\ =\sum_{x,y}\widetilde{P}(x)P(y|x)logp(y|x)\!+\!w_{0}(1\!-\!\sum_{y}P(y|x))\!+\!\sum_{i}w_{i}(\sum_{x,y}(\widetilde{P}(x)P(y|x)f_{i}(x,y)\!-\!\sum_{x,y}\widetilde{P}(x,y)f_{i}(x,y))\\ s.t. \bigtriangledown L(P,w)=0\\ (1-\sum_{y}P(y|x))=0\\ \sum_{x,y}(\widetilde{P}(x)P(y|x)f_{i}(x,y)-\sum_{x,y}\widetilde{P}(x,y)f_{i}(x,y)=0 ,i=1..n\\ w_{i}\geq0 ,i=1..n$
根據拉格朗日乘子法，$L(P) \geq L(P,w)$，當且僅當滿足拉格朗日乘子法的所有必要條件等式成立，原問題也就是一個最小化最大問題
$\min_{P \in C}\max_{w}L(P,w)$
裏層是$\max$最大化$L(P,w)$，外層的$\min$最小化$L(P)$。

對偶問題是：
$\max_{w} \min_{P \in C}L(P,w)$
求解對偶問題，第一步最小化內部$\min_{P \in C}L(P,w)$，$\min_{P \in C}L(P,w)$是關於$w$的函數，最優解記爲$P_{w}$：
$P_{w}=arg\min_{P \in C}L(P,w)=P_{w}(y|x)$
那麼外層最大化目標函數爲：
$\max_{w}\Phi(w)\\ \Phi(w)=\min_{p \in C}L(P,w)=L(P_{w},w)$
爲了求解$P_{w}(y|x)$，根據KKT條件對$P(y|x)$求偏導：
$\frac{\partial L(P,w)}{\partial P(y|x)}=\sum_{x,y}\widetilde{P}(x)(logP(y|x)+1)-\sum_{y}w_{0}-\sum_{x,y}\left (\widetilde{P}(x)\sum_{i}w_{i}f_{i}(x,y) \right )\\ =\sum_{x,y}\widetilde{P}(x)\left (logP(y|x)+1-w_{0}-\sum_{i}w_{i}f_{i}(x,y) \right )\\ =0$
求解得：
$P(y|x)=exp\left( \sum_{i} w_{i}f_{i}(x,y) +w_{0}-1 \right)=\frac{ \left(exp \sum_{i} w_{i}f_{i}(x,y)\right)}{exp(1-w_{0})}$
這裏，雖然我們不知道$w_{0}$，但是由於$\sum_{y}P(y|x)=1$,所以分母一定是對$y$的所有可能的歸一化因子
$P_{w}(y|x)=\frac{1}{z_{w}(x)} \left(exp \sum_{i} w_{i}f_{i}(x,y)\right)\\ z_{w}(x)=\sum_{y}exp(\sum_{i}w_{i}f_{i}(x,y))$
因此，$\max_{w} \Phi(w)$的最優解爲：
$w^* = arg \max_w \Phi(w)$
代回$P_{w}(y|x)$，我們可以得到最終的分類模型，同樣我們發現最大熵模型也是一個對數線性模型。

回顧對偶函數，內部最小化求解得到了$P_{w}(y|x)$，回到外部目標$\max_{w}\Phi(w)$，將$P_{w}(y|x)$代回拉格朗日函數有：
$\begin{aligned} \Phi(w) &=\sum_{x,y}\widetilde{P}(x)P_w(y|x)logP_w(y|x) + \sum^n_{i=1}w_i\left (\sum_{x,y}\widetilde{P}(x ,y)f_{i}(x,y) -\sum_{x,y}\widetilde{P}(x)P_w(y|x)f_{i}(x,y) \right )\\ &= \sum_{x,y} \widetilde{P}(x,y)\sum_{i=1}^nw_if_i(x,y) +\sum_{x,y}\widetilde{P}(x)P_w(y|x)\left (logP_w(y|x) - \sum_{i=1}^nw_if_i(x,y) \right) \\ &=\sum_{x,y} \widetilde{P}(x,y)\sum_{i=1}^nw_if_i(x,y) -\sum_{x,y}\widetilde{P}(x)P_w(y|x)logz_w(x)\\ &=\sum_{x,y} \widetilde{P}(x,y)\sum_{i=1}^nw_if_i(x,y) -\sum_x\widetilde{P}(x)logz_w(x)\sum_yP_w(y|x)\\ &=\sum_{x,y} \widetilde{P}(x,y)\sum_{i=1}^nw_if_i(x,y) -\sum_x\widetilde{P}(x)logz_w(x)\\ \end{aligned}$

3.3 概率解釋

已知訓練集的經驗概率分佈$\widetilde{P}(x,y)$，條件概率分佈$P(y|x)$的對數似然函數爲：

$L_{\widetilde{P}}(P_w) = log\prod_{x,y}P(y|x)^{\widetilde{P}(x,y)} = \sum_{x,y}\widetilde{P}(x,y)logP(y|x) ，特徵統計\\ Logistic:\max logL(\theta)=p\left ( y|x; \theta \right )=log\prod_{i=1}^{m}\prod_{k=1}^{K}\left (h_{\theta}(x^{(i)}) \right )^{y^{(i)}}，樣本統計\\$

其中，我們發現對數似然函數與條件熵的形式一致，最大熵模型目標函數前面有負號（這與最大化對數似然函數完全相反），同時最大熵模型中有約束條件。也正是因爲約束條件，我們將原問題轉化爲對偶問題後發現，在滿足約束條件的對偶函數的極大化等價於最大化對數似然函數。

當條件概率$P(y|x)$滿足約束條件，在對偶問題求解過程中我們有：
$P_{w}(y|x)=\frac{1}{z_{w}(x)} \left(exp \sum_{i} w_{i}f_{i}(x,y)\right)\\ z_{w}(x)=\sum_{y}exp(\sum_{i}w_{i}f_{i}(x,y))$
代入到對數似然函數，同樣有：
$\begin{aligned} L_{\widetilde{P}}(P_w) &= \sum_{x,y}\widetilde{P}(x,y)logP(y|x)\\ &= \sum_{x,y}\widetilde{P}(x,y)\left ( \sum_{i=1}^n w_if_i(x,y) -logz_w(x)\right )\\ &= \sum_{x,y}\widetilde{P}(x,y)\sum_{i=1}^n w_if_i(x,y) - \sum_{x,y}\widetilde{P}(x,y)logz_w(x)\\ &= \sum_{x,y}\widetilde{P}(x,y)\sum_{i=1}^n w_if_i(x,y) - \sum_{x}\widetilde{P}(x)logz_w(x) = \Phi(w) \\ \end{aligned}$
最後，我們再來看對偶函數表達式，我們發現，第一項其實是$X,Y$的聯合熵$H(X,Y)$，第二項是$X$的信息熵$H(X)$，回看熵的示意圖，我們發現，我們的目標還是最大化條件熵$H(Y|X)$。

下面再來對比下Logistic迴歸，SoftMax迴歸，最大熵模型：

1）同屬於對數線性模型；

2）Logistic迴歸和SoftMax迴歸都基於條件概率$P(y|x)$，滿足一個伯努利分佈，N重伯努利分佈；而最大熵模型以期望爲準，沒有該假設；

3）由於都採用線性模型，三者都假設特徵之間是獨立的。

3.4 最大熵模型的優化問題

​ 最大熵模型從拉格朗日乘子法最大化對偶函數，還是從最大化對數似然函數，其目標函數如下：
$L_{\widetilde{P}}(P_w)= \sum_{x,y}\widetilde{P}(x,y)\sum_{i=1}^n w_if_i(x,y) - \sum_{x}\widetilde{P}(x)logZ_w(x)\\$
常用的梯度優化算法都可以，另外對於最大熵模型也有專門的算法有GIS IIS 算法 。

代碼

Logistic迴歸

int LogReg()
{
    const char *file="data\\LogReg.txt";
    const string model="gradAscent";
    const double alpha=0.01;
    Matrix x;
    cout<<"loadData"<<endl;
    cout<<"----------------------"<<endl;
    x.LoadData(file);
    Matrix y;
    y=x.getOneCol(x.col-1);
    x.deleteOneCol(x.col-1);

    if(model=="gradAscent")
        gradAscent_Log(x,y);
    if(model=="stoGradAscent")
        stoGradAscent_Log(x,y);

    return 0;
}

  int gradAscent_Log(Matrix x,Matrix y)  
      {
          if(y.col!=1)
          {
              cout<<"logReg is two class"<<endl;
              return -1;
          }
          Matrix weights(x.col,y.col,0.1,"T");
          Matrix xT = x.transposeMatrix();
  
          float alpha=0.01;///迭代步長
          float error=0;///記錄錯誤率
          int iter=0;
          int i,j;
          Matrix z(y.row,y.col,0,"T");//最好確定矩陣的大小
          Matrix grad(x.col,y.col,0,"T");
          for(iter=0; iter<5000; iter++)
          {
              z = x * weights;
              for(i=0; i<z.row; i++)
              {
                  z.data[i][0]=sigmoid(z.data[i][0]);
              }
              z = y - z;
              error=0;
              for(i=0; i<x.row; i++)///統計錯誤率
                  error+=z.data[i][0];
              grad = xT * z;///計算負梯度方向
              for(i=0; i<grad.row; i++)
                  grad.data[i][0]*= alpha;///負梯度方向與步長的乘積確定迭代值
              weights = weights + grad;///往負梯度方向走一個步長
          }
  
          /**
          驗證算法的正確性
          **/  
          int er1=0,er2=0;
          Matrix train=x * weights;
          cout<<"test"<<endl;
          for(i=0; i<y.row; i++)
          {
              if(train.data[i][0]>0)
              {
                  cout<<1-y.data[i][0]<<endl;
                  er1+=(1-y.data[i][0]);
              }
              else  
              {
                  cout<<0-y.data[i][0]<<endl;
                  er2-=(0-y.data[i][0]);
              }
          }
      }

SoftMax迴歸

int SoftMaxReg()
{
    const char *file="data\\LogReg.txt";
    const string model="gradAscent";
    const double alpha=0.01;
    Matrix x;
    cout<<"loadData"<<endl;
    cout<<"----------------------"<<endl;
    x.LoadData(file);
    Matrix y;
    y=x.getOneCol(x.col-1);
    y=one_hot(y,2);
    x.deleteOneCol(x.col-1);

    if(model=="gradAscent")
        gradAscent_SoftMax(x,y);
    if(model=="stoGradAscent")
        stoGradAscent_SoftMax(x,y);

    return 0;
}


  /**
      隨機梯度下降與梯度下降法不同的是在負梯度方向的確定，梯度下降是根據所有的樣本來確定負梯度方向，
      而隨機梯度下降每次只看一個樣本點來確定負梯度方向，雖然不完全可信，但隨着迭代次數增加，同樣收斂
        
 **/  
int stoGradAscent_SoftMax(Matrix x,Matrix y)//隨機梯度下降每一次選擇m個樣本進行求梯度下降方向，該代碼中只選擇一個樣本進行求解梯度下降方向與數值
      {
          Matrix xOneRow(1,x.col,0,"T");
          Matrix xOneRowT(x.col,1,0,"T");
  
          Matrix weights(x.col,y.col,0.1,"T");
          Matrix z(1,y.col,0,"T");//最好確定矩陣的大小
          Matrix grad(x.col,y.col,0,"T");
          double zRowSum=0;
          double alpha=0.001;///步長
          double error;
          int i,j,k,iter;
          for(iter=0; iter<5000; iter++)
          {
              for(i=0; i<x.row; i++)
              {
                  xOneRow=x.getOneRow(i);///隨機選擇一個樣本點，這裏沒有作隨機選擇，而是按序選擇
                  z = xOneRow * weights;
                  zRowSum=0;
                  for(j=0;j<z.col;j++)
                  {
                      z.data[0][j]=sigmoid(z.data[0][j]);
                      zRowSum+=z.data[0][j];//求和
                  }
                  for(j=0;j<z.col;j++)
                  {
                      z.data[0][j]/=zRowSum;//歸一化
                      if(iter%1000==0)
                          cout<<z.data[0][j] <<" s ";
                  }
                  if(iter%1000==0)
                      cout<<endl;
                  for(j=0;j<y.col;j++)
                  {
                      z.data[0][j]=y.data[i][j]-z.data[0][j];
                  }
                  xOneRowT = xOneRow.transposeMatrix();
                  grad = xOneRowT * z;///根據一樣樣本的預測誤差來確定負梯度方向
                  for(k=0; k<grad.row;k++)
                  {
                      for(j=0;j<grad.col; j++)
                      {
                          grad.data[k][j]*= alpha;///負梯度方向與步長的乘積確定迭代值
                      }
                  }
                  weights = weights + grad; ///迭代
              }
          }
          //驗證算法的正確性
          /**
          驗證算法的正確性
          **/  
          Matrix test=x * weights;
          cout<<"test"<<endl;
          for(i=0; i<y.row; i++)
          {
              if(test.data[i][0]>test.data[i][1])
                  cout<<0-y.data[i][1]<<" ";
              else  
                  cout<<1-y.data[i][1]<<" ";
              cout<<endl;
          }
      }

歡迎關注【AI小白入門】，這裏分享Python、機器學習、深度學習、自然語言處理、人工智能等技術，關注前沿技術，求職經驗等，陪有夢想的你一起成長。