机器学习十大算法---2 .逻辑回归

逻辑回归其实是一个分类算法而不是回归算法。通常是利用已知的自变量来预测一个离散型因变量的值（像二进制值0/1，是/否，真/假）。简单来说，它就是通过拟合一个逻辑函数（logit fuction）来预测一个事件发生的概率。所以它预测的是一个概率值，自然，它的输出值应该在0到1之间。

此时可以看看一个博客，推导公式：http://www.cnblogs.com/daguankele/p/6549891.html 

它的核心思想是，如果线性回归的结果输出是一个连续值，而值的范围是无法限定的，那我们有没有办法把这个结果值映射为可以帮助我们判断的结果呢。而如果输出结果是 (0,1) 的一个概率值，这个问题就很清楚了。我们在数学上找了一圈，还真就找着这样一个简单的函数了，就是很神奇的sigmoid函数(如下)：

    如果把sigmoid函数图像画出来，是如下的样子：

　　 
　　假设你的一个朋友让你回答一道题。可能的结果只有两种：你答对了或没有答对。为了研究你最擅长的题目领域，你做了各种领域的题目。那么这个研究的结果可能是这样的：如果是一道十年级的三角函数题，你有70%的可能性能解出它。但如果是一道五年级的历史题，你会的概率可能只有30%。逻辑回归就是给你这样的概率结果。 
　　 
　　Logistic回归简单分析

　　优点：计算代价不高，易于理解和实现 
　　缺点：容易欠拟合，分类精度可能不高 
　　适用数据类型：数值型和标称型数据

　　我们都知道逻辑回归是和Sigmod函数一起的，为了实现逻辑回归分类器，我们可以在每一个特征上都乘以一个回归系数，然后将所有的结果值相加，将总和代入S函数，进而得到一个范围在0~1之间的数值。任何大于0.5的数据被分人1类，小于0.5被归为0类。 
　　而现在有了分类器的函数了，那么上面提到的最佳回归系数怎么求呢？这里就出现了基于最优化方法的最佳回归系数的确定。 
　　 
　　梯度上升法：要找到某函数的最大值，最好的方法就是沿着该函数的梯度方向探寻。梯度上升法用来求函数的最大值，梯度下降法用来求函数的最小值。

梯度上升法伪代码：

//每个回归系数初始化为1//重复R次：
    //计算整个数据集的梯度
    //使用alpha*gradient更新回归系数的向量
    //返回回归系数

算法思想：

1、训练

1.1、初始化权重：

1.2、加载数据；

1.3、计算hypothesis

1.4、计算Loss

1.5、计算损失函数J（theta）：如果明白变化可以看看极大似然推导公式

1.6、想要最小化损失函数minJ（theta），更新theta（梯度下降法）

即：倒数求解可以私下导一导

2、测试：

练习代码：

1. #! /usr/bin/python   

2. # -*- coding: utf-8 -*-  

3.   

4. import os   

5. import string   

6. import sys  

7. import math  

8.   

9.   

10. class LogisticRegression :  

11.     def __init__ ( self ) :  

12.         self.__X = []   #特征集合  

13.         self.__Y = []    #标签  

14.         self.__theta = []  #权重  

15.         self.__LEARNING_RATE = 7   #学习率  

16.         self.__FEATURE_CNT = 1 + 2   #特征数  

17.         self.__load_training_data ()  #加载数据  

18.         self.__SAMPLE_CNT = len ( self.__Y )   #样本数  

19.         self.__feature_scaling ()   #特征缩放  

20.   

21.         for idx in range ( 0, self.__FEATURE_CNT ) :  

22.             self.__theta.append(0)  

23.   

24.     def __load_training_data(self) :  

25.         fp = open ( "testSet.txt", "r" )  

26.         for line in fp.readlines() :  

27.             (x1, x2,y) = line.strip('\r\n').split ( '\t' )  

28.             self.__X.append ( [1, float(x1), float(x2)] )  

29.             self.__Y.append(float(y))  

30.         fp.close()          

31.   

32.     def __feature_scaling(self) :  

33.         max_value = []  

34.         min_value = []  

