在python上的朴素贝叶斯中添加混淆矩阵

Question

3天前，我在网上找到了使用朴素贝叶斯分类的分类技术代码。这段代码成功运行。现在我想使用sklearn库添加混淆矩阵代码。 这是所有的代码

import csv
import random
import math
import pandas as pd
from matplotlib.pylab import plt
from sklearn.metrics import confusion_matrix




def loadCsv(filename):
    lines = csv.reader(open("E:\KULIAH\TUGAS AKHIR\MachineLearning\kananniih.csv"))
    dataset = list(lines)
    for i in range(len(dataset)):
        dataset[i] = [float(x) for x in dataset[i]]
        print("ini dataset")
        print(dataset[i])
    return dataset


def splitDataset(dataset, splitRatio):
    trainSize = int(len(dataset) * splitRatio)
    trainSet = []
    copy = list(dataset)
    print("ini trainSize")
    print(trainSize)
    print("ini trainset")
    print(trainSet)
    print("ini copy")
    print(copy)
    while len(trainSet) < trainSize:
        index = random.randrange(len(copy))
        trainSet.append(copy.pop(index))
        #nilai apaa itu dirandom, untuk trainset dan copy
        apaa = [trainSet, copy]
        print("index")
        print(index)
        print("copy")
        print(copy)
        print("apa")
        print(apaa)
    return apaa


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


#hitung mean
def mean(numbers):
    haha = sum(numbers) / float(len(numbers))
    print("haha")
    print(haha)
    print("len numbers")
    print(len(numbers))
    return haha
    #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)
    print("------------------------------------------")
    print("nilai varian")
    print(variance)
    print("----------------------------------")
    print("numbers")
    print(numbers)
    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.items():
        summaries[classValue] = summarize(instances)
    return summaries


def calculateProbability(x, mean, stdev):
    #rumus gauss
    exponent = math.exp(-(math.pow(x - mean, 2) / (2 * math.pow(stdev, 2))))
    prob = (1 / (math.sqrt(2 * math.pi) * stdev)) * exponent
    print("-------------exponent---------------")
    print(exponent)
    print("--------------probability---------------")
    print(prob)
    return prob


def calculateClassProbabilities(summaries, inputVector):
    probabilities = {}
    for classValue, classSummaries in summaries.items():
        probabilities[classValue] = 1
        for i in range(len(classSummaries)):
            mean, stdev = classSummaries[i]
            x = inputVector[i]
            print("-----nilai x-----------")
            print(x)
            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.items():
        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
            precent = (correct / float(len(testSet))) * 100.0

        #Confusion Matrix
            hasile = confusion_matrix(testSet, correct)
            #print
            print("Test set: %s" % testSet)
            print("Predicted   : %s" % correct)
            print("accuracy : %s" % precent)
            print("Result : %s" % hasile)
    return precent


def main():
    filename = 'E:\KULIAH\TUGAS AKHIR\MachineLearning\kananniih.csv'
    splitRatio = 0.6
    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)
    #akurasi
    print(('Accuracy: {0}%').format(accuracy))


main()

这部分我写了混淆矩阵代码，但是有一些错误，我混淆了

def getAccuracy(testSet, predictions):
        correct = 0
        for i in range(len(testSet)):
            if testSet[i][-1] == predictions[i]:
                correct += 1
                precent = (correct / float(len(testSet))) * 100.0
            #Confusion Matrix
                hasile = confusion_matrix(testSet, predictions)
                #print
                print("Test set: %s" % testSet)
                print("Predicted   : %s" % predictions)
                print("accuracy : %s" % precent)
                print("Result : %s" % hasile)
        return precent

你们能帮帮我吗？非常感谢！向你问好，伊利亚