关联分析-Python

Aprior底层代码原理

def deco(func):
    def inner():
        print('running inner()')
        return inner
def createc1(dataset):  # 定义一个函数来创建1-项集的候选集
    C1 = []  # 初始化一个空列表来存放1-项集
    for transaction in dataset:  # 遍历数据集中的每一个事务
        print(transaction)  # 输出当前事务，用于调试
        for item in transaction:  # 遍历当前事务中的每一个项
            print(item)  # 输出当前项，用于调试
            if [item] not in C1:  # 检查当前项是否已经在候选集中
                C1.append([item])  # 如果不在，则将其添加到候选集中
    C1.sort()  # 对候选集进行排序
    # 将列表转换为不可变集合（frozenset），以便可以作为字典的键使用
    return list(map(frozenset, C1)) 
D=[['A','C','D'],['B',"C",'E'],['A','B','C','D'],['B','E']]
D1=createc1(D)
D1






def aprioriGen(Lk, k):  # 定义一个函数来生成候选的k项集
    retList = []  # 初始化一个空列表来存放生成的候选k项集
    lenLk = len(Lk)  # 获取频繁k-1项集的数量
    for i in range(lenLk):  # 遍历频繁k-1项集
        for j in range(i + 1, lenLk):  # 从i+1开始遍历，确保不会重复组合
            L1 = list(Lk[i])[:k-2]  # 获取第i个频繁k-1项集的前k-2个元素
            L2 = list(Lk[j])[:k-2]  # 获取第j个频繁k-1项集的前k-2个元素
            
            # 当k=2时，L1和L2都是空集，因此这个检查可以跳过
            L1.sort()  # 排序L1
            L2.sort()  # 排序L2
            
            if L1 == L2:  # 如果这两个集合的前k-2个元素相同
                retList.append(Lk[i] | Lk[j])  # 将这两个集合合并生成候选k项集，并添加到返回列表中
    
    return retList  # 返回生成的候选k项集列表
D2=aprioriGen(D1, 2)
D2








def scanD(D, Ck, minsupport):  # 扫描整个事务数据集，并统计每个候选集的支持度
    ssCnt = {}  # 初始化一个字典来存储候选项集的支持度计数
    for tid in D:  # 遍历数据集中的每一个事务
        for can in Ck:  # 遍历候选项集中的每一个元素
            if can.issubset(tid):  # 如果事务包含候选项（即候选项是事务的子集）
                if can not in ssCnt:  # 如果这个候选项还没有出现在字典中
                    ssCnt[can] = 1  # 将其加入并设置计数值为1
                else:
                    ssCnt[can] += 1  # 如果已存在，则增加其计数值
    
    numItems = float(len(D))  # 计算事务数据集的大小
    retList = []  # 初始化一个列表来存储满足最小支持度要求的频繁项集
    supportData = {}  # 初始化一个字典来存储频繁项集的支持度信息
    for key in ssCnt:  # 遍历统计结果中的每一个候选项
        support = ssCnt[key] / numItems  # 计算支持度
        if support >= minsupport:  # 如果支持度大于或等于预设的最小支持度
            retList.insert(0, key)  # 将候选项添加到频繁项集列表的开头
            supportData[key] = support  # 存储支持度信息
    
    return retList, supportData  # 返回满足条件的频繁项集列表和支持度信息字典

scanD(D,D2,0.4)
D3=aprioriGen(D2, 3)
D3
scanD(D,D3,0.4)

实例调包

import pandas as pd
item_list = [['牛奶','面包'], 
             ['面包','尿布','啤酒','土豆'], 
             ['牛奶','尿布','啤酒','可乐'], 
             ['面包','牛奶','尿布','啤酒'], 
             ['面包','牛奶','尿布','可乐']]
item_df = pd.DataFrame(item_list)

from mlxtend.preprocessing import transactionencoder
import mlxtend

# 导入TransactionEncoder类
from mlxtend.preprocessing import TransactionEncoder

# 创建TransactionEncoder的实例
te = transactionencoder.TransactionEncoder()

# 使用TransactionEncoder的fit_transform方法将item_list转换为布尔矩阵
df_tf = te.fit_transform(item_list)

# 将布尔矩阵转换为DataFrame，并指定列名为事务中的项目名称
df = pd.DataFrame(df_tf, columns=te.columns_)

# 显示DataFrame的内容
display(df)


# 计算频繁项集
from mlxtend.frequent_patterns import apriori
frequent_itemsets = apriori(df, min_support=0.05,use_colnames=te.columns_)
frequent_itemsets

frequent_itemsets.sort_values(by='support', ascending=False, inplace=True)
frequent_itemsets

#选择2频繁项集
print(frequent_itemsets[frequent_itemsets.itemsets.apply(lambda x: len(x)==2)])

# 计算关联规则
from mlxtend.frequent_patterns import association_rules# metric可以有很多的度量选项，返回的表列名都可以作为参数
association_rule =association_rules(frequent_itemsets,metric='confidence',min_threshold=0.9)
association_rule

#关联规则可以提升度排序
association_rule.sort_values(by='lift',ascending=False,inplace=True)
association_rule
# 规则是：antecedents->consequents