Logistic回归和Sigmoid函数

发表于 | 更新于: | 分类于 |
字数统计: 1,625字

一、概述

1. 原理：

  • 工作机制：

2. 优缺点

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

理论 ### 二、算法流程 1. 收集数据：anyway 2. 准备数据：需要数值型(要进行距离计算)，结构化数据格式最佳 3. 分析数据：anyway 4. 训练算法：大部分时间将用于训练，训练的目的是为了找到最佳的分类回归系数 5. 测试算法：一旦训练步骤完成，分类将会很快 6. 使用算法： * 步骤一：输入一些数据，并将其转换成对应的结构化数值； * 步骤二：基于训练好的回归系数对数值进行简单的回归计算，判定它们属于哪个类别；随后在输出的类别上做一些其他的分析工作

三、算法实践

错误合集

1.问题

  • 准备数据
  • 打开文件并逐行读取 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    def loadDataSet():
        # 定义数据集和标签
        dataMat = []
        labelMat = []
        # 读取文件
        fr = open('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
1
2
3
4
5
6
>>> import logRegres
>>> dataArr,labelMat = logRegres.loadDataSet()
>>> logRegres.gradAscent(dataArr,labelMat)
matrix([[ 4.12414349],
        [ 0.48007329],
        [-0.6168482 ]])
  • 回归函数和梯度上升算法 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    #回归函数
    def sigmoid(intX):
        return 1.0/(1+exp(-intX))

    # 梯度上升算法
    def gradAscent(dataMatIn,classLabels):
        # 转换为Numpy数据类型
        dataMatrix = mat(dataMatIn)
        labelMat = mat(classLabels).transpose()
        # 矩阵大小
        m, n = shape(dataMatrix)
        # 步长
        alpha = 0.001
        # 迭代次数
        maxCycles = 500
        # 系数矩阵初始化为1
        weights = ones((n, 1))
        for k in range(maxCycles):
            # 变量h是一个列向量，元素个数等于样本个数
            h = sigmoid(dataMatrix*weights)
            error = (labelMat-h)
            weights = weights+alpha*dataMatrix.transpose()*error
        return weights

2.分析数据

  • 利用Matplotlib画图
  • 画出数据集和Logistic最佳拟合直线 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    # 画出最佳拟合直线
    def plotBestFit(wei):
        import matplotlib.pyplot as plt
        # 矩阵变为数组
        weights = wei.getA()
        # 加载数据
        dataMat, labelMat = loadDataSet()
        # 转化为数组
        dataArr = array(dataMat)
        # 数据的列数目
        n = shape(dataArr)[0]
        # 用于存放类1的点
        xcord1 = []
        ycord1 = []
        # 用于存放类2的点
        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.0, 3.0, 0.1)
        # 画出分类的边界，函数的系数由之前的梯度上升算法求得
        y = (-weights[0]-weights[1]*x)/weights[2]
        ax.plot(x, y)
        plt.xlabel('X1')
        plt.ylabel('X1')
        plt.show()

3.训练算法

缺点：
  • 对于以上的算法，每次更新回归系数我们都需要遍历整个数据集，如果数据量过大，数亿或者成千上万个特征，那么==计算复杂度==就太高。 ##### 改进：每次仅用一个样本更改回归系数，这种方法就成为==随机梯度上升算法==。
  • 这种在样本到来时对分类器进行增量更新的方式可以称为在线学习算法。相应的，一次处理所有数据称为批处理。
1
2
3
4
5
6
7
8
9
10
11
12
# 随机梯度上升算法
def stocGradAscent0(dataMatrix,classLabels):
    # 无矩阵转换过程
    m, n = shape(dataMatrix)
    alpha = 0.01
    weights = ones(n)
    for i in range(m):
        # 变量h和误差error都是数值
        h = sigmoid(sum(dataMatrix[i]*weights))
        error = (classLabels[i]-h)
        weights = weights + alpha * error * dataMatrix[i]
    return weights

##### 改进 * 从结果中可以看出分类效果并不是很好，这主要是和迭代的次数和步长有关系，我们进一步修改算法，让迭代步长随着迭代次数的增加逐渐变小。另外，我们可以随机选取样本更新系数。 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def stocGradAscent1(dataMatrix, classLabels, numIter=150):
    m,n = shape(dataMatrix)
    weights = ones(n)   #initialize to all ones
    for j in range(numIter):
        dataIndex = list(range(m))
        for i in range(m):
            # alpha在每次迭代时不断减小，但不会减到0
            alpha = 4/(1.0+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]
            # 删除，进行下一次迭代
            del(dataIndex[randIndex])
    return weights

四.示例：预测病马的死亡率

1.问题：数据缺失

  • 解决办法：
  • 1.用可用特征的均值来替代
  • 2.用特殊值来替代，如-1
  • 3.忽略有缺失值的样本
  • 4.使用相识样本的均值来替代
  • 5.使用另外的机器学习算法预测缺失值 #### 2.准备数据：处理数据的缺失值
  • 用实数0来替换所有的缺失值（==NumPy数据类型不允许包含缺失值==）
  • 作者自己并没有给出具体的实现方法（待补充）

3.测试算法：用Logistic回归进行分类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
# 通过输入回归系数和特征向量来计算对应sigmoid的值
def classifyVector(inX, weights):
    prob = sigmoid(sum(inX*weights))
    if prob > 0.5:
        return 1.0
    else:
        return 0.0

def colicTest():
    # 导入数据
    frTrain = open('horseColicTraining.txt')
    frTest = open('horseColicTest.txt')
    trainingSet = []; trainingLabels = []
    for line in frTrain.readlines():
        currLine = line.strip().split('\t')
        lineArr =[]
        for i in range(21):
            lineArr.append(float(currLine[i]))
        trainingSet.append(lineArr)
        trainingLabels.append(float(currLine[21]))
    # 导入数据完成后利用stocGradAscent1（）来计算回归系数向量
    trainWeights = stocGradAscent1(array(trainingSet), trainingLabels, 1000)
    errorCount = 0
    numTestVec = 0.0
    # 导入测试集并计算分类错误率
    for line in frTest.readlines():
        numTestVec += 1.0
        currLine = line.strip().split('\t')
        lineArr =[]
        for i in range(21):
            lineArr.append(float(currLine[i]))
        if int(classifyVector(array(lineArr), trainWeights))!= int(currLine[21]):
            errorCount += 1
    errorRate = (float(errorCount)/numTestVec)
    print("the error rate of this test is: %f" % errorRate)
    return errorRate

# 调用colicTest()函数10次并求结果的平均值
def multiTest():
    numTests = 10
    errorSum=0.0
    for k in range(numTests):
        errorSum += colicTest()
    print("after %d iterations the average error rate is: %f" % (numTests, errorSum/float(numTests)))
  • 在有30%的数据缺失的情况下，得到平均错误率约为33%
  • 通过调整colicTest()中的迭代次数和stocGradAscent1()中的步长，平均错误率可以降到20%左右