Logistic 回归

Logistic 回归主要用于分类情况，我有一堆数据，我想从某种角度或者按照他们某个特征，分成两类。于是引入分类函数。
如下，我有一堆数据点，

Paste_Image.png

最终我将他们分成活跃的和非活跃的，黑线左边为非活跃的数据，黑线右边为活跃的数据，这条黑线就是目标拟合线，他用来划分将来的某个数据点应该属于左边的非活跃数据点，还是右边的活跃数据点。

Paste_Image.png

用比较理论的语言就是
利用Logistic回归进行分类的主要思想是，根据现有数据对分类边界线建立回归公式，以此进行分类。

流程基本是这样的：

Paste_Image.png

如何找到一个函数，无论x如何变化，y集中在0和1呢？
引入单位阶跃函数，sigmond 函数，
公式为

Paste_Image.png

函数曲线为

Paste_Image.png

可以看出当，z范围越大，阶跃函数分类的性质就会越明显。于是如何让z取得最大值，是分类成功或者失败的保障。

梯度上升算法，是取Z最高值的经典方法。

梯度下降算法流程.jpg

具体可以采用批量梯度上升算法和随机梯度上升算法

批量梯度和随机梯度的区别.jpg

具体的流程如下，最终效果，在更迭学习速率，并且优化随机向量的基础上，计算速率大大提高了。

梯度下降算法.jpg

批量梯度下降python实现

import pandas as pd
import numpy as np
from numpy import *
def loadDataSet():
    dataMat  = [];
    labelMat = [];
    fr = open('test.txt')
    for line in fr.readlines():
        lineArr = line.strip().split()
        dataMat.append([1.0,float(lineArr[0]),float(lineArr[1])])
        #读取数据，dataMat最左侧加一列
        labelMat.append(float(lineArr[2]))
        #数据的最后一列是训练集的判定，y
    return dataMat,labelMat

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

def gradAscent(dataMatIn,classLabels):
    #转换成矩阵类型
    dataMatrix = np.mat(dataMatIn)
    labelMat = np.mat(classLabels).transpose()
    m,n=np.shape(dataMatrix)
    alpha = 0.0001
    maxCycles = 50
    weights = ones((n,1))
    for k in range(maxCycles):
        h=sigmoid(dataMatrix*weights)
        error = (labelMat-h)
        weights = weights+alpha * dataMatrix.transpose()*error
    return weights

def plotBestFit(weights):
    import matplotlib.pyplot as plt
    dataMat,labelMat=loadDataSet()
    dataArr = array(dataMat)
    #labelMat = array(labelMat)
    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=w0x0+w1x1+w2x2

    w0=weights[0]
    w1=weights[1]
    w2=weights[2]
    y=(w0+w1*x)/w2
    ax.plot(x,y)
    plt.xlabel('X1');
    plt.ylabel('X2');
    plt.show()


dataArr,labelMat=loadDataSet()
weights = gradAscent(dataArr,labelMat)
print(weights[1])
plotBestFit(weights.getA())
#将weights以array方式输入

效果如下

Figure_1.png

随机梯度上升算法

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)
print(weights[1])
plotBestFit(weights)
#将weights以array方式输入

效果如下

Figure_2.png

改进的随机梯度上升算法

def stocGradAscent1(dataMatrix,classLabels,numIter=150):
    m,n= shape(dataMatrix)
    weights = ones(n)
    for j in range(numIter):
        dataIndex = list(range(m))
        #print(dataIndex)
        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


dataArr,labelMat=loadDataSet()
weights = stocGradAscent1(array(dataArr),labelMat)
#print(weights[1])
plotBestFit(weights)
#将weights以array方式输入

效果如下

Figure_3.png