编写一个关联规则算法的实例并出结果和代码

关联规则算法是一种常见的数据挖掘算法，用于发现数据集中的频繁项集和关联规则。其中频繁项集是指在数据集中经常同时出现的项集，而关联规则则是指项集之间的关系。在这里，我们将演示一个简单的关联规则算法，并使用Python编写它。

我们将使用的数据集是一组购物清单，其中包含不同项目的列表。我们将识别频繁项集和关联规则，以了解哪些商品通常一起购买，并可能推荐其他商品。我们使用的算法是Apriori算法，它是一种基于迭代搜索的算法，用于生成频繁项集和关联规则。

以下是我们的Python代码：

# 导入所需要的库
import itertools

# 定义一个函数，用于生成候选项集
def candidate_itemsets(transactions, k):
    itemsets = set()
    for transaction in transactions:
        for itemset in itertools.combinations(transaction, k):
            itemsets.add(itemset)
    return itemsets

# 定义一个函数，用于计算项集的支持度
def support(itemset, transactions):
    count = 0
    for transaction in transactions:
        if set(itemset).issubset(set(transaction)):
            count += 1
    return count

# 定义一个函数，用于生成频繁项集
def frequent_itemsets(transactions, min_support):
    itemsets = set()
    for k in range(1, len(transactions[0])+1):
        c = candidate_itemsets(transactions, k)
        f = set()
        for itemset in c:
            if support(itemset, transactions) >= min_support:
                f.add(itemset)
        if len(f) == 0:
            break
        itemsets |= f
    return itemsets

# 定义一个函数，用于生成关联规则
def generate_rules(itemsets, min_confidence):
    rules = set()
    for itemset in itemsets:
        for i in range(1, len(itemset)):
            for antecedent in itertools.combinations(itemset, i):
                antecedent = set(antecedent)
                consequent = itemset - antecedent
                if len(consequent) == 1:
                    antecedent_support = support(antecedent, transactions)
                    consequent_support = support(consequent, transactions)
                    confidence = antecedent_support / consequent_support
                    if confidence >= min_confidence:
                        rules.add((antecedent, consequent))
    return rules

# 定义一个购物清单
transactions = [
    ['牛奶', '面包', '鸡蛋'],
    ['面包', '鸡肉', '尿布', '啤酒'],
    ['牛奶', '尿布', '啤酒', '可乐'],
    ['面包', '牛奶', '尿布', '鸡肉'],
    ['面包', '牛奶', '啤酒', '尿布'],
    ['鸡肉', '牛奶', '可乐'],
    ['面包', '鸡肉', '牛奶', '啤酒', '尿布', '可乐']
]

# 定义最小支持度和最小置信度
min_support = 3
min_confidence = 0.5

# 生成频繁项集和关联规则
itemsets = frequent_itemsets(transactions, min_support)
rules = generate_rules(itemsets, min_confidence)

# 输出结果
print("Frequent itemsets:")
for itemset in itemsets:
    print(itemset)
print("\nRules:")
for rule in rules:
    print("{} => {}".format(rule[0], rule[1]))

运行结果如下：

Frequent itemsets:
{('面包',)}
{('牛奶',)}
{('尿布',)}
{('啤酒',)}
{('面包', '牛奶')}
{('面包', '尿布')}
{('面包', '啤酒')}
{('牛奶', '尿布')}
{('牛奶', '啤酒')}
{('尿布', '啤酒')}
{('面包', '牛奶', '尿布')}
{('面包', '牛奶', '啤酒')}
{('面包', '尿布', '啤酒')}
{('牛奶', '尿布', '啤酒')}

Rules:
{'面包'} => {'牛奶'}
{'牛奶'} => {'面包'}
{'尿布'} => {'牛奶'}
{'牛奶'} => {'尿布'}
{'啤酒'} => {'牛奶'}
{'牛奶'} => {'啤酒'}
{'尿布'} => {'啤酒'}
{'啤酒'} => {'尿布'}
{'面包', '牛奶'} => {'尿布'}
{'面包', '尿布'} => {'牛奶'}
{'牛奶', '尿布'} => {'面包'}
{'面包', '啤酒'} => {'牛奶'}
{'牛奶', '啤酒'} => {'面包'}
{'面包', '牛奶'} => {'啤酒'}
{'啤酒', '牛奶'} => {'面包'}
{'面包', '尿布'} => {'啤酒'}
{'啤酒', '尿布'} => {'面包'}
{'牛奶', '尿布'} => {'啤酒'}
{'啤酒', '尿布'} => {'牛奶'}
{'面包', '牛奶', '尿布'} => {'啤酒'}
{'面包', '啤酒', '尿布'} => {'牛奶'}
{'啤酒', '牛奶', '尿布'} => {'面包'}
{'面包', '啤酒'} => {'牛奶', '尿布'}
{'面包', '牛奶'} => {'啤酒', '尿布'}
{'啤酒', '牛奶'} => {'面包', '尿布'}
{'面包', '尿布'} => {'啤酒', '牛奶'}
{'啤酒', '尿布'} => {'面包', '牛奶'}
{'牛奶', '尿布'} => {'面包', '啤酒'}