Logistic回归

# -*-coding:utf-8-*-
'''
逻辑回归算法
'''
from __future__ import division
import numpy as np
import matplotlib.pyplot as plt
import random

def loadDataSet():
'''
训练数据 ---> 训练数据列表,分类标号向量
'''
dataMat = []
labelMat = []
f = open('testSet.txt')
for line in f.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):
'''
inX = W(T)*X = W1*X1 + W2*X2 + W3*X3 + ...
阶跃函数
'''
return 1.0/(1+np.exp(-inX))

def gradAscent(dataMatIn,classLabels):
'''
梯度上升算法,每更新一次w,要遍历所有的训练数据
'''
_dataMatrix = np.mat(dataMatIn)  # 训练数据列表 ---> 数据矩阵 m*n
_labelMat = np.mat(classLabels).transpose()  # 分类标号列表 --->分类标号单行矩阵 ---> 转制单列矩阵
m,n = np.shape(_dataMatrix)  # 矩阵的行、列
_alpha = 0.001   # 向目标移动的步长
_maxCycles = 500 # 迭代次数
weights = np.ones((n,1))   # 初始为全1的系数矩阵
for k in range(_maxCycles):
h = sigmoid(_dataMatrix * weights)    # h = sigmod(x1*w1 + x2*w2 + ...)
_error = _labelMat - h   # 计算结果与真实值之差
weights = weights + _alpha * _dataMatrix.transpose() * _error  # 每循环一次就更新一次系数
return weights

def stocGradAscent0(dataMatIn,classLabels):
'''
随机梯度上升算法,对每一个训练数据，更新一次w
'''
_dataMatrix = np.array(dataMatIn)   # 训练数据矩阵格式化
m,n = np.shape(_dataMatrix) # m个数据，n个特征
_alpha = 0.01    # 更新步长
weights = np.ones(n)    # 初始化为全1的w列表
for i in range(m):  # 对每一训练数据
h = sigmoid(sum(_dataMatrix[i]*weights))  #　sum(x0*w0 + x1*w1 + x2*w2)
_error = classLabels[i] - h
weights = weights + _alpha * _error * _dataMatrix[i]
return weights

def stocGradAscent1(dataMatIn, classLabels, numIter=4000):
'''
增加计算次数的随机梯度上升算法
算法的改进：
1. 步长alpha随迭代次数不断减小
2. 随机选择样本点更新回归系数
'''
_dataMatrix = np.array(dataMatIn)
m,n = np.shape(_dataMatrix)
weights = np.ones(n)
x0 = []
x1 = []
x2 = []
for i in range(numIter):
_dataIndex = range(m)   #　[0,1,2,...m]
for j in range(m):
_alpha = 4/(1.0 + i + j) + 0.01     # 每次迭代训练数据调整步长
_randIndex = int(random.uniform(0,len(_dataIndex))) # 随机生成一个范围内整数,在一次训练中，是随机无序加载训练数据的
h = sigmoid(sum(_dataMatrix[_randIndex] * weights)) # sum(x0*w0 + x1*w1 + x2*w2)
error = classLabels[_randIndex] - h
weights = weights + _alpha*error*_dataMatrix[_randIndex]    # 对每一个训练数据，更新w
del(_dataIndex[_randIndex]) #　遍历一个训练数据后，删除该数据
x0.append(weights[0])   #参数学习过程--->x0,然后在途中展示
x1.append(weights[1])
x2.append(weights[2])
plotime(x0,x1,x2)
return weights

def plotime(x0,x1,x2):
'''
4000次学习过程中，w的变化过程
'''
fig = plt.figure()
ax1 = fig.add_subplot(311)
ax2 = fig.add_subplot(312)
ax3 = fig.add_subplot(313)
x = np.linspace(1,4000,4000)
plt.sca(ax1)
plt.xlim(0,4000,500)
plt.ylim(8,15,0.5)
plt.ylabel('X0')
plt.plot(x,x0)

plt.sca(ax2)
plt.xlim(0,4000,500)
plt.ylim(0,3,0.2)
plt.ylabel('X1')
plt.plot(x,x1)

plt.sca(ax3)
plt.xlim(0,4000,500)
plt.ylim(-3,0,0.2)
plt.ylabel('X2')
plt.plot(x,x2)

plt.show()

def plotBestFit(weights):
'''
画出决策边界
'''
weights = weights.getA()    # 返回本身，以矩阵形式
dataMat,labelMat = loadDataSet()    # 列表训练数据 分类标号
dataArr = np.array(dataMat) # 矩阵格式
n = np.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 = np.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()