机器学习实战--logistic回归

 #encoding:utf-8
 from numpy import *

 def loadDataSet():  #加载数据
     dataMat = [];
     labelMat = []
     fr = open('testSet.txt')
     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):    #得到sigmoid函数值
     return 1.0 / (1 + exp(-inX))

 def gradAscent(dataMatIn, classLabels):
     dataMatrix = mat(dataMatIn)  # 转化为numpy矩阵
     labelMat = mat(classLabels).transpose()  # 转化为numpy矩阵，并转置
     m, n = shape(dataMatrix)
     alpha = 0.001
     maxCycles = 500
     weights = ones((n, 1))
     for k in range(maxCycles):  # 迭代maxCycles次   梯度上升算法
         h = sigmoid(dataMatrix * weights)
         error = (labelMat - h)
         weights = weights + alpha * dataMatrix.transpose() * error  # 为什么这么做？参考附件，或者http://download.csdn.net/detail/lewsn2008/6547463，总结的非常好
     return weights

 def plotBestFit(weights):   #画出数据集和最佳拟合曲线
     import matplotlib.pyplot as plt
     dataMat, labelMat = loadDataSet()
     dataArr = array(dataMat)
     #weights = weights.getA()
     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()

 # 梯度上升算法在每次更新回归系数时都需要遍历整个数据集，
 # 该方法在处理100个左右的数据集尚可，但如果数据量增大，那该方法的计算量就太大了，
 # 有一种改进方法是一次仅用一个样本点来更新回归系数，该方法称为随机梯度上升算法，
 # 由于可以在新样本到来时对分类器进行增量式更新，因而随机梯度上升算法是一个在线学习算法。
 def stocGradAscent0(dataMatrix, classLabels):   #随机梯度上升算法
     m, n = shape(dataMatrix)
     alpha = 0.01
     weights = ones(n)  # initialize to all ones
     for i in range(m):
         h = sigmoid(sum(dataMatrix[i] * weights))
         error = classLabels[i] - h
         weights = weights + alpha * error * dataMatrix[i]
     return weights

 def useStocGradAscent0():    #测试随机梯度上升算法
     dataMat, labelMat = loadDataSet()
     weights = stocGradAscent0(array(dataMat), labelMat)
     plotBestFit(weights)

 def useStocGradAscent1():    #测试改进的随机梯度上升算法
     dataMat, labelMat = loadDataSet()
     weights = stocGradAscent1(array(dataMat), labelMat)
     plotBestFit(weights)

 def stocGradAscent1(dataMatrix, classLabels, numIter=150):   #改进的随机梯度上升算法
     m, n = shape(dataMatrix)
     weights = ones(n)
     for j in range(numIter):
         dataIndex = range(m)
         for i in range(m):
             alpha = 4 / (1.0 + j + i) + 0.0001  # 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])
     return weights

 def classifyVector(inX, weights):   #得到类别
     prob = sigmoid(sum(inX * weights))
     if prob > 0.5:
         return 1.0
     else:
         return 0.0

 def colicTest():
     frTrain = open('horseColicTraining.txt');   #读取文件
     frTest = open('horseColicTest.txt')
     trainingSet = [];
     trainingLabels = []
     for line in frTrain.readlines():
         currLine = line.strip().split('\t')
         lineArr = []
         for i in range(21):
             lineArr.append(float(currLine[i]))
         trainingSet.append(lineArr)
         trainingLabels.append(float(currLine[21]))
     trainWeights = stocGradAscent1(array(trainingSet), trainingLabels, 1000)  #用改进的随机梯度上升法训练
     errorCount = 0;
     numTestVec = 0.0
     for line in frTest.readlines():
         numTestVec += 1.0
         currLine = line.strip().split('\t')
         lineArr = []
         for i in range(21):
             lineArr.append(float(currLine[i]))
         if int(classifyVector(array(lineArr), trainWeights)) != int(currLine[21]):    #对测试集分类，并判断是否正确
             errorCount += 1
     errorRate = (float(errorCount) / numTestVec)
     print "the error rate of this test is: %f" % errorRate
     return errorRate

 def multiTest():   #测试
     numTests = 10;
     errorSum = 0.0
     for k in range(numTests):
         errorSum += colicTest()
     print "after %d iterations the average error rate is: %f" % (numTests, errorSum / float(numTests))

 if __name__ == '__main__':
     # dataMat, labelMat = loadDataSet()
     # plotBestFit(gradAscent(dataMat, labelMat).getA())
     #useStocGradAscent1()
     multiTest()

附件：http://files.cnblogs.com/files/yzwhykd/Logistic%E5%9B%9E%E5%BD%92%E6%80%BB%E7%BB%93.pdf