# Apriori算法核心流程
transactions = [
    {'面包', '牛奶', '鸡蛋'},
    {'面包', '牛奶'},
    {'牛奶', '鸡蛋', '饼干'},
    {'面包', '饼干'},
    {'面包', '牛奶', '鸡蛋', '饼干'}
]

# 最小支持度阈值
min_support = 0.4

# 步骤1: 生成1-项集
def create_c1(transactions):
    c1 = []
    for transaction in transactions:
        for item in transaction:
            if not [item] in c1:
                c1.append([item])
    return list(map(frozenset, c1))

c1 = create_c1(transactions)
print("1-项候选集:", c1)

# 步骤2: 扫描数据库计算支持度
def scan_db(transactions, ck, min_support):
    item_count = {}
    for transaction in transactions:
        for candidate in ck:
            if candidate.issubset(transaction):
                item_count[candidate] = item_count.get(candidate, 0) + 1
    
    num_transactions = float(len(transactions))
    frequent_itemsets = []
    support_data = {}
    
    for key in item_count:
        support = item_count[key] / num_transactions
        if support >= min_support:
            frequent_itemsets.insert(0, key)
        support_data[key] = support
    
    return frequent_itemsets, support_data

L1, support_data = scan_db(transactions, c1, min_support)
print("1-项频繁集:", L1)
                      

# 生成关联规则
def generate_rules(frequent_itemsets, support_data, min_conf=0.7):
    big_rule_list = []
    for i in range(1, len(frequent_itemsets)):
        for freq_set in frequent_itemsets[i]:
            H1 = [frozenset([item]) for item in freq_set]
            if (i > 1):
                rules_from_conseq(freq_set, H1, support_data, big_rule_list, min_conf)
            else:
                calc_conf(freq_set, H1, support_data, big_rule_list, min_conf)
    return big_rule_list

def calc_conf(freq_set, H, support_data, brl, min_conf):
    pruned_H = []
    for conseq in H:
        conf = support_data[freq_set] / support_data[freq_set - conseq]
        if conf >= min_conf:
            print(freq_set - conseq, '-->', conseq, 'conf:', conf)
            brl.append((freq_set - conseq, conseq, conf))
            pruned_H.append(conseq)
    return pruned_H

# 示例：生成规则
# 假设有频繁项集L2, L3等
# rules = generate_rules([L1, L2, L3], support_data, min_conf=0.7)

# 计算提升度
def calculate_lift(support_XY, support_X, support_Y):
    """计算提升度"""
    return support_XY / (support_X * support_Y)

# 示例：计算提升度
support_milk_bread = 0.4  # 牛奶和面包同时出现的概率
support_milk = 0.8        # 牛奶出现的概率
support_bread = 0.6       # 面包出现的概率
lift = calculate_lift(support_milk_bread, support_milk, support_bread)
print(f"面包 -> 牛奶 的提升度: {lift:.3f}")
                      

import pandas as pd

# 创建关联规则数据
rules_data = {
    'antecedent': ['面包', '牛奶', '鸡蛋', '面包', '饼干'],
    'consequent': ['牛奶', '面包', '牛奶', '鸡蛋', '牛奶'],
    'support': [0.4, 0.4, 0.3, 0.3, 0.2],
    'confidence': [0.8, 0.5, 0.75, 0.6, 0.5],
    'lift': [1.33, 0.83, 1.25, 1.0, 0.83]
}

rules_df = pd.DataFrame(rules_data)

print("关联规则表:")
print(rules_df)

# 筛选强关联规则
strong_rules = rules_df[(rules_df['support'] >= 0.3) & 
                        (rules_df['confidence'] >= 0.6) & 
                        (rules_df['lift'] > 1)]
print("\n强关联规则:")
print(strong_rules[['antecedent', 'consequent', 'support', 'confidence', 'lift']])

# 按提升度排序
sorted_rules = rules_df.sort_values('lift', ascending=False)
print("\n按提升度排序:")
print(sorted_rules[['antecedent', 'consequent', 'lift']])
                      

# A/B测试分析应用示例
def recommend_products(cart, rules, top_n=3):
    """
    根据购物篮和关联规则推荐商品
    """
    recommendations = []
    
    for _, rule in rules.iterrows():
        antecedent = set(rule['antecedent'].split(','))
        if antecedent.issubset(set(cart)):
            consequent = rule['consequent']
            if consequent not in cart:
                recommendations.append({
                    'product': consequent,
                    'confidence': rule['confidence'],
                    'lift': rule['lift']
                })
    
    # 按置信度和提升度排序
    recommendations.sort(key=lambda x: (x['confidence'], x['lift']), reverse=True)
    return recommendations[:top_n]

# 示例：购物车中有面包和鸡蛋
cart = ['面包', '鸡蛋']
recommendations = recommend_products(cart, rules_df)

print(f"当前购物篮: {cart}")
print("推荐商品:")
for rec in recommendations:
    print(f"  - {rec['product']} (置信度: {rec['confidence']:.2f}, 提升度: {rec['lift']:.2f})")