一、概述
1、Logistic回归
假设现在有一些数据点，我们利用一条直线对这些点进行拟合(该线称为最佳拟合直线)，这个拟合过程就称作为回归
Logistic回归是分类方法，利用的是Sigmoid函数阈值在[0,1]这个特性。Logistic回归进行分类的主要思想是：根据现有数据对分类边界线建立回归公式，以此进行分类。
2、sigmoid函数
如果我们有合适的参数列向量θ([θ0,θ1,…θn]^T)，以及样本列向量x([x0,x1,…,xn])，那么我们对样本x分类就可以通过上述公式计算出一个概率，如果这个概率大于0.5，我们就可以说样本是正样本，否则样本是负样本。举个例子，对于"垃圾邮件判别问题"，对于给定的邮件(样本)，我们定义非垃圾邮件为正类，垃圾邮件为负类。我们通过计算出的概率值即可判定邮件是否是垃圾邮件。
3、如何得到合适的参数向量θ?
根据sigmoid函数的特性：
在已知样本x和参数θ的情况下，样本x属性正样本(y=1)和负样本(y=0)的条件概率
把上述两个概率公式合二为一：
这个函数称为代价函数，给定一个样本，我们就可以通过这个代价函数求出，样本所属类别的概率，而这个概率越大越好，所以也就是求解这个代价函数的最大值。利用最大似然估计假定样本与样本之间相互独立，那么整个样本集生成的概率即为所有样本生成概率的乘积，再将公式对数化：
m为样本的总数，y(i)表示第i个样本的类别，x(i)表示第i个样本，需要注意的是θ是多维向量，x(i)也是多维向量。
满足J(θ)的最大的θ值即是我们需要求解的模型
求最大值=>使用梯度上升算法
4、梯度上升算法
梯度上升迭代公式为：
推导过程：
4、Logistic回归的一般过程
- 收集数据：采用任意方法收集数据。
- 准备数据：由于需要进行距离计算，因此要求数据类型为数值型。另外，结构化数据格式则最佳。
- 分析数据：采用任意方法对数据进行分析。
- 训练算法：大部分时间将用于训练，训练的目的是为了找到最佳的分类回归系数。
- 测试算法：一旦训练步骤完成，分类将会很快。
- 使用算法：首先，我们需要输入一些数据，并将其转换成对应的结构化数值；接着，基于训练好的回归系数，就可以对这些数值进行简单的回归计算，判定它们属于哪个类别；在这之后，我们就可以在输出的类别上做一些其他分析工作。
二、实战案例
1、数据准备
编写代码查看数据分布情况：
假设Sigmoid函数的输入记为z，那么z=w0x0 + w1x1 + w2x2，即可将数据分割开。其中，x0为全是1的向量，x1为数据集的第一列数据，x2为数据集的第二列数据。另z=0，则0=w0 + w1x1 + w2x2。横坐标为x1，纵坐标为x2。这个方程未知的参数为w0，w1，w2，也就是我们需要求的回归系数(最优参数)。
2、训练算法
编写代码求解最优参数：w0 w1 w2
3、绘制决策边界
Logistic回归的目的是寻找一个非线性函数Sigmoid的最佳拟合参数，求解过程可以由最优化算法完成。
4、改进梯度上升算法
梯度上升算法在每次更新回归系数(最优参数)时，都需要遍历整个数据集，计算复杂度太高，**一次只用一个样本点去更新回归系数(最优参数)**有效减少计算量 随机梯度上升算法
改进之处：
1）调整alpha，alpha会随着迭代次数不断减小，但永远不会减小到0，为了保证在多次迭代之后新数据仍然具有一定的影响。在降低alpha的函数中，alpha每次减少1/(j+i)，其中j是迭代次数，i是样本点的下标。
2）更新回归系数(最优参数)，只使用一个样本点，并且选择的样本点是随机的，每次迭代不使用已经用过的样本点。有效地减少了计算量，并保证了回归效果。
代码汇总
from matplotlib.font_manager import FontProperties
import matplotlib.pyplot as plt
import numpy as np
import random
"""
函数说明：加载数据
Returns：
dataMat - 数据列表
labelMat - 标签列表
"""
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]))
# 关闭文件
fr.close()
return dataMat, labelMat
"""
函数说明：绘制数据集
"""
def plotDataSet():
# 加载数据集
dataMat, labelMat = loadDataSet()
# 转换成numpy的array数组
dataArr = np.array(dataMat)
# 数据个数
n = np.shape(dataMat)[0]
# 正样本
xcord1 = []
ycord1 = []
# 负样本
xcord2 = []
ycord2 = []
for i in range(n):
# 1为正样本
if int(labelMat[i]) == 1:
xcord1.append(dataArr[i, 1])
ycord1.append(dataArr[i, 2])
# 0为负样本
else:
xcord2.append(dataArr[i, 1])
ycord2.append(dataArr[i, 2])
fig = plt.figure()
# 添加subplot
ax = fig.add_subplot(111)
# 绘制正样本
ax.scatter(xcord1, ycord1, s=20, c='red', marker='s', alpha=.5)
# 绘制负样本
ax.scatter(xcord2, ycord2, s=20, c='green', alpha=.5)
plt.title('DataSet')
plt.xlabel('x')
plt.ylabel('y')
plt.show()
"""
函数说明：sigmoid函数
Parameters：
inX - 数据
Returns：
sigmoid函数
"""
def sigmoid(inX):
return 1.0 / (1 + np.exp(-inX))
"""
函数说明：梯度上升算法
Parameters：
dataMatIn - 数据集
classLabels - 数据标签
Returns：
weights.getA() - 求得的权重数组（最优参数）
"""
def gradAscent(dataMatIn, classLabels):
# 转换成numpy的mat
dataMatrix = np.mat(dataMatIn)
# 转换成numpy的mat,并进行转置
labelMat = np.mat(classLabels).transpose()
# 返回dataMatrix的大小。m为行数,n为列数。
m, n = np.shape(dataMatrix)
# 移动步长,也就是学习速率,控制更新的幅度。
alpha = 0.001
# 最大迭代次数
maxCycles = 500
weights = np.ones((n,1))
for k in range(maxCycles):
# 梯度上升矢量化公式
# g(X)=h(theta) = theta * X
h = sigmoid(dataMatrix * weights)
error = labelMat - h
# theta = theta + alpha * X^T(y - g(X))
weights = weights + alpha * dataMatrix.transpose() * error
return weights.getA()
"""
函数说明：绘制数据集
Parameters：
weights - 权重参数数组
"""
def plotBestFit(weights):
# 加载数据集
dataMat, labelMat = loadDataSet()
# 转换成numpy的array数组
dataArr = np.array(dataMat)
# 数据个数
n = np.shape(dataMat)[0]
# 正样本
xcord1 = []
ycord1 = []
# 负样本
xcord2 = []
ycord2 = []
# 根据数据集标签进行分类
for i in range(n):
# 1为正样本
if int(labelMat[i]) == 1:
xcord1.append(dataArr[i,1]); ycord1.append(dataArr[i,2])
# 0为负样本
else:
xcord2.append(dataArr[i,1]); ycord2.append(dataArr[i,2])
fig = plt.figure()
# 添加subplot
ax = fig.add_subplot(111)
# 绘制正样本
ax.scatter(xcord1, ycord1, s=20, c='red', marker='s', alpha=.5)
# 绘制负样
ax.scatter(xcord2, ycord2, s=20, c='green', alpha=.5)
x = np.arange(-3.0, 3.0, 0.1)
y = (-weights[0] - weights[1] * x) / weights[2]
ax.plot(x, y)
plt.title('BestFit')
plt.xlabel('X1')
plt.ylabel('X2')
plt.show()
"""
函数说明：随机梯度上升算法
"""
def stocGradAscent1(dataMatrix, classLabels, numIter=150):
# 返回dataMatrix的大小。m为行数,n为列数。
m, n = np.shape(dataMatrix)
# 参数初始化
weights = np.ones(n)
for j in range(numIter):
dataIndex = list(range(m))
for i in range(m):
# 降低alpha的大小，每次减小1/(j+i)。
alpha = 4 / (1.0 + j + i) + 0.01
# 随机选取样本
randIndex = int(random.uniform(0, len(dataIndex)))
# 选择随机选取的一个样本，计算h
h = sigmoid(sum(dataMatrix[randIndex] * weights))
# 计算误差
error = classLabels[randIndex] - h
# 更新回归系数
weights = weights + alpha * error * dataMatrix[randIndex]
# 删除已经使用的样本
del (dataIndex[randIndex])
return weights
"""
函数说明:绘制回归系数与迭代次数的关系
Parameters:
weights_array1 - 回归系数数组1
weights_array2 - 回归系数数组2
"""
def plotWeights(weights_array1, weights_array2):
# 设置汉字格式
font = FontProperties(fname=r"c:\windows\fonts\simsun.ttc", size=14)
# 将fig画布分隔成1行1列,不共享x轴和y轴,fig画布的大小为(13,8)
# 当nrow=3,nclos=2时,代表fig画布被分为六个区域,axs[0][0]表示第一行第一列
fig, axs = plt.subplots(nrows=3, ncols=2, sharex=False, sharey=False, figsize=(20, 10))
x1 = np.arange(0, len(weights_array1), 1)
# 绘制w0与迭代次数的关系
axs[0][0].plot(x1, weights_array1[:, 0])
axs0_title_text = axs[0][0].set_title(u'梯度上升算法：回归系数与迭代次数关系', FontProperties=font)
axs0_ylabel_text = axs[0][0].set_ylabel(u'W0', FontProperties=font)
plt.setp(axs0_title_text, size=20, weight='bold', color='black')
plt.setp(axs0_ylabel_text, size=20, weight='bold', color='black')
# 绘制w1与迭代次数的关系
axs[1][0].plot(x1, weights_array1[:, 1])
axs1_ylabel_text = axs[1][0].set_ylabel(u'W1', FontProperties=font)
plt.setp(axs1_ylabel_text, size=20, weight='bold', color='black')
# 绘制w2与迭代次数的关系
axs[2][0].plot(x1, weights_array1[:, 2])
axs2_xlabel_text = axs[2][0].set_xlabel(u'迭代次数', FontProperties=font)
axs2_ylabel_text = axs[2][0].set_ylabel(u'W2', FontProperties=font)
plt.setp(axs2_xlabel_text, size=20, weight='bold', color='black')
plt.setp(axs2_ylabel_text, size=20, weight='bold', color='black')
x2 = np.arange(0, len(weights_array2), 1)
# 绘制w0与迭代次数的关系
axs[0][1].plot(x2, weights_array2[:, 0])
axs0_title_text = axs[0][1].set_title(u'改进的随机梯度上升算法：回归系数与迭代次数关系', FontProperties=font)
axs0_ylabel_text = axs[0][1].set_ylabel(u'W0', FontProperties=font)
plt.setp(axs0_title_text, size=20, weight='bold', color='black')
plt.setp(axs0_ylabel_text, size=20, weight='bold', color='black')
# 绘制w1与迭代次数的关系
axs[1][1].plot(x2, weights_array2[:, 1])
axs1_ylabel_text = axs[1][1].set_ylabel(u'W1', FontProperties=font)
plt.setp(axs1_ylabel_text, size=20, weight='bold', color='black')
# 绘制w2与迭代次数的关系
axs[2][1].plot(x2, weights_array2[:, 2])
axs2_xlabel_text = axs[2][1].set_xlabel(u'迭代次数', FontProperties=font)
axs2_ylabel_text = axs[2][1].set_ylabel(u'W1', FontProperties=font)
plt.setp(axs2_xlabel_text, size=20, weight='bold', color='black')
plt.setp(axs2_ylabel_text, size=20, weight='bold', color='black')
plt.show()
if __name__ == '__main__':
# 1.绘制数据集
# plotDataSet()
# 2.求最优参数
# dataMat, labelMat = loadDataSet()
# print(gradAscent(dataMat, labelMat))
# 3.绘制决策边界
# dataMat, labelMat = loadDataSet()
# weights = gradAscent(dataMat, labelMat)
# plotBestFit(weights)
# 4.改进：随机梯度下降法
dataMat, labelMat = loadDataSet()
weights = stocGradAscent1(np.array(dataMat), labelMat)
plotBestFit(weights)5、回归系数与迭代次数的关系
编写程序，绘制出回归系数和迭代次数的关系曲线：
代码
from matplotlib.font_manager import FontProperties
import matplotlib.pyplot as plt
import numpy as np
import random
"""
函数说明：加载数据
Returns：
dataMat - 数据列表
labelMat - 标签列表
"""
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]))
# 关闭文件
fr.close()
return dataMat, labelMat
"""
函数说明：sigmoid函数
Parameters：
inX - 数据
Returns：
sigmoid函数
"""
def sigmoid(inX):
return 1.0 / (1 + np.exp(-inX))
"""
函数说明：梯度上升算法
Parameters：
dataMatIn - 数据集
classLabels - 数据标签
Returns：
weights.getA() - 求得的权重数组（最优参数）
"""
def gradAscent(dataMatIn, classLabels):
# 转换成numpy的mat
dataMatrix = np.mat(dataMatIn)
# 转换成numpy的mat,并进行转置
labelMat = np.mat(classLabels).transpose()
# 返回dataMatrix的大小。m为行数,n为列数。
m, n = np.shape(dataMatrix)
# 移动步长,也就是学习速率,控制更新的幅度。
alpha = 0.01
# 最大迭代次数
maxCycles = 500
weights = np.ones((n, 1))
weights_array = np.array([])
for k in range(maxCycles):
# 梯度上升矢量化公式
h = sigmoid(dataMatrix * weights)
error = labelMat - h
# theta = theta + alpha*X^T(y - g(X))
weights = weights + alpha * dataMatrix.transpose() * error
weights_array = np.append(weights_array,weights)
weights_array = weights_array.reshape(maxCycles,n)
return weights.getA(),weights_array
"""
函数说明：随机梯度上升算法
"""
def stocGradAscent1(dataMatrix, classLabels, numIter=150):
# 返回dataMatrix的大小。m为行数,n为列数。
m, n = np.shape(dataMatrix)
# 参数初始化
weights = np.ones(n)
# 存储每次更新的回归系数
weights_array = np.array([])
for j in range(numIter):
dataIndex = list(range(m))
for i in range(m):
# 降低alpha的大小，每次减小1/(j+i)。
alpha = 4/(1.0+j+i)+0.01
# 随机选取样本
randIndex = int(random.uniform(0, len(dataIndex)))
# 选择随机选取的一个样本，计算h
h = sigmoid(sum(dataMatrix[randIndex]*weights))
# 计算误差
error = classLabels[randIndex] - h
# 更新回归系数
weights = weights + alpha * error * dataMatrix[randIndex]
# 添加回归系数到数组中
weights_array = np.append(weights_array, weights, axis=0)
# 删除已经使用的样本
del(dataIndex[randIndex])
# 改变维度
weights_array = weights_array.reshape(numIter*m, n)
return weights, weights_array
"""
函数说明:绘制回归系数与迭代次数的关系
Parameters:
weights_array1 - 回归系数数组1
weights_array2 - 回归系数数组2
"""
def plotWeights(weights_array1, weights_array2):
# 设置汉字格式
font = FontProperties(fname=r"c:\windows\fonts\simsun.ttc", size=14)
# 将fig画布分隔成1行1列,不共享x轴和y轴,fig画布的大小为(13,8)
# 当nrow=3,nclos=2时,代表fig画布被分为六个区域,axs[0][0]表示第一行第一列
fig, axs = plt.subplots(nrows=3, ncols=2, sharex=False, sharey=False, figsize=(20, 10))
x1 = np.arange(0, len(weights_array1), 1)
# 绘制w0与迭代次数的关系
axs[0][0].plot(x1, weights_array1[:, 0])
axs0_title_text = axs[0][0].set_title(u'梯度上升算法：回归系数与迭代次数关系', FontProperties=font)
axs0_ylabel_text = axs[0][0].set_ylabel(u'W0', FontProperties=font)
plt.setp(axs0_title_text, size=20, weight='bold', color='black')
plt.setp(axs0_ylabel_text, size=20, weight='bold', color='black')
# 绘制w1与迭代次数的关系
axs[1][0].plot(x1, weights_array1[:, 1])
axs1_ylabel_text = axs[1][0].set_ylabel(u'W1', FontProperties=font)
plt.setp(axs1_ylabel_text, size=20, weight='bold', color='black')
# 绘制w2与迭代次数的关系
axs[2][0].plot(x1, weights_array1[:, 2])
axs2_xlabel_text = axs[2][0].set_xlabel(u'迭代次数', FontProperties=font)
axs2_ylabel_text = axs[2][0].set_ylabel(u'W2', FontProperties=font)
plt.setp(axs2_xlabel_text, size=20, weight='bold', color='black')
plt.setp(axs2_ylabel_text, size=20, weight='bold', color='black')
x2 = np.arange(0, len(weights_array2), 1)
# 绘制w0与迭代次数的关系
axs[0][1].plot(x2, weights_array2[:, 0])
axs0_title_text = axs[0][1].set_title(u'改进的随机梯度上升算法：回归系数与迭代次数关系', FontProperties=font)
axs0_ylabel_text = axs[0][1].set_ylabel(u'W0', FontProperties=font)
plt.setp(axs0_title_text, size=20, weight='bold', color='black')
plt.setp(axs0_ylabel_text, size=20, weight='bold', color='black')
# 绘制w1与迭代次数的关系
axs[1][1].plot(x2, weights_array2[:, 1])
axs1_ylabel_text = axs[1][1].set_ylabel(u'W1', FontProperties=font)
plt.setp(axs1_ylabel_text, size=20, weight='bold', color='black')
# 绘制w2与迭代次数的关系
axs[2][1].plot(x2, weights_array2[:, 2])
axs2_xlabel_text = axs[2][1].set_xlabel(u'迭代次数', FontProperties=font)
axs2_ylabel_text = axs[2][1].set_ylabel(u'W1', FontProperties=font)
plt.setp(axs2_xlabel_text, size=20, weight='bold', color='black')
plt.setp(axs2_ylabel_text, size=20, weight='bold', color='black')
plt.show()
if __name__ == '__main__':
# 5.回归系数与迭代次数的关系
dataMat, labelMat = loadDataSet()
weights1, weights_array1 = stocGradAscent1(np.array(dataMat), labelMat, numIter=150)
weights2, weights_array2 = gradAscent(dataMat, labelMat)
plotWeights(weights_array1, weights_array2)
分析：
随机梯度上升算法，随机选取样本点，所以每次的运行结果是不同的。但是大体趋势是一样的。改进的随机梯度上升算法收敛效果更好。一共有100个样本点，改进的随机梯度上升算法迭代次数为150。而上图显示15000次迭代次数的原因是，使用一次样本就更新一下回归系数。因此，迭代150次，相当于更新回归系数150*100=15000次。迭代150次，更新1.5万次回归参数。从上图左侧的改进随机梯度上升算法回归效果中可以看出，其实在更新2000次回归系数的时候，已经收敛了。**相当于遍历整个数据集20次的时候，回归系数已收敛。**训练已完成。
梯度上升算法每次更新回归系数都要遍历整个数据集。从图中可以看出，当迭代次数为300多次的时候，回归系数才收敛。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
