logistic 回归
logistic回归
1.算法思想
根据给定的数据集确定分类的边界。这个分类的边界就是我们所要求的回归函数。
所谓的回归其实就是最佳拟合，回归函数就是确定最佳回归参数，然后对不同的特征赋予不同的权重
2.算法基础
（1）所采用的映射函数是sigmoid函数，sigmoid函数比0-1函数（正方形波）更好的原因是sigmoid函数在局部上看是平滑的，而在全局上看是接近跳跃的。而0-1函数它本身是跳跃的，不够平滑，误差比较大。
（2）根据回归函数计算出了一个结果，然后代入sigmoid函数，就可以得到一个位于0与1之间的函数值，然后根据这个函数值得大小就可以判断类别；如果是二类分类问题值大于0.5属于1类， 否则属于0类
（3）最佳回归系数确定的方法是梯度上升法：
a.梯度上升法是用来求函数的最大值的，常说的梯度下降法是用来求函数的最小值的
b.所谓的梯度其实就是数学中的导数，也就是数据变化最大的方向。一般用倒三角符号来表示梯度。
c.公式为 w= w+ a.tidu(f(w)),其中a是步长，该公式会一直被迭代直到次数达到某一个值，或者达到某个误差允许的范围。
3.算法的优缺点
优点：计算比较简单，易于理解说明
缺点：有可能会欠拟合
适用的数据：标称数据和数值数据
4.算法的python实现
（1）创造简单的数据
from numpy import *
from math import *
import matplotlib.pyplot as plt
# create the data
def createdata(filename):
fr = open(filename, 'r')
lines = fr.readlines()
dataset = []
labelset = []
for each in lines:
current_data = each.strip().split()
dataset.append([1.0, float(current_data[0]), float(current_data[1])])
labelset.append(int(current_data[2]))
return dataset, labelset
（2）定义sigmoid函数
# define the sigmoid fuction
def sigmoid(x):
return 1.0/(1+ exp(-x))
（3）定义梯度上升算法
# define the gradascent
def gradascent(dataset, lableset):
datamatrix = mat(dataset)
y = mat(lableset).transpose()
m, n = shape(datamatrix)
a = 0.001
maxloop = 500
w = ones((n, 1))
for i in range(maxloop):
l = datamatrix*w
h = ones((m, 1))
j =0
for each in l:
h[j] = sigmoid(each)
j += 1
error = y - h
w += a * datamatrix.transpose()*error
return w
（4）定义随机梯度下降算法，这是一个改进的算法，之所以它是一个改进的算法是因为他节省了计算资源
# improve the grad
def gradimprove(dataset, datalable, times = 150):
datamatrix = array(dataset)
m,n = shape(datamatrix)
weights = ones(n)
for i in range(times):
dataindex = range(m)
for j in range(m):
a = 4/(i + j + 10)+0.01
randindex = int(random.uniform(0, len(dataindex)))
t = sum(datamatrix[randindex]*weights)
h = sigmoid(t)
error = datalable[randindex] - h
weights += a*datamatrix[randindex]*error
del(dataindex[randindex])
return weights
（5）绘制logstic函数
# plot the regression function
def plotregression(weights):
datamat, datalable = createdata("F:data/machinelearninginaction/Ch05/testSet.txt")
datastr = array(datamat)
n = shape(datastr)[0]
x1 = []
y1 = []
x2 = []
y2 = []
for i in range(n):
if datalable[i] == 1:
x1.append(datastr[i, 1])
y1.append(datastr[i, 2])
else:
x2.append(datastr[i, 1])
y2.append(datastr[i, 2])
fig = plt.figure()
ax = fig.add_subplot(111)
ax.scatter(x1, y1, s=30, c='red', marker='s')
ax.scatter(x2, y2, 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.show()
（6）对测试向量进行分类
# classify the vector
def classify(testdata, weights):
testsum = sum(testdata*weights)
classnum = sigmoid(testsum)
if classnum < 0.5:
return 0
else:
return 1
（7）进行十折交叉验证，这里针对的是判定马是否得病的案例
# the multi test
def multitest(times):
errorall = 0.0
for i in range(times):
error = horse()
errorall += error
errorrate = errorall/float(times)
print "the %d errorrate is %f" % (times, errorrate)
return errorrate
（8）
5.具体应用：判断一匹马是不是得病了
# create the horse function
def horse():
fr1 = open("F:data/machinelearninginaction/Ch05/horseColicTraining.txt")
fr2 = open("F:data/machinelearninginaction/Ch05/horseColicTest.txt")
lines = fr1.readlines()
dataset = []
labelset = []
for each in lines:
current_data = each.strip().split('\t')
vector = []
for i in range(21):
vector.append(float(current_data[i]))
dataset.append(vector)
labelset.append(float(current_data[21]))
weights = gradimprove(dataset, labelset, 500)
test_lines = fr2.readlines()
testdata = []
testlable = []
for each in test_lines:
current_data = each.strip().split('\t')
vector = []
for i in range(21):
vector.append(float(current_data[i]))
testdata.append(vector)
testlable.append(float(current_data[21]))
error = 0.0
for i in range(len(testdata)):
lable = classify(testdata[i], weights)
if lable != testlable[i]:
error += 1.0
errorrate = error/float(len(testdata))
print "the error rate is %f" % errorrate
return errorrate
5.分析与总结
1.书上的算法采用的是梯度上升算法，但是其实它就是梯度下降算法的变式。因为w = w+(y - h)*X= w-(h-y)*X
2.书上算w为什么没有用到导数的原因见此博客http://blog.csdn.net/dongtingzhizi/article/details/15962797
3.logistic回归，其实就是找到一个能够最好的分割两个类别的边界函数。
