Apriori的实现

Apriori的python实现

多的不想说，直接放代码

import pandas as pd
import numpy as np
apdata = np.array(pd.read_table('apriori.txt', delimiter=',', dtype=int))
# print(apdata)
# print(apdata.loc[1]['A'])
# print(apdata.shape[1])
Label =pd.read_table('apriori.txt', delimiter=',', dtype=int).columns


# 得到所有项
# 输入【columns】
# 输出【item】
def getitem(label):
    item = []
    for i in range(len(label)):
        item.append(list(label[i]))
    return item
# print(getitem(Label))
Item = [['A'], ['B'], ['C'], ['D'], ['E']]
# print(label)


# 获取所有项
# def getdata(data):
# #     list = []
# #     for i in range(len(data)):
# #         for j in range(len(data[i])):
# #             list.append(data[i][j])
# #     return set(list)
# # print(getdata(apdata))


# 返回事务
# 参数【数据， 标签】
# 返回【事务】
def getthing(data, lable):
    data2 = []
    for i in range(len(data)):
        data1 = []
        for j in range(len(data[i])):
            if data[i][j] == 1:
                data1.append(lable[j])
        data2.append(data1)
    return np.array(data2)
# print(getthing(apdata, Label))
# print(len(getone(apdata, ['A', 'B', 'C', 'D', 'E'])))


# 获取项集支持度计数
# 参数【项集 ， 数据， 标签】
# 返回【项集， 支持度计数字典】
def getcounts(item, data, label):
    thing = getthing(data, label)
    countitems = []
    for i in range(len(item)):
        count = 0
        for j in range(len(thing)):
            if [True for c in item[i] if c not in thing[j]]:  #如果元素在item中不再thing中说明thing不包括item数组就不为空
                count = count
            else:
                count += 1
        countitems.append(count)
    dic = list(zip(item, countitems))  #得到项集与支持度的zip
    return dic

# print(getcounts(Item, apdata, Label))
# print(list(list(zip(*getcounts(Item, apdata, Label)))[0]))


# 剪枝
# 参数【项集， 支持度，数据， 标签】
def getnewItem(item, support, data, label):
    dic = getcounts(item, data, label)
    newdic = []
    for i in range(len(item)):
        if dic[i][1] >= support:
            newdic.append(dic[i])
    print(newdic)
    return newdic


# 连接步
# 参数【项集， 数据， 标签】
# 输出【新的项集及支持度】
def connect(item, data, label):
    newitem = []
    k = 0
    for i in range(len(item)):
        k += 1
        for j in range(len(item)-k):
            if len(item[i]) >= 2:
                if item[i][0:-1] == item[j+k][0:-1]:  #连接步的前提是第一项到倒数第二项要相同
                    item1 = sorted(list(set(item[i]+item[j+k])))
                    newitem.append(item1)
            else:
                item1 = sorted(list(set(item[i]+item[j+k])))
                newitem.append(item1)
    return getcounts(newitem, data, label)
# print(connect(Item, apdata, Label))
# newdata = list(list(zip(*connect(Item, apdata, Label)))[0])
# print(newdata)
# newdata2 = list(list(zip(*getnewItem(newdata, 2, apdata, Label)))[0])
# print(newdata2)
# print(connect(newdata2, apdata, Label))

# 运行函数
# 参数【项集，数据，标签，支持度，迭代次数】
# 输出迭代结果  返回【结果列表】
def run(item, data, label, support, m, itemlist):
    # getcounts(item, data, label)  #得到项集及支持度
    m += 1
    print('第', m, '次迭代频繁项集为:')
    countitem = getnewItem(item, support, data, label)
    itemlist.append(countitem)
    if len(countitem) == 0:
        print('迭代结束')
    else:
        newitem = list(list(zip(*countitem))[0])  #得到剪枝后的项集  zip(*)表示解压缩
        if len(newitem) >= 2:
            newcountitem = list(list(zip(*connect(newitem, data, label)))[0]) #连接步
            run(newcountitem, data, label, support, m, itemlist)
    return itemlist

# print(run(Item, apdata, Label, 2, 0, itemlist=[]))


# 关联规则的产生
# run[a][b][c]  第a次迭代第b个频繁项  【c为0或者1   为项集标签和项集支持度】


# 得到频繁项集的置信度
# 输入 【项集， 数据， 标签， 支持度迭代次数从0开始， 空的频繁项集】
# 输出 【置信度】
def confidence(item, data, label, support, m, itemlist):
    list1 = run(item, data, label, support, m, itemlist)
    # 得出频繁项集set
    for i in range(len(list1[-2])):
        itemlist = list1[-2][i][0]
        for j in range(len(itemlist)):
            count1 = 0
            count2 = 0
            count3 = 0
            for h in range(data.shape[1]):  #列
                for g in range(data.shape[0]):  #行
                    if itemlist[j] == Item[h][0]:
                        if data[g][h] == 1:
                            count1 += 1
                    itemlist2 = itemlist[0:j]+itemlist[j+1:]
            for t in range(len(getthing(data, label))):
                if [True for c in itemlist2 if c not in getthing(data, label)[t]]:
                    count2 = count2
                else:
                    count2 += 1
                if [True for c in itemlist if c not in getthing(data, label)[t]]:
                    count3 = count3
                else:
                    count3 += 1
            print(count1, count2, count3)
            print(itemlist[j], '->', itemlist[0:j]+itemlist[j+1:], '=', (count3/count1))
            print(itemlist[0:j]+itemlist[j+1:], '->', itemlist[j], '=', (count3/count2))

confidence(Item, apdata, Label, 2, 0, [])

没了！