机器学习实战--naive bayes和logistic Regression

前面我们学到的knn和trees都是能确切的确定例子属于哪一类，这一节我们将介绍一种用概率来进行分类的方式。

一、朴素贝叶斯（naive bayes）

用一句话介绍就是，待测例子属于哪一类的可能性更大，就将待测例子归为哪一类。

先简单的介绍一下概率的基本知识：

假设一共有两类c=0,1；如果p(c=0)>p(c=1)，那我们就将该例归为c=0类。反之，归为c=1类。对于多类问题采用相似的解决方法。

而bayes的分类依据采用的是条件概率，p(c|w) = p(w|c)*p(c)/p(w)。其中p(c|w)表示，已知w的概率分布时，属于ci的概率。p(w|c)表示，已知所属类别时，w的概率分布。

这里w是一个多元数据w=（w0, w1, w2,….）。

在bayes理论中，如果p(c=0|w)>p(c=1|w),我们就将该例归为c=0类，于是就衍生出了怎么计算p(c|w)的问题，这里p(c)是各类别出现的概率，很好计算。p(w)相同，可以不用计算。问题在于怎么计算p(w|c),这时便做了一个特征相互独立假设，即w0, w1, …之间是相互独立，于是就有了p(w|c)=p(w0|c)*p(w1|c)….

这在理论上说不通，但实际的效果却很好（尤其在文档分类上），这就是naive bayes的“naive”所在。

更详细的概率知识，请参考其它

算法优点：

1、便于处理不完全的数据

2、能充分的利用领域的先验知识

3、在数据较少的情况下仍然有效，可进行多酚类问题

算法缺点：

对于输入的数据格式较为敏感。

算法步骤：

这里以文档分类为例

1、将文档转化为对应的单词向量

2、将单词向量转化为机器可识别的向量

3、训练：根据条件概率公式，计算对应的概率，或概率向量p(w|c), p(c)

4、测试：根据3中得到的训练参数，测试算法。

主要算法实现：

1、创建邮件列表，和对应的类别。

def loadDataSet():
postingList=[['my', 'dog', 'has', 'flea', 'problems', 'help', 'please'],
['maybe', 'not', 'take', 'him', 'to', 'dog', 'park', 'stupid'],
['my', 'dalmation', 'is', 'so', 'cute', 'I', 'love', 'him'],
['stop', 'posting', 'stupid', 'worthless', 'garbage'],
['mr', 'licks', 'ate', 'my', 'steak', 'how', 'to', 'stop', 'him'],
['quit', 'buying', 'worthless', 'dog', 'food', 'stupid']]
classVec = [0,1,0,1,0,1]    #1 is abusive, 0 not
return postingList,classVec

2、创建单词列表

def createVocabList(dataSet):
vocabSet = set([])  #create empty set
for document in dataSet:
vocabSet = vocabSet | set(document) #union of the two sets
return list(vocabSet)

3、单词转化为计算机能能识别的向量，第一个函数转化为词集，只标记是否出现，第二个函数转化为词袋，标记出现的次数

def setOfWords2Vec(vocabList, inputSet):
returnVec = [0]*len(vocabList)
for word in inputSet:
if word in vocabList:
returnVec[vocabList.index(word)] = 1
else: print "the word: %s is not in my Vocabulary!" % word
return returnVec

def bagOfWords2VecMN(vocabList, inputSet):
returnVec = [0]*len(vocabList)
for word in inputSet:
if word in vocabList:
returnVec[vocabList.index(word)] += 1
return returnVec

3、训练，计算相应的概率参数

def trainNB0(trainMatrix,trainCategory):
numTrainDocs = len(trainMatrix)
numWords = len(trainMatrix[0])
pAbusive = sum(trainCategory)/float(numTrainDocs)
p0Num = ones(numWords); p1Num = ones(numWords)      #change to ones()
p0Denom = 2.0; p1Denom = 2.0                        #change to 2.0
for i in range(numTrainDocs):
if trainCategory[i] == 1:
p1Num += trainMatrix[i]
p1Denom += sum(trainMatrix[i])
else:
p0Num += trainMatrix[i]
p0Denom += sum(trainMatrix[i])
p1Vect = log(p1Num/p1Denom)          #change to log()
p0Vect = log(p0Num/p0Denom)          #change to log()
return p0Vect,p1Vect,pAbusive

4、测试

def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
p1 = sum(vec2Classify * p1Vec) + log(pClass1)    #element-wise mult
p0 = sum(vec2Classify * p0Vec) + log(1.0 - pClass1)
if p1 > p0:
return 1
else:
return 0

