logistics回归

logistic回归的基本思想　　

　　logistic回归是一种分类方法，用于两分类问题。其基本思想为：

　　a. 寻找合适的假设函数，即分类函数，用以预测输入数据的判断结果；

　　b. 构造代价函数，即损失函数，用以表示预测的输出结果与训练数据的实际类别之间的偏差；

　　c. 最小化代价函数，从而获取最优的模型参数。

 

import numpy
from numpy import  *
import matplotlib.pyplot as plt
import random
def loadDataSet(filename):
    fr = open(filename)
    dataMat = []
    labelMat = []
    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

#阶跃函数
def sigmoid(inX):
    return 1.0/(1 + numpy.exp(-inX))

#基于梯度上升法的logistic回归分类器
def gradAscent(dataMatIn,classLabels):
    dataMatrix = mat(dataMatIn)
    labelMatrix = mat(classLabels).transpose()
    m , n = shape(dataMatrix)
    alpha = 0.001#步长
    maxCycles = 500
    weights = ones((n,1))
    #对回归系数进行maxCycles次梯度上升
    for i in range(maxCycles):
        h = sigmoid(dataMatrix * weights)
        error = labelMatrix - h
        weights = weights + alpha * dataMatrix.transpose() * error
    return weights

#分析数据：画出决策边界
def plotBestFit(weights):
    dataMat,labelMat = loadDataSet('test.txt')
    dataArr = array(dataMat)
    n = list(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)
    print('xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx',shape(x))

    y = (-weights[0] - weights[1] * x) / weights[2]
    print('-----------------------------------------',shape(y))
    ax.plot(x,y)
    plt.xlabel('X1')
    plt.ylabel('X2')
    plt.show()

#随机梯度上升
def stocGradAscent0(dataMatrix,classLabels):
    m , n = numpy.shape(dataMatrix)
    alpha = 0.01#步长
    weights = numpy.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

#改进的随机梯度上升
def stocGradAscent1(dataMatrix,classLabels,numIter=150):
    m , n = shape(dataMatrix)
    weights = ones(n)
    dataIndex = list(range(m))
    print (dataIndex)
    for j in range(numIter):
        for i in range(m):
            alpha = 4/(1.0+j+i) + 0.1   #alpha每次迭代都要调整
            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]
            print("randIndex",randIndex)
            print("dataIndex",dataIndex)
            if randIndex==0:
                return weights


if __name__ == '__main__':
    dataArr,labelMat = loadDataSet('test.txt')
    weights = stocGradAscent1(array(dataArr),labelMat)
    # weights = gradAscent(dataArr,labelMat)
    # print(shape(weights))
    plotBestFit(weights)

 

 应用：从疝气病预测病马的死亡率

import numpy
from numpy import  *
import matplotlib.pyplot as plt
import random

#阶跃函数
def sigmoid(inX):
    return 1.0/(1 + numpy.exp(-inX))

#分类回归函数
def classifyVector(inX,weights):
    prob = sigmoid(sum(inX * weights))
    if prob > 0.5:
        return 1.0
    else:
        return 0.0

#改进的随机梯度上升算法
def stocGradAscent1(dataMatrix, classLabels, numIter=150):
    m, n = shape (dataMatrix)
    weights = ones (n)
    dataIndex = list (range (m))
    for j in range (numIter):
        for i in range (m):
            alpha = 4 / (1.0 + j + i) + 0.1  # alpha每次迭代都要调整
            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]
            if randIndex == 0:
                return weights

#测试，返回错误率
def colicTest():
    frTrain = open('horseColicTraining.txt')
    frTest = open('horseColicTest.txt')
    trainingSet = []
    trainingLabels = []
    for line in frTrain.readlines():
        curLine = line.strip().split('\t')
        lineArr = []
        for i in range(21):
            lineArr.append(float(curLine[i]))
        trainingSet.append(lineArr)
        trainingLabels.append(float(curLine[21]))
    trainWeights =  stocGradAscent1(array(trainingSet),trainingLabels,500)

    errorCount = 0
    numTestVec = 0
    for line in frTest.readlines():
        numTestVec += 1.0
        curLine = line.strip().split('\t')
        lineArr = []
        for i in range(21):
            lineArr.append(float(curLine[i]))
        if int(classifyVector(array(lineArr),trainWeights)) != int(curLine[21]):
            errorCount += 1
    errorRate = (float(errorCount)/numTestVec)
    print("错误率",errorRate)
    return errorRate


def multiTest():
    numTests = 10
    errorSum = 0.0
    for i in range(numTests):
        errorSum += colicTest()
    print("%d 次迭代之后，平均错误率为%f"%(numTests,errorSum/float(numTests)))

multiTest()