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()