5个基础的数据处理的代码：相关系数（Pearson积矩系数）、Apriori算法、FP-Tree、决策树、贝叶斯分类

相关系数（Pearson积矩系数）、Apriori算法、FP-Tree、决策树、贝叶斯分类
【jupyter notebook】

目录

一、 相关系数（Pearson积矩系数）
二、 Apriori算法
三、 FP-Tree
四、 决策树
五、 贝叶斯分类
六、 总结

一、相关系数（Pearson积矩系数）

1、概述：皮尔逊系数实现，主要就是将函数拆分成分子分母，再将分子分母拆分为易实现标准差和均值函数。

2、代码实现（python）：

from math import sqrt
from array import array`
#定义一个均值函数
def avg(g):
    sum_i = 0.0
    for i in range(len(g)):
        sum_i += g[i]
    return sum_i/len(g)
#定义一个标准差函数
def standev(a):
    sum_a = 0.0
    len_a = len(a)
    for i in range(len(a)):
        temp = pow(a[i] - avg(a), 2)
        sum_a += temp
    return sqrt(sum_a/len_a)
#定义计算皮尔逊相关系数的函数
def cal_pearson(x,y):
    n = len(x)
    molecular = 0.0 #分子
    avg_x = avg(x)
    avg_y = avg(y)
#先把分子列出来
    for i in range(n):
        temp = (x[i]-avg_x)*(y[i]-avg_y)
        molecular +=temp
#分母
    denominator = n*standev(x)*standev(y)
    return molecular/denominator  
num1 = [float(n) for n in input().split()]  #split指定切片
num2 = [float(n) for n in input().split()]
print("相关系数为："+str(cal_pearson(num1,num2)))

3、输出结果

二、Apriori算法

**1、概述：**本算法采用的语言是python在jupyter notebook上实现，代码的设计和实现来源于“菊安酱的机器学习第十期”。代码实现介绍如下：先定义一个简单的数据集；然后利用三个函数实现，分别是CreateC1()#生成候选一项集、ScanD()#扫描候选项集并生成频繁项集、AprioriGen()#合并频繁项集继续生成更高一维的候选项集；最后利用apriori()函数调用以上的函数进行操作实现对数据集操作生成频繁项集。
2、代码实现：

def loadDataSet():
    dataSet = [[1,3,4],[2,3,5],[1,2,3,5],[2,5]]
return dataSet
def CreateC1(dataSet):
    C1 = []
    for transaction in dataSet:
        for item in transaction:
            if not {
   item} in C1:
                C1.append({
   item})
    C1.sort()
return list(map(frozenset, C1))
def scanD(D, Ck, minSupport):
    ssCnt = {
   }
    for tid in D:
        for can in Ck:
            if can.issubset(tid):
                if can not in ssCnt.keys():
                    ssCnt[can] = 1
                else:
                    ssCnt[can] +=1
    numItems = float(len(D))
    retList = []
    supportData = {
   }
    for key in ssCnt:
        support = ssCnt[key]/numItems
        supportData[key] = support
        if support >= minSupport:
            retList.append(key)
return retList, supportData
def aprioriGen(Lk, k):
    Ck = []
    lenLk = len(Lk)
    for i in range(lenLk):
        for j in range(i+1, lenLk):
            L1 = list(Lk[i])[:k-2]
            L1.sort()
            L2 = list(Lk[j])[:k-2]
            L2.sort()
            if L1 == L2:
                Ck.append(Lk[i] | Lk[j])
return Ck
def apriori(D, minSupport = 0.5):
    C1 = CreateC1(D)
    L1,supportData = scanD(D, C1, minSupport)
    L = [L1]
    k = 2
    while(len(L[k-2]) > 0):
        Ck = aprioriGen(L[k-