来源 | AI小白入门
作者 | 文杰
编辑 | yuquanle
完整代码见：原文链接

1. Logistic回归

​ 分类问题可以看作是在回归函数上的一个分类。一般情况下定义二值函数，然而二值函数构成的损失函数非凸，一般采用sigmoid函数平滑拟合（当然也可以看作是一种软划分，概率划分）：从函数图像我们能看出，该函数有很好的特性，适合二分类问题。至于为何选择Sigmoid函数，后面可以从广义线性模型导出为什么是Sigmoid函数。

逻辑回归可以看作是在线性回归的基础上构建的分类模型，理解的角度有多种（最好的当然是概率解释和最小对数损失），而最直接的理解是考虑逻辑回归是将线性回归值离散化。即一个二分类问题如下：（二值函数）

$$h_{\theta }(x^{(i)})=g({\theta }^{T}x)=\{\begin{array}{c}1，if{\theta }^{T}x\ge t\\ 0，if{\theta }^{T}x<t\end{array}$$

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次伯努利分布加最大似然估计），其目标函数如下：

$$\begin{gathered} 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 ) \end{gathered}$$

同样采用梯度下降的方法有：

$$\begin{gathered} {\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} \end{gathered}$$

又：

$$\begin{gathered} \frac{\partial h_{\theta }(x)}{\partial \theta }={\left(\frac{1}{1+e^{-{\theta }^{T}x}}\right)}^{\prime } \\ =\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 \end{gathered}$$

所以有：

$${\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服从伯努利分布是合理的 。即：

$$\begin{gathered} 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)} \end{gathered}$$

所以最大化似然估计有：

$$\begin{gathered} \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)} \\ \iff \max logL(\theta ) \\ \iff \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) \end{gathered}$$

1.3 logistic采用对数损失原因

采用对数损失的原因有二：

​ 1) 从概率解释来看，多次伯努利分布是指数的形式。由于最大似然估计导出的结果是概率连乘，而概率（sigmoid函数）恒小于1，为了防止计算下溢，取对数将连乘转换成连加的形式，而且目标函数和对数函数具备单调性，取对数不会影响目标函数的优化值。

​ 2）从对数损失目标函数来看，取对数之后在求导过程会大大简化计算量。

2. SoftMax回归

2.1 SoftMax回归

Softmax回归可以看作是Logistic回归在多分类上的一个推广。考虑二分类的另一种表示形式：

$$\left[k_1,1-k_1\right]\to \left[\begin{array}{c}{k}_1\\ k_2\end{array}\right]$$

当logistic回归采用二维表示的话，那么其损失函数如下：

$$\begin{gathered} 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) \end{gathered}$$
其中，在逻辑回归中两类分别为$k_1$，$1-k_1$二在softmax中采用$k_1，$$k_2$两个随机变量组成二维向量表示，当然隐含约束$k_1+k_2=1$.为了更好的表示多分类问题，将 y ∈ { 1 , 2 , . . K } y\in \left \{ 1,2,..K \right \} y∈{1,2,..K}（不一定理解为$y$的取值为$k$，更应该理解为$y$可以取$k$类）多分类问题进行如下表示：
$$T(k)=\left[\begin{array}{c}0\\ 0\\ .\\ 1\\ .\\ 0\end{array}\right]$$
其中向量的第$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)}\left[\begin{array}{c}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{array}\right]$$
其中函数值是一个$K$维的向量，同样采用对数损失（N元伯努利分布和最大似然估计），目标函数形式是logistic回归的多维形式。

$$\begin{gathered} 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) \end{gathered}$$

其中$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\le H(P)\le 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 ) } T=\{ (x_{1},y_{1}),(x_{2},y_{2})..(x_{m},y_{m})\} T={(x1​,y1​),(x2​,y2​)..(xm​,ym​)}，假设$X\in \chi \subseteq R^n$表示输入，$y\in \varphi$表示输出，分类模型是一个以条件概率分布$P(Y|X)$输出$Y$，也就是说在满足条件的所有可能集中，条件熵$P(Y|X)$最大的模型即为最好的模型。其中条件为隐藏在数据的期望。