def testingNB():
listOPosts,listClasses = loadDataSet()
myVocabList = createVocabList(listOPosts)
trainMat=[]
for postinDoc in listOPosts:
trainMat.append(setOfWords2Vec(myVocabList, postinDoc))
p0V,p1V,pAb = trainNB0(array(trainMat),array(listClasses))
testEntry = ['love', 'my', 'dalmation']
thisDoc = array(setOfWords2Vec(myVocabList, testEntry))
print testEntry,'classified as: ',classifyNB(thisDoc,p0V,p1V,pAb)
testEntry = ['stupid', 'garbage']
thisDoc = array(setOfWords2Vec(myVocabList, testEntry))
print testEntry,'classified as: ',classifyNB(thisDoc,p0V,p1V,pAb)

注意事项：

1、由于我们得到的概率参数，可能会非常小，相乘后很可能会出现下溢出的情况，于是，我们采用log（p）的形式，并将连乘变为连加。

2、在求解p(c)时，有可能会遇到某类个数为零的情况，从而p(c)为0,使得p(c|w)也为0,造成数据异动，为了避免这种情况的发生，我们在初始p(c)值时，该类个数和总数分别为1,2

3、对于实际的文本解析，需要引入re正则表达式进行textparse()

4、关于vocabList选取的问题，有人倾向于在整个训练样本中选取，有人倾向于在训练样本和测试样本中选取。

5、对于其它语言（比如中文，要用到中文分词），本人正在研究当中。

二、逻辑回归（logistic Regression )

从这里开始，我们讨论最优化问题，如最短路程，最小功率。

首先，假设任何函数都可以由多个线性函数的组合得到。

即： z = w0*x0 + w1*x1 + w2* x2 + ……

其次，既然是个分类器，那么我们首先需要一个分类函数，经过前人的努力，发现sigmoid函数在这方面有很好的特征f(z) = 1/(1+exp(-z))。当然了，也可以用其它的函数，比如现在找到了更好的分类函数relu,用来防止过拟合和接近极值时，函数值几乎不改变的情况。

确定了分类函数之后，问题就转化为了如何确定最佳回归系数的问题：w。这里介绍两种：分别是梯度下降和随机梯度下降。大致的原理就是，从某个点出发，沿梯度方向下降最快，越快能到达极小值（极大值也一样）。

算法优点：

计算代价不高，易于理解和实现

算法缺点：

容易欠拟合，分类精度不够

算法步骤：

1、初始化参数

2、计算梯度 error = (h-classLabels)

3、更新参数 w = w + alpha*error*dataMat[i]

主要代码实现：

1、梯度下降算法：

def gradAscent(dataMatIn, classLabels):
dataMatrix = mat(dataMatIn)             #convert to NumPy matrix
labelMat = mat(classLabels).transpose() #convert to NumPy matrix
m,n = shape(dataMatrix)
alpha = 0.001
maxCycles = 500
weights = ones((n,1))
for k in range(maxCycles):              #heavy on matrix operations
h = sigmoid(dataMatrix*weights)     #matrix mult
error = (labelMat - h)              #vector subtraction
weights = weights + alpha * dataMatrix.transpose()* error #matrix mult
return weights

2、随机梯度算法

def stocGradAscent1(dataMatrix, classLabels, numIter=150):
m,n = shape(dataMatrix)
weights = ones(n)   #initialize to all ones
for j in range(numIter):
dataIndex = range(m)
for i in range(m):
alpha = 4/(1.0+j+i)+0.0001    #apha decreases with iteration, does not
randIndex = int(random.uniform(0,len(dataIndex)))#go to 0 because of the constant
h = sigmoid(sum(dataMatrix[randIndex]*weights))
error = classLabels[randIndex] - h
weights = weights + alpha * error * dataMatrix[randIndex]
del(dataIndex[randIndex])
return weights

3、分类

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

4、给出一个划分数据画图的代码

def plotBestFit(weights):
import matplotlib.pyplot as plt
dataMat,labelMat=loadDataSet()
dataArr = array(dataMat)
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()

注意事项：

1、什么时候用矩阵，什么时候用数组

2、随机梯度算法，用单个数据去更新，属于“在线学习”，梯度算法，用整个数据集去更新。

3、两种算法得到的最优都属于局部最优，和初始值的选择有很大的关系。

4、容易出现过拟合的现象，可引入规则项等其它手段加以约束。