机器学习-朴素贝叶斯，逻辑回归

朴素贝叶斯分类器

朴素贝叶斯分类器是使用概率论来进行分类的方法，

• 优点：在数据较少的情况下仍然有效，可以处理多类别问题。
• 缺点：对于输入数据的准备方式较为敏感。
• 适用数据类型：标称型数据。

贝叶斯决策理论
假设现在我们有一个数据集，它由两类数据组成，数据分布下图所示

用P1(x,y)表示数据点(x,y)属于类别1(以图中用圆点表示的类别）的概率
用P2(x,y)表示数据点(x,y)属于类别2(以图中用三角表示的类别）的概率
那么对于一个新的数据点(x0,y0)（未知类别），可以用下面的规则来判断其类别

• 如果P1(x0,y0)>p2(x0,y0),那么该点的类别为1
• 如果P1(x0,y0)<p2(x0,y0),那么该点的类别为2

这就是贝叶斯决策理论的核心思想，即选择具有最高概率的决策。

概率比较方法
如上图，贝叶斯决策涉及到对数据点进行分类。这时，前面的KNN算法和决策树都有自己的缺点。

• KNN算法：计算量太大
• 决策树：沿X,Y轴划分数据，效果不会太明显。
  这里用概率比较的方法来对数据进行分类（依据条件概率）。

使用条件概率进行分类
贝叶斯分类准则：

1. 如果P(C1|x,y)>P(C2|x,y) 那么属于类别C1
2. 如果P(C1|x,y)>P(C2|x,y) 那么属于类别C2
   使用贝叶斯准则，可以通过巳知的三个概率值来计算未知的概率值

使用朴素贝叶斯估计进行文档分类（例子）
朴素贝叶斯的一般过程

3. 收集数据：可以使用任何方法。本章使用RSS源。
4. 准备数据：需要数值型或者布尔型数据。
5. 分析数据：有大量特征时，绘制特征作用不大，此时使用直方图效果更好
6. 训练算法：计算不同的独立特征的条件概率
7. 测试算法：计算错误率
8. 使用算法：一个常见的朴素贝叶斯应用是文档分类。可以在任意的分类场景中使用朴素贝叶斯命类器，不一定非要是文本。

文本分类

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]                       
    return postingList,classVec

创建词表

def createVocabList(dataSet):
             vocabSet = set([])  
    for document in dataSet:
        vocabSet = vocabSet | set(document)   
    return list(vocabSet)    

向量化

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

从词向量计算函数

计算每个类别中的文档数目
对每篇训练文档： 
    对每个类别：
      如果词条出现文档中―增加该词条的计数值 
        增加所有词条的计数值 
             对每个类别： 
             对每个词条：
        将该词条的数目除以总词条数目得到条件概率 
返回每个类别的条件概率

训练函数

def trainNB(trainMatrix,trainCategory):
        numTrainDocs = len(trainMatrix)
        numWords = len(trainMatrix[0])
        pAbusive = sum(trainCategory) / float(numTrainDocs)
        p0Num = np.ones(numWords)
        p1Num = np.ones(numWords)
        p0Denom = 2.0
        p1Denom = 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 = np.log(p1Num / p1Denom)
        p0Vect = np.log(p0Num / p0Denom)
        return p0Vect, p1Vect, pAbusive

贝叶斯分类函数（主要）以及测试

def classifyBayes(vec2Classify, p0Vec, p1Vec, pClass1):
    p1 = sum(vec2Classify*p1Vec)+np.log(pClass1)              
    p0 = sum(vec2Classify*p0Vec)+np.log(1-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 = cal_possibility(np.array(trainMat), np.array(listClasses))
    testEntry = ['love', 'my', 'dalmation']
    thisDoc = np.array(setofWords2Vec(myVocabList, testEntry))
    print(testEntry,'classified as:',classifyNB(thisDoc,pOV,plV,pAb))
    testEntry = ['stupid', 'garbage']
    thisDoc = np.array(setofWords2Vec(myVocabList, testEntry))
    print (testEritry, 'classified as:' ,classifyNB(thisDoc,pOV,plV,pAb))

逻辑回归

逻辑回归是常见的最优化问题的算法
逻辑回归的一般过程

1. 收集数据：采用任意方法收集数据
2. 准备数据：由于需要进行距离计算，因此要求数据类型为数值型。另外，结构化数据 格式则最佳。
3. 分析数据：采用任意方法对数据进行分析
4. 训练算法：大部分时间将用于训练，训练的目的是为了找到最佳的分类回归系数
5. 测试算法：一旦训练步驟完成，分类将会很快。
6. 使用算法：首先，我们需要输入一些数据，并将其转换成对应的结构化数值；
   接着，基于训练好的回归系数就可以对这些数值进行简单的回归计算，判定它们属于 哪个类别.，在这之后，我们就可以在输出的类别上做一些其他分析工作

最佳回归系数的确定
梯度上升法

#############伪代码
每个回归系数初始化为1
重复R次
       计算整个数据集的梯度
       使用alpha * gradient更新回归系数的向量
       返回回归系数

def loadDataSet():
    dataMat = []; labelMat = []
    fr = open('G:/python/machinelearninginaction/Ch05/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])))
    return dataMat, labelMat
# 定义sigmoid函数
def sigmoid(inX):
    return 1.0 / (1 + np.exp(-inX))
# 梯度上升函数
def gradAscent(dataMatIn, classLabels):
    dataMatrix = np.mat(dataMatIn)
    labelMat = np.mat(classLabels).transpose()
    m, n = np.shape(dataMatrix)
    alpha = 0.001
    maxCycles = 500
    weights = np.ones((n, 1))
    for k in range(maxCycles):
        h = sigmoid(dataMatrix * weights)
        error = (labelMat - h)
        weights = weights + alpha * dataMatrix.transpose() * error
    return weights