Logistic回归

---

优点:

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

缺点:

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

适用数据类型:

数值型和标称型数据

---

二分类问题

在二维平面划分数据(http://pan.baidu.com/s/1skSMVXr 密码：q9av ):

如图所示,图上的数据点是样本数据，可通过一条直线大致划分数据，我们正是要寻找这样一条直线，直线公式为:

f(X) = W*X + b

X为特征向量，W为权重向量，我们正是要求得W和b的值，
将该公式推广至N维:

f(x1,x2,x3...xn) = w1*x1 + w2*x2 + w3*x3 +...+ wn*xn + b*1
==>f(x) = W*X
#W = [w1,w2,w3...wn,b]
#X = [x1,x2,x3...xb,1]

Sigmoid

sigmoid函数公式:

sigmoid函数图像:

如图，该函数极值为1，0，x=0时，其函数值为0.5,输入的值越接近0，函数值变化越大。
将f(x)代入sigmoid，若f(x) > 0,sigmoid(f(x)) > 0.5.
若f(x) < 0,sigmoid(f(x)) < 0.5.我们正是要求得一个W 使得样本中两个分类中最接近回归直线的样本点在其正确位置上尽量远离直线。对于sigmoid函数值也可看作该样本点属于1分类的概率。

代码实现:

import numpy as np
def sigmoid(x):
    return 1/(1 + np.exp(-x))

梯度上升算法

梯度上升算法用于寻找最佳的W值

梯度记作▽,f(x,y)的梯度如下表示:

这个梯度意味着要沿x方向移动 ，沿y的方向移动
一个实例:

梯度上升算法到达每个点后都会重新估计移动的方向。从p0开始，计算完该点的梯度，函数就根据梯度移动到下一点p1 。在p1点梯度再次被重新计算，并沿新的梯度方向移动到p2。如此循环迭代，直到满足停止条件。迭代的过程中，梯度算子总是保证我们能选取到最佳的移动方向。这里所说的是移动方向，而未提到移动量的大小。该量值称为步长，记做α。用向量来表示的话，梯度算法的迭代公式如下：

梯度上升算法代码实现：

def gradAscent(dataset, labels):
    if not isinstance(dataset, np.ndarray):
        dataset = np.array(dataset, dtype=np.float32)
    if not isinstance(labels, np.ndarray):
        labels = np.array(labels, dtype=np.float32)
        labels.shape = (labels.shape[0], 1)
    m, n = dataset.shape
    alpha = 0.001
    maxCycles = 500
    weights = np.ones((n, 1))
    x = [[1],[1],[1]]
    y = 0
    for i in range(maxCycles):
        h = sigmoid(np.dot(dataset, weights))
        error = labels - h
        weights = weights + alpha * np.dot(dataset.transpose(), error)
        x[0].append(weights[0])
        x[1].append(weights[1])
        x[2].append(weights[2])
        y += 1
    return weights, x, y

决策边界

W的训练变化

随机梯度上升算法

梯度上升算法在每次更新回归系数时都需要遍历整个数据集,如果有数十亿样本和成千上万的特征，那么该方法的计算复杂度就太高了。一种改进方法是一次仅用一个样本点来更新回归系数,该方法称为随机梯度上升算法。 由于可以在新样本到来时对分类器进行增量式更新，因而随机梯度上升算法是一个在线学习算法。

随机梯度上升算法实现V1

####随机梯度上升算法version-1
def stocGradAscent0(dataset, labels):
    if not isinstance(dataset, np.ndarray):
        dataset = np.array(dataset, dtype=np.float32)
    if not isinstance(labels, np.ndarray):
        labels = np.array(labels, dtype=np.float32)
    m, n = dataset.shape
    alpha = 0.001
    weights = np.ones(n)
    x = [[1],[1],[1]]
    y = 0
    for i in range(m):
        h = sigmoid(np.sum(dataset[i] * weights))
        error = labels[i] - h
        weights = weights + alpha * error * dataset[i]
        x[0].append(weights[0])
        x[1].append(weights[1])
        x[2].append(weights[2])
        y += 1
    return weights, x, y

绘制决策边界V1

由于数据量太小，只有100条，其分类效果较为差劲,还未达到收敛。

W的训练变化

随机梯度上升算法实现V2

####随机梯度上升算法version-2
def stocGradAscent1(dataset, labels, numIter = 150):
    from random import sample
    if not isinstance(dataset, np.ndarray):
        dataset = np.array(dataset, dtype=np.float32)
    if not isinstance(labels, np.ndarray):
        labels = np.array(labels, dtype=np.float32)
    m, n = dataset.shape
    weights = np.ones(n)
    x = [[1],[1],[1]]
    y = 0
    for j in range(numIter):
        index = sample(range(m), m)
        for i in range(m):
            alpha = 4/(1.0+i+j) + 0.01
            h = sigmoid(np.sum(dataset[index[i]] * weights))
            error = labels[index[i]] - h
            weights = weights + alpha * error * dataset[index[i]]
            x[0].append(weights[0])
            x[1].append(weights[1])
            x[2].append(weights[2])
            y += 1
    return weights, x, y

绘制决策边界

可以看出，效果与梯度上升算法相仿，但是消耗的计算资源较少。

W的训练变化

使用样本随机选择和alpha动态减少机制的随机梯度上升算法,该方法比采用固定alpha的方法收敛速度更快

画图函数

def loadDataset():
    dataset = []
    labels = []
    with open('testSet.txt') as f:
        for line in f:
            line = line.strip().split()
            dataset.append([1.0, float(line[0]), float(line[1])])
            labels.append(int(line[2]))
    return dataset, labels

def plotBestFit(dataset=None, labels=None):
    import matplotlib.pyplot as plt
    if dataset is None:
        dataset, labels = loadDataset()
    dataset = np.array(dataset, dtype=np.float32)
    num = dataset.shape[0]
    # weights, wx, wy = gradAscent(dataset, labels)
    # weights, wx, wy = stocGradAscent0(dataset, labels)
    weights, wx, wy = stocGradAscent1(dataset, labels)
    xcord1 = []
    ycord1 = []
    xcord0 = []
    ycord0 = []
    for i in range(num):
        if labels[i] == 1:
            xcord1.append(dataset[i][1])
            ycord1.append(dataset[i][2])
        else:
            xcord0.append(dataset[i][1])
            ycord0.append(dataset[i][2])
    fig = plt.figure()
    ax = fig.add_subplot(111)
    ax.scatter(xcord0, ycord0, s=30, c='red', marker='s')
    ax.scatter(xcord1, ycord1, s=30, c='green')
    x = np.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()
    plotW(wx, wy)       

def plotW(x, y):
    import matplotlib.pyplot as plt
    plt.figure(1)
    ax1 = plt.subplot(311)
    ax2 = plt.subplot(312)
    ax3 = plt.subplot(313)
    ax1.plot(range(y+1), x[0])
    ax2.plot(range(y+1), x[1])
    ax3.plot(range(y+1), x[2])
    plt.show()

分类函数

def classify(inx, weights):
    prob = sigmoid(sum(inx*weights))
    if prob > 0.5:
        return 1.0
    else:
        return 0.0