机器学习笔记之梯度下降与logistic回归

最新推荐文章于 2022-08-23 18:00:31 发布

QinZheng7575

最新推荐文章于 2022-08-23 18:00:31 发布

阅读量328

点赞数 1

分类专栏：机器学习文章标签： python 机器学习深度学习人工智能

本文链接：https://blog.csdn.net/QinZheng7575/article/details/104109346

版权

机器学习专栏收录该内容

14 篇文章 2 订阅

订阅专栏

机器学习笔记之梯度下降与logistic回归

梯度下降算法

本博客思路来自于吴恩达的机器学习公开课，开门见山，直接上原理公式
在这里插入图片描述梯度下降算法的直观表示在这里不用多介绍，就像下山一样通过步长，每次贪心的选择方向向下降，祈求最终达到代价函数的最小值。而代价函数（Cost function），根据具体的问题来定义。

在上面的公式中，我们可以看到代价函数就是一个简单的距离，在这里用一个很简单的例子来说：
求f(x)=-x^2+4x最小值点
参考：（https://blog.csdn.net/GXSeveryday/article/details/88141074）

def test():
    def f_prime(x_old):
        return - 2 * x_old + 4
    x_old = -1
    x_new = 0
    step = 0.001
    presision = 0.0000001
    while abs(x_new - x_old) > presision:
        x_old = x_new
        x_new = x_old + step * f_prime(x_old)
    print(x_new)
if __name__ == '__main__':
    test()

x_old为我们开始下降的起点
step则为每次下降的步长
presision为精度
而这个while循环就是我们逐渐下降的一个过程，
每次在f(x)的偏导方向也就是-2x+4下降一个step，再更新x_new与x_old（就是牛顿迭代法的思路）
最终运算的结果约为 1.99995，可以看到已经非常接近2了。

logistic回归

我们首先讨论一下logistic回归解决的是什么问题。它解决的是二分类问题，如图：
在这里插入图片描述
在这个例子中，我们有两个颜色的点，需要用一个边界将他们分开。logistic回归和刚才的梯度下降算法最本质的区别就在于我们的代价函数以及权重函数的选择。
为了能够让我们的权重始终在0到1之间（这里的权重的意义就是情况为1的概率），我们采用了一个sigmoid函数来满足以上要求。
接着考虑代价函数，可以想到，我们要让P(0|1)和P(1|0)这两种情况的代价很大，因为它完全得到了错的结果，而让P(0|0)和P(1|1)这两种情况的代价为0，就代表着我们与实际情况相符。在经过改进，得到如下：在这里插入图片描述
现在我们就对它进行梯度下降，回忆一下我们之前在梯度下降中的操作，不难理解接下来的步骤：
我们首先应该明确，Cost函数已经将我们的二分类问题转换成了一个求凸函数的极值点的问题，因此我们对Cost函数进行求偏导，就是我们每个步长下降的方向，而Cost函数中出现了的权重sigmoid函数，我们也可以通过计算求出值。下面来看一个例子吧：（参考https://www.jb51.net/article/167107.htm）

from numpy import *
filename='D:\ForStudy\python练习\练习\寒假练习\\testSet.txt' #文件目录
def loadDataSet():  #读取数据（这里只有两个特征）
  dataMat = []
  labelMat = []
  fr = open(filename)
  for line in fr.readlines():
    lineArr = line.strip().split()
    dataMat.append([1.0, float(lineArr[0]), float(lineArr[1])])  #前面的1，表示方程的常量。比如两个特征X1,X2，共需要三个参数，W1+W2*X1+W3*X2
    labelMat.append(int(lineArr[2]))
  return dataMat,labelMat

def sigmoid(inX): #sigmoid函数
  return 1.0/(1+exp(-inX))
 
def gradAscent(dataMat, labelMat): #梯度上升求最优参数
  dataMatrix=mat(dataMat) #将读取的数据转换为矩阵
  classLabels=mat(labelMat).transpose() #将读取的数据转换为矩阵
  _,n = shape(dataMatrix)#矩阵大小
  alpha = 0.001 #设置梯度的阀值，该值越大梯度上升幅度越大
  maxCycles = 500 #设置迭代的次数，一般看实际数据进行设定，有些可能200次就够了
  weights = ones((n,1)) #设置初始的参数，并都赋默认值为1。注意这里权重以矩阵形式表示三个参数。
  for k in range(maxCycles):
    h = sigmoid(dataMatrix*weights)
    error = (classLabels - h)   #求导后差值
    weights = weights + alpha * dataMatrix.transpose()* error #迭代更新权重
  return weights
 
def stocGradAscent0(dataMat, labelMat): #随机梯度上升，当数据量比较大时，每次迭代都选择全量数据进行计算，计算量会非常大。所以采用每次迭代中一次只选择其中的一行数据进行更新权重。
  dataMatrix=mat(dataMat)
  classLabels=labelMat
  m,n=shape(dataMatrix)
  alpha=0.01
  maxCycles = 500
  weights=ones((n,1))
  for k in range(maxCycles):
    for i in range(m): #遍历计算每一行
      h = sigmoid(sum(dataMatrix[i] * weights))
      error = classLabels[i] - h
      weights = weights + alpha * error * dataMatrix[i].transpose()
  return weights
 
