为了账号安全,请及时绑定邮箱和手机立即绑定

机器学习十大算法---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(梯度下降法)


https://img1.sycdn.imooc.com//5adaf20b0001e5fa07330262.jpg


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




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  

原文出处

点击查看更多内容
TA 点赞

若觉得本文不错,就分享一下吧!

评论

作者其他优质文章

正在加载中
  • 推荐
  • 评论
  • 收藏
  • 共同学习,写下你的评论
感谢您的支持,我会继续努力的~
扫码打赏,你说多少就多少
赞赏金额会直接到老师账户
支付方式
打开微信扫一扫,即可进行扫码打赏哦
今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与 放弃机会
意见反馈 帮助中心 APP下载
官方微信

举报

0/150
提交
取消