机器学习算法-朴素贝叶斯（附源码）

前言

I={x_(1,) ┤├ x_(2, ) x_(3,…., ) x_(m,…) },确定映射规则y=f(x)，使得任意x_i∈I,有且仅有一个y_j∈C

使得y_j=f(x_i)成立。

 其中C叫做类别集合，其中每一个元素是一个类别，而I叫做项集合，其中每一个元素是一个待分类项，f叫做分类器。分类算法的任务就是构造分类器f 。

贝叶斯定理

     除以P(B)，即P(A│B)=P(A∩B)/P(B) 。

     P(A│B)P(B)=P(B│A)P(A),即：P(A│B)=(P(B│A)P(A))/P(B) ，这就是条件概率的计算公式。 

      别乘以B对这两个事件的条件概率之和。

      将这个公式代入条件概率公式，就得到了条件概率的另一种写法：P(A│B)=(P(B│A)P(A))/(P(B│A)P(A)"+" P(B│A’)P(A′) )

    P(A│B)=P(A)  (P(B│A))/P(B)

      P(A|B)称为“后验概率”即在B事件发生之后，对A事件概率的重新评估。P(B|A)/P(B)称为“可能性函数”这是一

      个调整因子，使得预估概率更接近真实概率。

      还是削弱了"先验概率"，由此得到更接近事实的"后验概率"。

在这里，如果"可能性函数"P(B|A)/P(B)>1，意味着"先验概率"被增强，事件A的发生的可能性变大；如果"可能性函数"=1，意味着B事件

无助于判断事件A的可能性；如果"可能性函数"<1，意味着"先验概率"被削弱，事件A的可能性变小。

贝叶斯决策论

                                         R(c_i│x)=∑_(j=1)^N▒λ_ij  P(c_j│x)

                                         R(h)=E_X [R(h(x)│x)]

                                        h^∗ (x)=(arg min)┬(c∈y)⁡〖R(c│x)〗

