SoftMax Regression属于指数家族，证明见（ http://cs229.stanford.edu/notes/cs229-notes1.pdf 及http://ufldl.stanford.edu/wiki/index.php/Softmax_Regression），最后得出的结论是：

最后写出似然估计： 

之后采用梯度或牛顿方法进行逼近：

注意，上面公式采用的是批量梯度，随机梯度当然也是可以的。

参数theta的更新如下：

实验还是参考大牛pennyliang（http://blog.csdn.net/pennyliang/article/details/7048291），代码如下：

1. #include <iostream>
2. #include <cmath>
3. #include <assert.h>
4. using namespace std;
5. const int K = 2;//有K+1类
6. const int M = 9;//训练集大小
7. const int N = 4;//特征数
8. double x[M][N]={{1,47,76,24}, //include x0=1
9. {1,46,77,23},
10. {1,48,74,22},
11. {1,34,76,21},
12. {1,35,75,24},
13. {1,34,77,25},
14. {1,55,76,21},
15. {1,56,74,22},
16. {1,55,72,22},
17. };
18. double y[M]={1,
19. 1,
20. 1,
21. 2,
22. 2,
23. 2,
24. 3,
25. 3,
26. 3,};
27. double theta[K][N]={
28. {0.3,0.3,0.01,0.01},
29. {0.5,0.5,0.01,0.01}}; // include theta0
30. double h_value[K];//h(x)向量值
31. //求exp（QT*x）
32. double fun_eqx(double* x, double* q)
33. {
34. double sum = 0;
35. for (int i = 0; i < N; i++)
36. {
37. sum += x[i] * q[i];
38. }
39. return pow(2.718281828, sum);
40. }
41. //求h向量
42. void h(double* x)
43. {
44. int i;
45. double sum = 1;//之前假定theta[K+1]={0},所以exp(Q[K+1]T*x)=1
46. for (i = 0; i < K; i++)
47. {
48. h_value[i] = fun_eqx(x, theta[i]);
49. sum += h_value[i];
50. }
51. assert(sum != 0);
52. for (i = 0; i < K; i++)
53. {
54. h_value[i] /= sum;
55. }
56. }
57. void modify_stochostic()
58. {
59. //随机梯度下降，训练参数
60. int i, j, k;
61. for (j = 0; j < M; j ++)
62. {
63. h(x[j]);
64. for (i = 0; i < K; i++)
65. {
66. for (k = 0; k < N; k++)
67. {
68. theta[i][k] += 0.001 * x[j][k] *  ((y[j] == i+1?1:0) - h_value[i]);
69. }
70. }
71. }
72. }
73. void modify_batch()
74. {
75. //批量梯度下降，训练参数
76. int i, j, k ;
77. for (i = 0; i < K; i++)
78. {
79. double sum[N] = {0.0};
80. for (j = 0; j < M; j++)
81. {
82. h(x[j]);
83. for (k = 0; k < N; k++)
84. {
85. sum[k] += x[j][k] * ((y[j] == i+1?1:0) - h_value[i]);
86. }
87. }
88. for (k = 0; k < N; k++)
89. {
90. theta[i][k] += 0.001 * sum[k] / N;
91. }
92. }
93. }
94. void train(void)
95. {
96. int i;
97. for (i = 0; i < 10000; i++)
98. {
99. //modify_stochostic();
100. modify_batch();
101. }
102. }
103. void predict(double* pre)
104. {
105. //输出预测向量
106. int i;
107. for (i = 0; i < K; i++)
108. h_value[i] = 0;
109. train();
110. h(pre);
111. for (i = 0; i < K; i++)
112. cout << h_value[i] << " ";
113. cout << 1 - h_value[0] - h_value[1] << endl;
114. }
115. int main(void)
116. {
117. for (int i=0; i < M; i++)
118. {
119. predict(x[i]);
120. }
121. cout << endl;
122. double pre[] = {1,20, 80, 50 };
123. predict(pre);
124. return 0;
125. }

代码实现了批量梯度和随机梯度两种方法，实验最后分别将训练样本带入进行估计，迭代10000次的结果为：

可见随机梯度收敛的更快。

对于预测来说，输出结果每行的三个数表示是：对于输入来说，是1 2 3三类的概率分别是多少。