​ 一般来讲，最大熵模型常用于处理离散化数据集，定义随机变量$X,Y$的特征模板，从数据中统计他们的期望作为最大熵模型的条件

特征函数：
$$f(x,y)=\{\begin{array}{c}1，x，y满足某一事实\\ 0，否则\end{array}$$
约束条件：对于任意的特征函数$f$，我们可以统计其在数据中的经验分布$\tilde{P}(x,y)$的期望：
$$E_{\tilde{p}}(f)=\sum _{x,y}\tilde{P}(x,y)f(x,y)$$
特征函数$f$关于模型$P(Y|X)$和先验$\tilde{P}(X)$的条件期望：
$$E_p(f)=\sum _{x,y}\tilde{P}(x)P(y|x)f(x,y)$$
所以，满足约束条件的模型集合为：
Ω ≡ { P ∈ P ∣ E p ( f i ) = E p ~ ( f i ) , i = 1.. n } \Omega \equiv \{ P\in \boldsymbol{P}| E_{p}(f_{i})=E_{\widetilde{p}}(f_{i}),i=1..n\} Ω≡{P∈P∣Ep​(fi​)=Ep ​​(fi​),i=1..n}
因此最大熵模型的形式化表示如下：
$$\begin{gathered} \underset{P\in C}{\max }H(P)=-\sum _{x,y}\tilde{P}(x)P(y|x)logp(y|x) \\ \iff \underset{P\in C}{\min }-H(P)=\sum _{x,y}\tilde{P}(x)P(y|x)logp(y|x) \\ s.t.E_p(f_i)=E_{\tilde{p}}(f_i),i=1..n \\ \sum _{y}P(y|x)=1 \end{gathered}$$

由拉格让日乘子法，引入拉格让日乘子，定义拉格让日函数：

$$\begin{gathered} L(P,w)=-H(P)+w_0(1-\sum _{y}P(y|x))+\sum _i{w}_i(E_p(f_i)-E_{\tilde{p}}(f_i)) \\ =\sum _{x,y}\tilde{P}(x)P(y|x)logp(y|x)+w_0(1-\sum _{y}P(y|x))+\sum _i{w}_i(\sum _{x,y}(\tilde{P}(x)P(y|x)f_i(x,y)-\sum _{x,y}\tilde{P}(x,y)f_i(x,y)) \\ s.t.▽L(P,w)=0 \\ (1-\sum _{y}P(y|x))=0 \\ \sum _{x,y}(\tilde{P}(x)P(y|x)f_i(x,y)-\sum _{x,y}\tilde{P}(x,y)f_i(x,y)=0,i=1..n \\ {w}_i\ge 0,i=1..n \end{gathered}$$
根据拉格朗日乘子法，$L(P)\ge L(P,w)$，当且仅当满足拉格朗日乘子法的所有必要条件等式成立，原问题也就是一个最小化最大问题
$$\underset{P\in C}{\min }\underset{w}{\max }L(P,w)$$
里层是$\max$最大化$L(P,w)$，外层的$\min$最小化$L(P)$。

对偶问题是：
$$\underset{w}{\max }\underset{P\in C}{\min }L(P,w)$$
求解对偶问题，第一步最小化内部${\min }_{P\in C}L(P,w)$，${\min }_{P\in C}L(P,w)$是关于$w$的函数，最优解记为$P_w$：
$$P_w=arg\underset{P\in C}{\min }L(P,w)=P_w(y|x)$$
那么外层最大化目标函数为：
$$\begin{gathered} \underset{w}{\max }\Phi (w) \\ \Phi (w)=\underset{p\in C}{\min }L(P,w)=L(P_w,w) \end{gathered}$$
为了求解$P_w(y|x)$，根据KKT条件对$P(y|x)$求偏导：
$$\begin{gathered} \frac{\partial L(P,w)}{\partial P(y|x)}=\sum _{x,y}\tilde{P}(x)(logP(y|x)+1)-\sum _y{w}_0-\sum _{x,y}\left(\tilde{P}(x)\sum _i{w}_i{f}_i(x,y)\right) \\ =\sum _{x,y}\tilde{P}(x)\left(logP(y|x)+1-w_0-\sum _i{w}_i{f}_i(x,y)\right) \\ =0 \end{gathered}$$
求解得：
$$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$的所有可能的归一化因子
$$\begin{gathered} 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)) \end{gathered}$$
因此，${\max }_w\Phi (w)$的最优解为：
$$w^{\ast }=arg\underset{w}{\max }\Phi (w)$$
代回$P_w(y|x)$，我们可以得到最终的分类模型，同样我们发现最大熵模型也是一个对数线性模型。

回顾对偶函数，内部最小化求解得到了$P_w(y|x)$，回到外部目标${\max }_w\Phi (w)$，将$P_w(y|x)$代回拉格朗日函数有：
$$\begin{array}{rl}\Phi (w)& =\sum _{x,y}\tilde{P}(x)P_w(y|x)log{P}_w(y|x)+\sum _{i=1}^n{w}_i\left(\sum _{x,y}\tilde{P}(x,y)f_i(x,y)-\sum _{x,y}\tilde{P}(x)P_w(y|x)f_i(x,y)\right)\\ & =\sum _{x,y}\tilde{P}(x,y)\sum _{i=1}^n{w}_i{f}_i(x,y)+\sum _{x,y}\tilde{P}(x)P_w(y|x)\left(log{P}_w(y|x)-\sum _{i=1}^n{w}_i{f}_i(x,y)\right)\\ & =\sum _{x,y}\tilde{P}(x,y)\sum _{i=1}^n{w}_i{f}_i(x,y)-\sum _{x,y}\tilde{P}(x)P_w(y|x)log{z}_w(x)\\ & =\sum _{x,y}\tilde{P}(x,y)\sum _{i=1}^n{w}_i{f}_i(x,y)-\sum _x\tilde{P}(x)log{z}_w(x)\sum _y{P}_w(y|x)\\ & =\sum _{x,y}\tilde{P}(x,y)\sum _{i=1}^n{w}_i{f}_i(x,y)-\sum _x\tilde{P}(x)log{z}_w(x)\end{array}$$

3.3 概率解释

已知训练集的经验概率分布$\tilde{P}(x,y)$，条件概率分布$P(y|x)$的对数似然函数为：

$$\begin{gathered} L_{\tilde{P}}(P_w)=log\prod _{x,y}P(y|x{)}^{\tilde{P}(x,y)}=\sum _{x,y}\tilde{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)}}，样本统计 \end{gathered}$$