def stocGradAscent1(dataMat, labelMat): #改进版随机梯度上升，在每次迭代中随机选择样本来更新权重，并且随迭代次数增加，权重变化越小。
  dataMatrix=mat(dataMat)
  classLabels=labelMat
  m,n=shape(dataMatrix)
  weights=ones((n,1))
  maxCycles=500
  for j in range(maxCycles): #迭代
    dataIndex=[i for i in range(m)]
    for i in range(m): #随机遍历每一行
      alpha=4/(1+j+i)+0.0001 #随迭代次数增加，权重变化越小。
      randIndex=int(random.uniform(0,len(dataIndex))) #随机抽样
      h=sigmoid(sum(dataMatrix[randIndex]*weights))
      error=classLabels[randIndex]-h
      weights=weights+alpha*error*dataMatrix[randIndex].transpose()
      del(dataIndex[randIndex]) #去除已经抽取的样本
  return weights
 
def plotBestFit(weights): #画出最终分类的图
  import matplotlib.pyplot as plt
  dataMat,labelMat=loadDataSet()
  dataArr = array(dataMat)
  n = shape(dataArr)[0]
  xcord1 = []; ycord1 = []
  xcord2 = []; ycord2 = []
  for i in range(n):
    if int(labelMat[i])== 1:
      xcord1.append(dataArr[i,1])
      ycord1.append(dataArr[i,2])
    else:
      xcord2.append(dataArr[i,1])
      ycord2.append(dataArr[i,2])
  fig = plt.figure()
  ax = fig.add_subplot(111)
  ax.scatter(xcord1, ycord1, s=30, c='purple', marker='s')
  ax.scatter(xcord2, ycord2, s=30, c='green')
  x = arange(-3.0, 3.0, 0.1)
  y = (-weights[0]-weights[1]*x)/weights[2]
  ax.plot(x, y)
  plt.xlabel('X1')
  plt.ylabel('X2')
  plt.show()
 
def main():
  dataMat, labelMat = loadDataSet()
  weights=gradAscent(dataMat, labelMat).getA()
  plotBestFit(weights)
 
if __name__=='__main__':
  main()

所用到的案例的数据文件如下：

-0.017612   14.053064   0
-1.395634   4.662541    1
-0.752157   6.538620    0
-1.322371   7.152853    0
0.423363    11.054677   0
0.406704    7.067335    1
0.667394    12.741452   0
-2.460150   6.866805    1
0.569411    9.548755    0
-0.026632   10.427743   0
0.850433    6.920334    1
1.347183    13.175500   0
1.176813    3.167020    1
-1.781871   9.097953    0
-0.566606   5.749003    1
0.931635    1.589505    1
-0.024205   6.151823    1
-0.036453   2.690988    1
-0.196949   0.444165    1
1.014459    5.754399    1
1.985298    3.230619    1
-1.693453   -0.557540   1
-0.576525   11.778922   0
-0.346811   -1.678730   1
-2.124484   2.672471    1
1.217916    9.597015    0
-0.733928   9.098687    0
-3.642001   -1.618087   1
0.315985    3.523953    1
1.416614    9.619232    0
-0.386323   3.989286    1
0.556921    8.294984    1
1.224863    11.587360   0
-1.347803   -2.406051   1
1.196604    4.951851    1
0.275221    9.543647    0
0.470575    9.332488    0
-1.889567   9.542662    0
-1.527893   12.150579   0
-1.185247   11.309318   0
-0.445678   3.297303    1
1.042222    6.105155    1
-0.618787   10.320986   0
1.152083    0.548467    1
0.828534    2.676045    1
-1.237728   10.549033   0
-0.683565   -2.166125   1
0.229456    5.921938    1
-0.959885   11.555336   0
0.492911    10.993324   0
0.184992    8.721488    0
-0.355715   10.325976   0
-0.397822   8.058397    0
0.824839    13.730343   0
1.507278    5.027866    1
0.099671    6.835839    1
-0.344008   10.717485   0
1.785928    7.718645    1
-0.918801   11.560217   0
-0.364009   4.747300    1
-0.841722   4.119083    1
0.490426    1.960539    1
-0.007194   9.075792    0
0.356107    12.447863   0
0.342578    12.281162   0
-0.810823   -1.466018   1
2.530777    6.476801    1
1.296683    11.607559   0
0.475487    12.040035   0
-0.783277   11.009725   0
0.074798    11.023650   0
-1.337472   0.468339    1
-0.102781   13.763651   0
-0.147324   2.874846    1
0.518389    9.887035    0
1.015399    7.571882    0
-1.658086   -0.027255   1
1.319944    2.171228    1
2.056216    5.019981    1
-0.851633   4.375691    1
-1.510047   6.061992    0
-1.076637   -3.181888   1
1.821096    10.283990   0
3.010150    8.401766    1
-1.099458   1.688274    1
-0.834872   -1.733869   1
-0.846637   3.849075    1
1.400102    12.628781   0
1.752842    5.468166    1
0.078557    0.059736    1
0.089392    -0.715300   1
1.825662    12.693808   0
0.197445    9.744638    0
0.126117    0.922311    1
-0.679797   1.220530    1
0.677983    2.556666    1
0.761349    10.693862   0
-2.168791   0.143632    1
1.388610    9.341997    0
0.317029    14.739025   0

得到的结果就是上面的图，
在这里插入图片描述总结一下，重点就是Cost函数怎么来的，凭什么要这样设置函数就刚刚好满足解决二分类问题的要求，这一部分请参考吴恩达机器学习公开课的内容，在这里就不赘述了，反正人家比我讲的好

QinZheng7575

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
机器学习笔记之梯度下降与logistic回归

机器学习笔记之梯度下降与logistic回归梯度下降算法本博客思路来自于吴恩达的机器学习公开课，开门见山，直接上原理公式梯度下降算法的直观表示在这里不用多介绍，就像下山一样通过步长，每次贪心的选择方向向下降，祈求最终达到代价函数的最小值。而代价函数（Cost function），根据具体的问题来定义。在上面的公式中，我们可以看到代价函数就是一个简单的距离...
复制链接

扫一扫

专栏目录