35.         for fidx in range ( 0, self.__FEATURE_CNT ) :  

36.             max_value.append(0)  

37.             min_value.append(100)  

38.   

39.         for idx in range ( 0, self.__SAMPLE_CNT) :  

40.             for fidx in range ( 1, self.__FEATURE_CNT ) :  

41.                 if max_value[fidx] < self.__X[idx][fidx] :  

42.                     max_value[fidx] = self.__X[idx][fidx]  

43.                 if min_value[fidx] > self.__X[idx][fidx] :  

44.                     min_value[fidx] = self.__X[idx][fidx]  

45.         for idx in range ( 0, self.__SAMPLE_CNT) :  

46.             x = self.__X[idx]  

47.             for fidx in range ( 1, self.__FEATURE_CNT ) :  

48.                 self.__X[idx][fidx] = ( x[fidx] - min_value[fidx] ) / ( max_value[fidx] - min_value[fidx] )    

49.   

50.   

51.     def batch_learning_alogrithm (self) :  

52.         last_loss = 0  

53.         for  itr in range ( 1, 100000 ) :  

54.             #1、训练数据  

55.             self.__training ()  

56.             loss = self.__get_loss ()  

57.             sys.stdout.write ( "After %s iteratorion loss = %lf\n" % (itr, loss) )  

58.   

59.             if math.fabs ( loss - last_loss)  <= 0.01 :  

60.                 break;  

61.             last_loss = loss  

62.   

63.         sys.stdout.write ( "The coef of the logistic model :\n")  

64.         for idx in range ( 0, self.__FEATURE_CNT ) :  

65.             sys.stdout.write ( "theta[%d] = %lf\n" % ( idx, self.__theta[idx]) )  

66.   

67.     def __training (self) :  

68.         #初始化权重为[0 0 0]  

69.         weight = []  

70.         for idx in range ( 0, self.__FEATURE_CNT ) :  

71.             weight.append(0)   

72.       

73.         """计算loss"""  

74.         for idx in range ( 0, self.__SAMPLE_CNT) :  

75.             x = self.__X[idx]  

76.             y = self.__Y[idx]  

77.             h = self.__sigmoid( x )   

78.             for fidx in range ( 0, self.__FEATURE_CNT ) :  

79.                 weight[fidx] +=  ( h - y ) * x[fidx]  

80.   

81.         """更新权重"""  

82.         for idx in range ( 0, self.__FEATURE_CNT ) :  

83.             self.__theta[idx] -= self.__LEARNING_RATE * weight[idx] / self.__SAMPLE_CNT  

84.   

85.     def __sigmoid ( self, x ) :  

86.         logit = 0  

87.         for idx in range ( 0, self.__FEATURE_CNT):  

88.             logit += self.__theta[idx] * x[idx]  

89.         return 1.0 / ( 1.0 + math.exp ( -logit ) )  

90.           

91.     def __get_loss (self ) :  

92.         loss = 0  

93.         for idx in range ( 0, self.__SAMPLE_CNT) :  

94.             x = self.__X[idx]  

95.             y = self.__Y[idx]  

96.             h = self.__sigmoid( x )   

97.             loss += y * math.log (h) + ( 1 - y ) * math.log ( 1 - h )  

98.         return loss  

99.    

100.   

101.     def test ( self ) :  

102.         wrong_ans = 0  

103.         for idx in range ( 0, self.__SAMPLE_CNT) :  

104.             x = self.__X[idx]  

105.             y = self.__Y[idx]  

106.             h = self.__sigmoid( x )   

107.             check = 0  

108.             if y > 0.5 and h< 0.5  :  

109.                 check = -1  

110.             if y < 0.5 and h > 0.5 :  

111.                 check = -1  

112.             sys.stdout.write ( "样本 %d : 真值 = %.2lf, 预测 = %.2lf check = %d\n" % ( idx, y, h, check ))  

113.             wrong_ans -= check      

114.         print "错误 = %d" % wrong_ans  

115.               

116. if __name__ == "__main__" :  

117.     lr = LogisticRegression()  

118.     lr.batch_learning_alogrithm ()  