其中，我们发现对数似然函数与条件熵的形式一致，最大熵模型目标函数前面有负号（这与最大化对数似然函数完全相反），同时最大熵模型中有约束条件。也正是因为约束条件，我们将原问题转化为对偶问题后发现，在满足约束条件的对偶函数的极大化等价于最大化对数似然函数。

当条件概率$P(y|x)$满足约束条件，在对偶问题求解过程中我们有：
$$\begin{gathered} 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)) \end{gathered}$$
代入到对数似然函数，同样有：
$$\begin{array}{rl}{L}_{\tilde{P}}(P_w)& =\sum _{x,y}\tilde{P}(x,y)logP(y|x)\\ & =\sum _{x,y}\tilde{P}(x,y)\left(\sum _{i=1}^n{w}_i{f}_i(x,y)-log{z}_w(x)\right)\\ & =\sum _{x,y}\tilde{P}(x,y)\sum _{i=1}^n{w}_i{f}_i(x,y)-\sum _{x,y}\tilde{P}(x,y)log{z}_w(x)\\ & =\sum _{x,y}\tilde{P}(x,y)\sum _{i=1}^n{w}_i{f}_i(x,y)-\sum _x\tilde{P}(x)log{z}_w(x)=\Phi (w)\end{array}$$
最后，我们再来看对偶函数表达式，我们发现，第一项其实是$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_{\tilde{P}}(P_w)=\sum _{x,y}\tilde{P}(x,y)\sum _{i=1}^n{w}_i{f}_i(x,y)-\sum _x\tilde{P}(x)log{Z}_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、机器学习、深度学习、自然语言处理、人工智能等技术，关注前沿技术，求职经验等，陪有梦想的你一起成长。