《机器学习实战》chapter05 Logistic回归

（1）收集数据：任意方法

（2）准备数据：由于需要计算距离，因此要求数据类型为数值型，结构化数据格式则最佳

（3）分析数据：任意方法

（4）训练算法：大部分时间将用于训练，训练的目的是为了找到最佳的分类回归系数

（5）测试算法：一旦训练完成，分类将会很快

Logistic回归

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

对于回归函数的选择，我们想要的是能接受所有的输入然后预测出类型。在两个类别的情况下，上述函数输出0或1，即单位阶跃函数，这里我们使用Sigmoid函数，如果横坐标足够大，Sigmoid函数看起来很像一个阶跃函数，公式如下：

为了实现Logistic回归分类器，我们可以在每个特征上都乘以一个回归系数，然后把所有结果值相加，把这个总和代入Sigmoid函数中进而得到一个0-1之间的数值。任何大于0.5的数据被分入1类，小于0.5的被分入0类。

1、梯度上升优化算法

from numpy import *

# 加载数据
def loadData():
    dataMat = []
    labelMat = []
    fr = open("testSet.txt")
    for line in fr.readlines():
        lineArr = line.strip().split()
        # 为方便计算， X0设置为1
        dataMat.append([1.0, float(lineArr[0]), float(lineArr[1])])
        # 文件中的第三列为类别
        labelMat.append(int(lineArr[2]))
    return dataMat, labelMat


# sigmoid
def sigmoid(inX):
    return 1.0 / (1 + exp(-inX))


# 梯度上升优化算法
def gradAscent(dataMatIn, classLabels):
    dataMatrix = mat(dataMatIn)
    # transpose()矩阵转置
    labelMat = mat(classLabels).transpose()
    m, n = shape(dataMatrix)
    alpha = 0.001
    maxCycles = 500
    weights = ones((n, 1))
    # 重复maxCycles次
    for k in range(maxCycles):
        # 计算整个数据集的梯度，h和error是都是向量
        h = sigmoid(dataMatrix * weights)
        error = (labelMat - h)
        # 更新回归系数向量
        weights = weights + alpha * dataMatrix.transpose() * error
    return weights

可视化方法

# 画出数据集和Logistic回归最佳拟合直线的函数
def plotBestFit(weights):
    import matplotlib.pyplot as plt
    dataMat, labelMat = loadData()
    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.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()

2、随机梯度上升

# 随机梯度上升算法，每次只用数据集中的一个样本点来更新系数，顺序遍历整个数据集
def stocGradAscent0(dataMatrix, classLabels):
    # 强制类型转换，避免array和list混用
    dataMatrix = array(dataMatrix)
    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

3、改进的随机梯度上升

# 改进的随机梯度上升算法, 多加一个迭代次数控制函数
# 在每次迭代中随机地用单个样本点更新数据集，每次迭代，遍历整个数据集
def stocGradAscent1(dataMatrix, classLabels, numIter=150):
    # 强制类型转换，避免array和list混用
    dataMatrix = array(dataMatrix)
    m, n = shape(dataMatrix)
    alpha = 0.01
    weights = ones(n)
    for j in range(numIter):
        dataIndex = list(range(m))
        for i in range(m):
            alpha = 4 / (1.0 + 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