https://blog.csdn.net/u010454729/article/details/48274955
5.1 基于Logistic回归和sigmoid函数的分类
实现Logistic回归分类器：在每个特征上都乘以一个回归系数，然后把所有的结果值相加，总和带入sigmoid函数，其结果大于0.5分为第0类，结果小于0.5分为第0类。
sigmoid函数公式：
Figure 5-1: sigmoid函数公式
Figure 5-2: sigmoid曲线
sigmoid函数具有很好的性质，如其导数可以用其本身表示等等。
5.2 基于最优化方法的最佳回归系数确定
sigmoid函数输入z:
其可以写成z=w.T*x，向量x为分类器的输入数据， w为训练器寻找的最佳参数。
梯度上升法：
思想：要找到某函数的最大值，最好的方法是沿着该函数的梯度方向探寻。
函数f(x,y)的梯度：
沿x的方向移动
，沿y的方向移动
，最后能够到达最优点，但是f(x,y)在待计算点需要有定义并且可微。
梯度算子总是指向函数值增长最快的方向。移动方向为梯度方向，移动量大小需要乘以一个参数，称之为步长。参数迭代公式为：
公式可一直执行，直到某个条件停止为止。如迭代次数或者算法达到某个可以允许的误差范围。
训练算法：使用梯度上升找到最佳参数
梯度上升法伪代码：
数据点：
算法：
def loadDataSet():
dataMat = []
labelMat = []
fr = open("testSet.txt")
for line in fr.readlines():
lineArr = line.strip().split("\t")
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+exp(-inX))
def gradAscent(dataMatIn, classLabels):
'''Logistic回归梯度上升优化算法'''
dataMatrix = mat(dataMatIn) #100行3列
labelMat = mat(classLabels).transpose() #transpose()将1行100列的矩阵转为100行1列mat(classLabels).T也可破
m,n = shape(dataMatrix) #m=100,n=3
alpha = 0.001
maxCycles = 500
weights = ones((n,1)) #100行1列
for k in range(maxCycles):
h = sigmoid(dataMatrix*weights) #dataMatrix*weights，100×3和3×1的矩阵相乘，得到100×1的矩阵
error = (labelMat - h)
weights = weights + alpha*dataMatrix.transpose()*error
return weights
dataMat, labelMat = loadDataSet()
weights = gradAscent(dataMat, labelMat)
print weights
Figure5-4: 算法参数
分析数据：画出决策边界
上一步确定了回归系数，确定了不同类别数据之间的分割线。这一步画出分割线：
def plotBestFit(weights):
dataMat, labelMat = loadDataSet()
dataArr = array(dataMat) #将每个数据点的x,y坐标存为矩阵的形式
n = shape(dataArr)[0] #取其行数,也即数据点的个数
#======画数据点
xcord1 = []
ycord1 = []
xcord2 = []
ycord2 = []
for i in range(n):
if int(labelMat[i]) == 1: #若是正例，存到(x1,y1)中
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) #x为numpy.arange格式，并且以0.1为步长从-3.0到3.0切分。
#拟合曲线为0 = w0*x0+w1*x1+w2*x2, 故x2 = (-w0*x0-w1*x1)/w2, x0为1,x1为x, x2为y,故有
y = (-weights[0] - weights[1]*x)/weights[2]
#x为array格式，weights为matrix格式，故需要调用getA()方法，其将matrix()格式矩阵转为array()格式
ax.plot(x,y)
plt.xlabel("X1")
plt.ylabel("X2")
plt.show()
dataMat, labelMat = loadDataSet()
weights = gradAscent(dataMat, labelMat)
#getA()方法，其将matrix()格式矩阵转为array()格式，type(weights),type(weights.getA())可观察到。
plotBestFit(weights.getA())
Figure 5-5: 分割线
训练算法：随机梯度上升
梯度上升算法中，每次更新回归系数需要遍历整个数据集。数据量若是大了，计算复杂度较高。
改进方法：一次仅用一个样本点更新回归系数，这便是随机梯度上升算法。
伪代码：
代码：
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)) #此处h为具体数值
error = classLabels[i] - h #error也为具体数值
weights = weights + alpha*error*dataMatrix[i] #每次对一个样本进行处理，更新权值
return weights
dataArr, labelMat = loadDataSet()
weights = stocGradAscent0(array(dataArr), labelMat)
plotBestFit(weights)
Figure 5-6: 随机梯度上升算法分割线
结果显示其效果还不如梯度上升算法，不过不一样，梯度上升算法，500次迭代每次都用上了所有数据，而随机梯度上升算法总共也只用了500次。需要对其进行改进：
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+i+j)+0.0001 #alpha迭代次数不断变小，1.非严格下降，2.不会到0
#随机选取样本更新系数weights,每次随机从列表中选取一个值，用过后删除它再进行下一次迭代
randIndex = int(random.uniform(0, len(dataIndex)))#每次迭代改变dataIndex,而m是不变的，故不用unifor(0, m)
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)
plotBestFit(weights)
Figure 5-7: 改进的随机梯度上升算法分割线
5.3 示例：从疝气病症预测病马的死亡率
准备数据：处理数据中的缺失值
可选做法：
- 使用可用特征的均值来填补缺失值
- 使用特殊值来填补缺失值，如-1
- 忽略有缺失值的样本
- 使用相似样本的均值添补缺失值
- 使用另外的机器学习算法预测缺失值
数据挖掘软件clementine几乎可以做以上数据预处理的工作。可破有问题的数据。
数据：
Figure 5-8: train data
Figure 5-9: test data
测试算法：用Logistic回归进行分类
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, 500) #进行500次迭代，计算权重
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 %s iterations the average error rate is: %f " % (numTests, errorSum/float(numTests))
Figure 5-10: 测试结果
5.4 小结
Logistic回归：
优点： 计算代价不高，易于理解和实现。
缺点： 容易欠拟合，分类精度可能不高。
适用数据类型：数值型和标称型数据。