机器学习实战--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、容易出现过拟合的现象，可引入规则项等其它手段加以约束。