首页 > 脚本专栏 > python > Python Logistic算法

Python Logistic逻辑回归算法使用详解

2021-06-06 11:59:44 作者：Want595

这篇文章主要介绍了Python Logistic逻辑回归算法使用的方法和原理,Logistic虽然不是十大经典算法之一,但却是数据挖掘中常用的有力算法,所以这里也专门进行了学习,需要的朋友可以参考下

Logistic回归

优点：计算代价不高，易于理解和实现

缺点：容易欠拟合，分类精度可能不高

适用数据类型：数值型和标称型数据

Sigmoid函数

训练算法-使用梯度上升找到最佳参数

def loadDataSet():
  dataMat = []
  labelMat = []
  fr = open('/content/drive/MyDrive/Colab Notebooks/MachineLearning/《机器学习实战》/Logistic回归/Logistic回归/testSet.txt')
  for line in fr.readlines():
    lineArr = line.strip().split()
    dataMat.append([1.0, float(lineArr[0]), float(lineArr[1])])
    labelMat.append(int(lineArr[2]))
  return dataMat, labelMat

from math import *
def sigmoid(inX):
  return 1.0/(1+exp(-inX))

from numpy import *
def gradAscent(dataMatIn, classLabels):
  dataMatrix = mat(dataMatIn)
  labelMat = mat(classLabels).transpose()
  m, n = shape(dataMatrix)
  alpha = 0.001
  maxCycles = 500
  weights = ones((n, 1))
  for k in range(maxCycles):
    h = sigmoid(dataMatrix * weights)
    error = (labelMat - h)
    weights = weights + alpha * dataMatrix.transpose() * error
  return weights

这是一个使用梯度上升算法进行逻辑回归的函数。主要步骤如下：

导入numpy库，用于矩阵运算。
定义函数gradAscent，接受输入参数dataMatIn和classLabels。
将dataMatIn和classLabels转化为矩阵，并进行转置，得到dataMatrix和labelMat。
获取dataMatrix的行数m和列数n。
设置学习率alpha为0.001，并设定最大迭代次数maxCycles为500。
初始化权重weights为全1的n行1列矩阵。
进行maxCycles次迭代：

a. 计算当前权重对应的预测结果h，通过sigmoid函数将dataMatrix与weights相乘得到。

b. 计算误差error，即真实标签labelMat与预测结果h的差。

c. 更新权重weights，通过乘以学习率alpha，再乘以dataMatrix的转置，再乘以误差error。

返回最终的权重weights。

总结：该函数通过梯度上升算法求解逻辑回归模型的权重参数，其中使用了sigmoid函数作为激活函数，并通过迭代优化权重参数，使得模型的预测结果与真实标签尽可能接近。最终返回的权重参数可以用于预测新的数据样本的类别。

dataArr, labelMat = loadDataSet()

weights = gradAscent(dataArr, labelMat)

分析数据-画出决策边界

import matplotlib.pyplot as plt
def plotBestFit(weights):
  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='red', marker='s')
  ax.scatter(xcord2, ycord2, s=30, c='green')
  x = arange(-3, 3, 0.1)
  y = (-weights[0]-weights[1]*x) / weights[2]
  ax.plot(x, y)
  plt.xlabel('X1')
  plt.ylabel('X2')
  plt.show()

plotBestFit(weights.getA())

训练算法-随机梯度上升

def stocGradAscent0(dataMatrix, classLabels):
  m, n = shape(dataMatrix)
  alpha = 0.01
  weights = ones(n)
  for i in range(m):
    h = sigmoid(sum(dataMatrix[i] * weights))
    error = classLabels[i] - h
    weights = weights + alpha * error * dataMatrix[i]
  return weights

dataArr, labelMat = loadDataSet()
weights = stocGradAscent0(array(dataArr), labelMat)

改进算法-优化梯度算法

def stocGradAscent1(dataMatrix, classLabels, numIter=150):
  m, n = shape(dataMatrix)
  weights = ones(n)
  for j in range(numIter):
    dataIndex = list(range(m))
    for i in range(m):
      alpha = 4/(1+j+i)+0.01
      randIndex = int(random.uniform(0, len(dataIndex)))
      h = sigmoid(sum(dataMatrix[randIndex] * weights))
      error = classLabels[randIndex] - h
      weights = weights + alpha * error * dataMatrix[randIndex]
      del(dataIndex[randIndex])
  return weights

这段代码实现了逻辑回归的随机梯度上升算法。逻辑回归是一种二分类的机器学习算法，用于预测二分类问题的结果。该算法通过最大化似然函数来更新权重，从而使得模型的预测结果与实际结果最接近。

算法的输入包括数据集的特征矩阵(dataMatrix)、数据集的标签(classLabels)和迭代次数(numIter)，默认为150次。其中，特征矩阵是一个m行n列的矩阵，m表示样本的数量，n表示特征的数量；标签是一个长度为m的向量，表示每个样本的分类标签。

算法的输出是更新后的权重(weights)，这些权重用于预测新样本的分类结果。

算法的主要步骤如下：

初始化权重为一个长度为n的向量，每个元素的初始值为1。
对于给定的迭代次数，重复以下步骤：

a. 初始化一个包含样本索引的列表(dataIndex)。

b. 对于每个样本，重复以下步骤：

i. 计算学习率(alpha)，其中alpha的值随着迭代次数和样本的索引i和j的变化而变化。这里使用的是固定的学习率，并加上一个小的常数以避免除零错误。

ii. 从dataIndex中随机选择一个样本的索引(randIndex)。

iii. 计算样本的预测概率(h)。这里使用的是sigmoid函数将线性组合转换为[0, 1]之间的概率值。

iv. 计算误差(error)，即实际标签(classLabels)与预测概率(h)之间的差值。

v. 更新权重(weights)。根据梯度上升算法，使用学习率(alpha)乘以误差(error)乘以样本的特征值(dataMatrix[randIndex])，然后将得到的结果加到权重(weights)上。

vi. 从dataIndex中删除已经使用过的样本索引(randIndex)。

返回更新后的权重。

该算法每次迭代都使用一个随机的样本来更新权重，因此被称为随机梯度上升算法。相比于批量梯度上升算法，随机梯度上升算法的计算效率更高，但收敛速度较慢，并且对于噪声数据更敏感。

dataArr, labelMat = loadDataSet()
weights = stocGradAscent1(array(dataArr), labelMat, 500)
plotBestFit(weights)

到此这篇关于Python Logistic算法使用详解的文章就介绍到这了,更多相关Python Logistic算法内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！