zoukankan      html  css  js  c++  java

  • Logistic回归Machine Learning In Action学习笔记

    利用Logistic回归进行分类的主要思想是：根据现有数据对分类边界线建立回归公式，以此进行分类。
    训练分类器时的做法就是寻找最佳拟合参数，使用的是最优化算法。

    Logistic回归的一般过程
    收集数据：采用任意方法收集数据。
    准备数据：由于需要进行距离计算，因此要求数据类型为数值型。另外，结构化数据格式则最佳。
    分析数据：采用任意方法对数据进行分析。
    训练算法：大部分时间将用于训练，训练的目的是为了找到最佳的分类回归系数。
    测试算法：一旦训练步骤完成，分类将会很快。
    使用算法：首先，我们需要一些输入数据，并将其转换成对应的结构化数值；接着，基于训练好的回归系数就可以对这些数值进行简单的回归计算，判定它们属于哪个类别；在这之后，我们就可以在输出的类别上做一些其他分析工作。

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

    我们想要的函数应该是，能接受所有的输入然后预测出类别。例如，在两个类的情况下，上述函数输出0或1。
    海维塞德阶跃函数（单位阶跃函数）：该函数在跳跃点上从0瞬间跳跃到1，这个瞬间跳跃过程有时很难处理。（用sigmoid改进）
    Sigmoid函数（一种阶跃函数：可以用半开区间上的指示函数的有限次线性组合来表示）：可以输出0或者1，且数学上更易处理。（如果横坐标刻度足够大，在x = 0点处Sigmoid函数看起来很像阶跃函数）
    计算公式：

    为了实现Logistic回归分类器，我们可以在每个特征上乘以一个回归系数，然后把所有的结果值相加，将这个总和代入Sigmoid函数中，进而得到一个范围在0~1之间的数值。最后，结果大于0.5的数据被归入1类，小于0.5的即被归入0类。所以，Logistic回归也可以被看成是一种概率估计。
    （Sigmoid函数的输入记为z）
    最优化算法——梯度上升法：
    要找到某函数的最大值，最好的方法是沿着该函数的梯度方向探寻。

    梯度上升法的伪代码：
    每个回归系数初始化为1
    重复R次：
        计算整个数据集的梯度
        使用`alpha × gradient`更新回归系数的向量
        返回回归系数

    随机梯度上升算法:（在线学习算法）
    一次仅用一个样本点来更新回归系数（梯度上升算法在每次更新回归系数时都需要遍历整个数据集）
    在线学习：在新样本到来时对分类器进行增量式更新
    批处理：一次处理所有数据

    随机梯度上升算法的伪代码：
    所有回归系数初始化为1  
    对数据集中每个样本
            计算该样本的梯度  
            使用alpha × gradient更新回归系数值  
    返回回归系数值

    一个判断优化算法优劣的可靠方法是看它是否收敛，也就是说参数是否达到了稳定值，是否还会不断地变化？
    存在一些不能正确分类的样本点（数据集并非线性可分），在每次迭代时会引发系数的剧烈改变。我们期望算法能避免来回波动，从而收敛到某个值。另外，收敛速度也需要加快。
    改进的随机梯度上升算法：
    1. alpha动态减少机制：alpha在每次迭代的时候都会调整，alpha会随着迭代次数不断减小，但永远不会减小到0，一个常数项(0.01)是为了保证在多次迭代之后新数据仍然具有一定的影响。（如果要处理的问题是动态变化的，那么可以适当加大上述常数项，来确保新的值获得更大的回归系数。）
    alpha每次减少1/(j+i) ，其中j是迭代次数，i是样本点的下标 。这样当j<<max(i)时，alpha就不是严格下降的。避免参数的严格下降也常见于模拟退火算法等其他优化算法中。
    2. 样本随机选择：通过随机选取样本来更新回归系数。这种方法将减少周期性的波动。


    示例：使用Logistic回归估计马疝病的死亡率
    收集数据：给定数据文件。
    准备数据：用Python解析文本文件并填充缺失值。
    分析数据：可视化并观察数据。
    训练算法：使用优化算法，找到最佳的系数。
    测试算法：为了量化回归的效果，需要观察错误率。根据错误率决定是否回退到训练阶段，通过改变迭代的次数和步长等参数来得到更好的回归系数。
    使用算法：实现一个简单的命令行程序来收集马的症状并输出预测结果。

    几种方法处理数据中的缺失值：
    • 使用可用特征的均值来填补缺失值；
    • 使用特殊值来填补缺失值，如-1；
    • 忽略有缺失值的样本；
    • 使用相似样本的均值添补缺失值；
    • 使用另外的机器学习算法预测缺失值。

    此处数据集的预处理：
    1. 所有的缺失值必须用一个实数值来替换，因为NumPy数据类型不允许包含缺失值。这里选择实数0来替换所有缺失值，恰好能适用于Logistic回归。原因在于：
    • 我们需要的是一个在更新时不会影响系数的值。
    • sigmoid(0)=0.5，即它对结果的预测不具有任何倾向性。
    • 将缺失值用0代替既可以保留现有数据，也不需要对优化算法进行修改。
    • 该数据集中的特征取值一般不为0，因此在某种意义上说它也满足“特殊值”这个要求。
    2. 如果在测试数据集中发现了一条数据的类别标签已经缺失，那么我们的简单做法是将该条数据丢弃。

    Logistic回归方法进行分类小结：
    把测试集上每个特征向量乘以最优化方法得来的回归系数，再将该乘积结果求和，最后输入到Sigmoid函数中即可。如果对应的Sigmoid值大于0.5就预测类别标签为1，否则为0。

    所有代码：
    1. # -*- coding:utf8 -*-
    2. from numpy import *
    5. # 梯度上升优化算法
    6. def loadDataSet():
    7.     dataMat, labelMat = [], []
    8.     fr = open('testSet.txt')
    9.     for line in fr.readlines():
    10.         lineArr = line.strip().split()
    11.         dataMat.append([1.0, float(lineArr[0]), float(lineArr[1])])
    12.         labelMat.append(int(lineArr[2]))
    13.     return dataMat, labelMat
    16. def sigmoid(inX):
    17.     return 1.0 / (1 + exp(-inX))
    20. # 梯度上升算法
    21. def gradAscent(dataMatIn, classLabels):
    22.     dataMatrix = mat(dataMatIn)
    23.     labelMat = mat(classLabels).transpose()
    24.     m, n = shape(dataMatrix)
    25.     alpha = 0.001  # 向目标移动的步长
    26.     maxCycles = 500  # 迭代次数
    27.     weights = ones((n, 1))
    28.     for k in range(maxCycles):
    29.         h = sigmoid(dataMatrix * weights)
    30.         error = (labelMat - h)
    31.         weights = weights + alpha * dataMatrix.transpose() * error
    32.     return weights
    35. def plotBestFit(weights):
    36.     import matplotlib.pyplot as plt
    37.     dataMat, labelMat = loadDataSet()
    38.     dataArr = array(dataMat)
    39.     n = shape(dataArr)[0]
    40.     xcord1, ycord1, xcord2, ycord2 = [], [], [], []
    41.     for i in range(n):
    42.         if int(labelMat[i]) == 1:
    43.             xcord1.append(dataArr[i, 1])
    44.             ycord1.append(dataArr[i, 2])
    45.         else:
    46.             xcord2.append(dataArr[i, 1])
    47.             ycord2.append(dataArr[i, 2])
    48.     fig = plt.figure()
    49.     ax = fig.add_subplot(111)
    50.     ax.scatter(xcord1, ycord1, s=30, c='red', marker='s')
    51.     ax.scatter(xcord2, ycord2, s=30, c='green')
    52.     x = arange(-3.0, 3.0, 0.1)
    53.     y = (-weights[0] - weights[1] * x) / weights[2]
    54.     ax.plot(x, y)
    55.     plt.xlabel('X1')
    56.     plt.ylabel('X2')
    57.     plt.show()
    60. # 随机梯度上升算法
    61. def stocGradAscent0(dataMatrix, classLabels):
    62.     dataMatrix = array(dataMatrix)
    63.     m, n = shape(dataMatrix)
    64.     alpha = 0.01
    65.     weights = ones(n)
    66.     for i in range(m):
    67.         h = sigmoid(sum(dataMatrix[i] * weights))
    68.         error = classLabels[i] - h
    69.         weights = weights + alpha * error * dataMatrix[i]
    70.     return weights
    73. # 改进的随机梯度上升算法
    74. def stocGradAscent1(dataMatrix, classLabels, numIter=150):
    75.     import random
    76.     m, n = shape(dataMatrix)
    77.     weights = ones(n)
    78.     for j in range(numIter):
    79.         dataIndex = range(m)
    80.         for i in range(m):
    81.             # alpha每次迭代时需要调整，一个常数项(0.01)是为了保证在多次迭代之后新数据仍然具有一定的影响
    82.             alpha = 4 / (1.0 + j + i) + 0.01
    83.             # 通过随机选取样本来更新回归系数，将减少周期性的波动
    84.             randIndex = int(random.uniform(0, len(dataIndex)))
    85.             h = sigmoid(sum(dataMatrix[randIndex] * weights))
    86.             error = classLabels[randIndex] - h
    87.             weights = weights + alpha * error * dataMatrix[randIndex]
    88.             del(dataIndex[randIndex])
    89.     return weights
    92. def classifyVector(inX, weights):
    93.     prob = sigmoid(sum(inX * weights))
    94.     if prob > 0.5:
    95.         return 1.0
    96.     else:
    97.         return 0.0
    100. def colicTest():
    101.     frTrain = open('horseColicTraining.txt')
    102.     frTest = open('horseColicTest.txt')
    103.     trainingSet, trainingLabels = [], []
    104.     for line in frTrain.readlines():
    105.         currLine = line.strip().split('\t')
    106.         lineArr = []
    107.         for i in range(21):
    108.             lineArr.append(float(currLine[i]))
    109.         trainingSet.append(lineArr)
    110.         trainingLabels.append(float(currLine[21]))
    111.     trainWeights = stocGradAscent1(array(trainingSet), trainingLabels, 500)
    113.     errorCount, numTestVec = 0, 0.0
    114.     for line in frTest.readlines():
    115.         numTestVec += 1.0
    116.         currLine = line.strip().split('\t')
    117.         lineArr = []
    118.         for i in range(21):
    119.             lineArr.append(float(currLine[i]))
    120.         if int(classifyVector(array(lineArr), trainWeights)) != int(currLine[21]):
    121.             errorCount += 1
    122.     errorRate = (float(errorCount) / numTestVec)
    123.     print "the error rate of this test is: %f" % errorRate
    124.     return errorRate
    127. def multiTest():
    128.     numTests = 10
    129.     errorSum = 0.0
    130.     for k in range(numTests):
    131.         errorSum += colicTest()
    132.     print "after %d iterations the average error rate is:%f" % (numTests, errorSum / float(numTests))

    参考资料：
    1. Peter Harrington《机器学习实战》第五章




    你好，这里是woaielf的博客。 我是编程爱好者，医学生，梦想职业是数据分析师，正在努力转型。 欢迎阅读，敬请批评指正。
  • 相关阅读:
    在VMware中使用Nat方式设置静态IP
    saltstack实现自动化扩容
    saltstack常用模块
    saltstack之nginx、php的配置
    桶排序
    【前端安全】JavaScript防http劫持与XSS
    memcached
    10 行 Python 代码写的模糊查询
    为什么print在python3中变成了函数？
    一行python代码实现树结构
  • 原文地址：https://www.cnblogs.com/woaielf/p/5473149.html
Copyright © 2011-2022 走看看