编程实现KNN和朴素贝叶斯算法分类

大数据上机作业，编程实现K近邻和朴素贝叶斯算法

1、 编程实现KNN算法对下表中两个未知类型的样本进行分类（冰川水或者湖泊水），其中K=3，即选择最近的3个邻居。

import numpy as np
import math
a=np.array([[0.2,0.5,0.1,0.1],[0.4,0.3,0.4,0.3],[0.3,0.4,0.6,0.3],[0.2,0.6,0.2,0.1],[0.5,0.5,0.1,0],[0.3,0.3,0.4,0.4]])
print(a)
label=["冰川水","湖泊水","冰川水","冰川水","湖泊水","湖泊水"]
def distance(x,y):
    sum=0.0
    for i in range(len(x)):
        sum+=math.pow((x[i]-y[i]),2)
    return math.sqrt(sum)




def classify(input,group,label,k):
    mark={}
    flag=0
    for i in group:
        tmpsum=distance(input,i)
        print("计算两者之间距离为{}".format(tmpsum))
        mark[flag]=tmpsum
        flag=flag+1
    sorted_mark = sorted(mark.items(),key=lambda x: x[1])  
    after_mark=dict(sorted_mark[:k])
    tmp=[]
    for i in after_mark.keys():
        tmp.append(label[i])
    # 直接统计
    print(max(tmp, key=tmp.count))

    
Garr=np.array([0.3,0.3,0.3,0.2])
Harr=np.array([0.1,0.5,0.2,0.2])
classify(Garr,a,label,3)
classify(Harr,a,label,3)

计算两者之间距离为0.31622776601683794
计算两者之间距离为0.17320508075688776
计算两者之间距离为0.33166247903553997
计算两者之间距离为0.34641016151377546
计算两者之间距离为0.4
计算两者之间距离为0.22360679774997902
湖泊水
计算两者之间距离为0.17320508075688776
计算两者之间距离为0.42426406871192857
计算两者之间距离为0.4690415759823429
计算两者之间距离为0.17320508075688773
计算两者之间距离为0.45825756949558405
计算两者之间距离为0.4
冰川水

实现朴素贝叶斯算法预测是否适合户外活动

import csv
def load_data(filename):
    lines = csv.reader(open(filename, "rt"))
    dataset = list(lines)
    data=[]
   
    for i in dataset:
        tmp=[]
        for j in i:
            j=j[:-1]
            tmp.append(str(j))
        data.append(tmp)
    return data

def getSumOfC(C,data):
    c=0
    for i in data:
        if(i[len(i)-1]==C):
            c=c+1
    return c

def getPossibilityofCwhenData(C,data):
    print("标签{}的概率为{}".format(C,getSumOfC(C,data)/len(data)))
    return getSumOfC(C,data)/len(data)

def getPossibilityofXwhenC_Single(X,C,data):
    sum_X=0
    for i in data:
        if i[len(i)-1]==C:
            if X in i:
                sum_X=sum_X+1
    print(sum_X)
    
    return sum_X/getSumOfC(C,data)
                   
def getPossibilityofXwhenC_Summary(input,C,data):
    sum_possibility=1.0
    for i in input:
        print("传入的要检查的x值为{}".format(i))
        res=getPossibilityofXwhenC_Single(i,C,data)
        if res!=0:
            sum_possibility=sum_possibility*res
    return sum_possibility

def getPossibility(input,C,data):
    #先获取标签总的概率
    a=getPossibilityofCwhenData(C,data)
    #然后获取对应元素概率
    b=getPossibilityofXwhenC_Summary(input,C,data)
    #相乘获取结果概率
    result=a*b
    print(result)
    return result

def main():
    filename="G:/学习/课程相关/大三/大数据挖掘/上机/3/thisdata.csv"
    data=load_data(filename)
    input=['下雨','低','大','微风']
    C1=getPossibility(input,'适合',data)
    C2=getPossibility(input,'不适合',data)
    print("{}概率为{}".format("适合",C1))
    print("{}概率为{}".format("不适合",C2))
    if C1<C2:
         print("最终答案为{}".format("不适合"))
    else:
         print("最终答案为{}".format("适合")) 
               
main()

标签适合的概率为0.6
传入的要检查的x值为下雨
3
传入的要检查的x值为低
3
传入的要检查的x值为大
2
传入的要检查的x值为微风
5
0.041666666666666664
标签不适合的概率为0.4
传入的要检查的x值为下雨
1
传入的要检查的x值为低
1
传入的要检查的x值为大
3
传入的要检查的x值为微风
2
0.009375000000000001
适合概率为0.041666666666666664
不适合概率为0.009375000000000001
最终答案为适合