119.     lr.test()  

testSet.txt

1. -0.017612   14.053064   0  

2. -1.395634   4.662541    1  

3. -0.752157   6.538620    0  

4. -1.322371   7.152853    0  

5. 0.423363    11.054677   0  

6. 0.406704    7.067335    1  

7. 0.667394    12.741452   0  

8. -2.460150   6.866805    1  

9. 0.569411    9.548755    0  

10. -0.026632   10.427743   0  

11. 0.850433    6.920334    1  

12. 1.347183    13.175500   0  

13. 1.176813    3.167020    1  

14. -1.781871   9.097953    0  

15. -0.566606   5.749003    1  

16. 0.931635    1.589505    1  

17. -0.024205   6.151823    1  

18. -0.036453   2.690988    1  

19. -0.196949   0.444165    1  

20. 1.014459    5.754399    1  

21. 1.985298    3.230619    1  

22. -1.693453   -0.557540   1  

23. -0.576525   11.778922   0  

24. -0.346811   -1.678730   1  

25. -2.124484   2.672471    1  

26. 1.217916    9.597015    0  

27. -0.733928   9.098687    0  

28. -3.642001   -1.618087   1  

29. 0.315985    3.523953    1  

30. 1.416614    9.619232    0  

31. -0.386323   3.989286    1  

32. 0.556921    8.294984    1  

33. 1.224863    11.587360   0  

34. -1.347803   -2.406051   1  

35. 1.196604    4.951851    1  

36. 0.275221    9.543647    0  

37. 0.470575    9.332488    0  

38. -1.889567   9.542662    0  

39. -1.527893   12.150579   0  

40. -1.185247   11.309318   0  

41. -0.445678   3.297303    1  

42. 1.042222    6.105155    1  

43. -0.618787   10.320986   0  

44. 1.152083    0.548467    1  

45. 0.828534    2.676045    1  

46. -1.237728   10.549033   0  

47. -0.683565   -2.166125   1  

48. 0.229456    5.921938    1  

49. -0.959885   11.555336   0  

50. 0.492911    10.993324   0  

51. 0.184992    8.721488    0  

52. -0.355715   10.325976   0  

53. -0.397822   8.058397    0  

54. 0.824839    13.730343   0  

55. 1.507278    5.027866    1  

56. 0.099671    6.835839    1  

57. -0.344008   10.717485   0  

58. 1.785928    7.718645    1  

59. -0.918801   11.560217   0  

60. -0.364009   4.747300    1  

61. -0.841722   4.119083    1  

62. 0.490426    1.960539    1  

63. -0.007194   9.075792    0  

64. 0.356107    12.447863   0  

65. 0.342578    12.281162   0  

66. -0.810823   -1.466018   1  

67. 2.530777    6.476801    1  

68. 1.296683    11.607559   0  

69. 0.475487    12.040035   0  

70. -0.783277   11.009725   0  

71. 0.074798    11.023650   0  

72. -1.337472   0.468339    1  

73. -0.102781   13.763651   0  

74. -0.147324   2.874846    1  

75. 0.518389    9.887035    0  

76. 1.015399    7.571882    0  

77. -1.658086   -0.027255   1  

78. 1.319944    2.171228    1  

79. 2.056216    5.019981    1  

80. -0.851633   4.375691    1  

81. -1.510047   6.061992    0  

82. -1.076637   -3.181888   1  

83. 1.821096    10.283990   0  

84. 3.010150    8.401766    1  

85. -1.099458   1.688274    1  

86. -0.834872   -1.733869   1  

87. -0.846637   3.849075    1  

88. 1.400102    12.628781   0  

89. 1.752842    5.468166    1  

90. 0.078557    0.059736    1  

91. 0.089392    -0.715300   1  

92. 1.825662    12.693808   0  

93. 0.197445    9.744638    0  

94. 0.126117    0.922311    1  

95. -0.679797   1.220530    1  

96. 0.677983    2.556666    1  

97. 0.761349    10.693862   0  

98. -2.168791   0.143632    1  

99. 1.388610    9.341997    0  

100. 0.317029    14.739025   0  

原文出处