贝叶斯决策论——举例

             后验概率P(c_1│x)=P(c_2│x)=P(c_4│x)=P(c_5│x)=0.15，P(c_3│x)=0.4

   R(c_i│x)=∑_(j=1)^N▒λ_ij  P(c_j│x)             λ_ij={█(0,  [email protected],  i≠ j)┤

   i=1：R(c_1│x)=λ_11 P(c_1│x)+λ_12 P(c_2│x)+λ_13 P(c_3│x)+λ_14 P(c_4│x)+λ_15 P(c_5│x)=0.85

   i=2：R(c_2│x)=λ_21 P(c_1│x)+λ_22 P(c_2│x)+λ_23 P(c_3│x)+λ_24 P(c_4│x)+λ_25 P(c_5│x)=0.85

   i=3：R(c_3│x)=λ_31 P(c_1│x)+λ_32 P(c_2│x)+λ_33 P(c_3│x)+λ_34 P(c_4│x)+λ_35 P(c_5│x)=0.6

   i=4：R(c_4│x)=λ_41 P(c_1│x)+λ_42 P(c_2│x)+λ_43 P(c_3│x)+λ_44 P(c_4│x)+λ_45 P(c_5│x)=0.85

   i=5：R(c_5│x)=λ_51 P(c_1│x)+λ_52 P(c_2│x)+λ_53 P(c_3│x)+λ_54 P(c_4│x)+λ_55 P(c_5│x)=0.85

R(c_3│x)=1-P(c_3│x)，条件风险最小，故：欲使用贝叶斯准则来最小化决策风险，首先要获得后验概率，使其最大化

                                                                               h^∗ (x)=(arg max)┬(c∈y)⁡〖P(c│x)〗

朴素贝叶斯分类器

      (其中d为属性数目，x_i为x在第i个属性上的取值)

                          〖       h〗_nb (x)=arg  max┬(c∈y)⁡〖P(c) ∏_(i=1)^d▒〖P(x_i│c)〗〗

这就是朴素贝叶斯分类器的表达式。

朴素贝叶斯分类器——训练过程

                       P(x_i│c)=1/(σ_(c,i) √2π) e^((-(x_i-μ_(c,i) )^2/(2σ_(c,i)^2)) )

朴素贝叶斯分类器——算法流程

朴素贝叶斯分类器——举例

采用西瓜数据集训练一个朴素贝叶斯分类器，对测试例“测1”进行分类：

测试用例：

拉普拉斯平滑

                                     P(c)=|D_c |/|D|                                P(x_i│c)=|D_c，x_i |/|D_c |

例中，类先验概率可估计为

类似地，P青绿|是和P青绿|否可估计为：

同时，概率P_(清脆|是) 可估计为：P_(清脆|是)=P（敲声=清脆|好瓜=是）=（0+1）/（8+3）≈0.091

实验数据

code：

import csv
import random
import math


def loadCsv(filename):
    lines = csv.reader(open(filename, "rb"))
    dataset = list(lines)
    for i in range(len(dataset)):
        dataset[i] = [float(x) for x in dataset[i]]
    return dataset


def splitDataset(dataset, splitRatio):
    trainSize = int(len(dataset) * splitRatio)
    trainSet = []
    copy = list(dataset)
    while len(trainSet) < trainSize:
        index = random.randrange(len(copy))
        trainSet.append(copy.pop(index))
    return [trainSet, copy]


def separateByClass(dataset):
    separated = {}
    for i in range(len(dataset)):
        vector = dataset[i]
        if (vector[-1] not in separated):
            separated[vector[-1]] = []
        separated[vector[-1]].append(vector)
    return separated


def mean(numbers):
    return sum(numbers) / float(len(numbers))


def stdev(numbers):
    avg = mean(numbers)
    variance = sum([pow(x - avg, 2) for x in numbers]) / float(len(numbers) - 1)
    return math.sqrt(variance)


def summarize(dataset):
    summaries = [(mean(attribute), stdev(attribute)) for attribute in zip(*dataset)]
    del summaries[-1]
    return summaries


def summarizeByClass(dataset):
    separated = separateByClass(dataset)
    summaries = {}
    for classValue, instances in separated.iteritems():
        summaries[classValue] = summarize(instances)
    return summaries


def calculateProbability(x, mean, stdev):
    exponent = math.exp(-(math.pow(x - mean, 2) / (2 * math.pow(stdev, 2))))
    return (1 / (math.sqrt(2 * math.pi) * stdev)) * exponent


def calculateClassProbabilities(summaries, inputVector):
    probabilities = {}
    for classValue, classSummaries in summaries.iteritems():
        probabilities[classValue] = 1
        for i in range(len(classSummaries)):
            mean, stdev = classSummaries[i]
            x = inputVector[i]
            probabilities[classValue] *= calculateProbability(x, mean, stdev)
    return probabilities


def predict(summaries, inputVector):
    probabilities = calculateClassProbabilities(summaries, inputVector)
    bestLabel, bestProb = None, -1
    for classValue, probability in probabilities.iteritems():
        if bestLabel is None or probability > bestProb:
            bestProb = probability
            bestLabel = classValue
    return bestLabel


def getPredictions(summaries, testSet):
    predictions = []
    for i in range(len(testSet)):
        result = predict(summaries, testSet[i])
        predictions.append(result)
    return predictions


def getAccuracy(testSet, predictions):
    correct = 0
    for i in range(len(testSet)):
        if testSet[i][-1] == predictions[i]:
            correct += 1
    return (correct / float(len(testSet))) * 100.0


def main():
    filename = 'sj.csv'
    splitRatio = 0.67
    dataset = loadCsv(filename)
    trainingSet, testSet = splitDataset(dataset, splitRatio)
    print('Split {0} rows into train={1} and test={2} rows').format(len(dataset), len(trainingSet), len(testSet))
    # prepare model
    summaries = summarizeByClass(trainingSet)
    # test model
    predictions = getPredictions(summaries, testSet)
    accuracy = getAccuracy(testSet, predictions)
    print('Accuracy: {0}%').format(accuracy)


main()

算法改进