1
import csv
2

3
def processing_data():
4
  with open("./data.csv") as csvfile:
5
    data = list(csv.reader(csvfile))
6

7
  dic = {}
8
  for i in data[1:]:    # 跳过表头
9
    if not i[0] in dic:
10
      dic[i[0]] = [i[1]]    # 创建新的交易
11
    else:
12
      dic[i[0]].append(i[1])    # 添加商品到已有交易
13
  data_set = list(dic.values())
14
  return data_set
15

16
data_set = processing_data()

1
def create_C1(data_set):
2
    C1 = set()
3
    for t in data_set:
4
        for item in t:
5
            item_set = frozenset([item])
6
            C1.add(item_set)
7
    return C1

1
def is_apriori(Ck_item, Lksub1):
2
    for item in Ck_item:
3
        sub_Ck = Ck_item - frozenset([item])    # 生成(k-1)项子集
4
        if sub_Ck not in Lksub1:    # 检查子集是否在Lk-1中
5
            return False
6
    return True

1
def create_Ck(Lksub1, k):
2
    Ck = set()
3
    list_Lksub1 = list(Lksub1)
4

5
    for i in range(len(list_Lksub1)):
6
        for j in range(i + 1, len(list_Lksub1)):
7
            # 获取两个(k-1)-项集
8
            l1 = list(list_Lksub1[i])
9
            l2 = list(list_Lksub1[j])
10

11
            # 排序，确保比较的一致性
12
            l1.sort()
13
            l2.sort()
14

15
            # 只有前(k-2)个元素相同时才能连接
16
            if l1[0:k-2] == l2[0:k-2]:
17
                # 合并生成候选k-项集
18
                Ck_item = list_Lksub1[i] | list_Lksub1[j]
19

20
                if is_apriori(Ck_item, Lksub1):
21
                    Ck.add(Ck_item)
22

23
    return Ck

1
def generate_Lk_by_Ck(data_set, Ck, min_support, support_data):
2
    # 初始化每个候选项集的支持度计数
3
    Ck_count = {}
4
    for item in Ck:
5
        Ck_count[item] = 0
6

7
    # 扫描数据集，统计每个候选项集的出现次数
8
    for transaction in data_set:
9
        transaction_set = set(transaction)
10

11
        # 检查每个候选项集
12
        for item in Ck:
13
            # 如果候选项集是交易的子集，计数+1
14
            if item.issubset(transaction_set):
15
                Ck_count[item] += 1
16

17
    # 初始化频繁k-项集
18
    Lk = set()
19

20
    # 遍历每个候选项集，根据支持度筛选
21
    for item in Ck:
22
        support = float(Ck_count[item]) / float(len(data_set))
23
        support_data[item] = support
24

25
        if support >= min_support:
26
            Lk.add(item)
27

28
    return Lk

1
def generate_L(data_set, k, min_support):
2
    # 初始化支持度字典
3
    support_data = {}
4

5
    # Step 1: 生成候选1-项集 C1
6
    C1 = create_C1(data_set)
7

8
    # Step 2: 从 C1 生成频繁1-项集 L1
9
    L1 = generate_Lk_by_Ck(data_set, C1, min_support, support_data)
10

11
    L = [L1]
12

13
    # Step 3: 迭代生成 L2, L3, ..., Lk
14
    for i in range(2, k + 1):
15
        Ci = create_Ck(L[i-2], i)
16

17
        # 如果候选集为空，终止
18
        if len(Ci) == 0:
19
            break
20

21
        Li = generate_Lk_by_Ck(data_set, Ci, min_support, support_data)
22

23
        # 如果频繁项集为空，终止
24
        if len(Li) == 0:
25
            break
26

27
        L.append(Li)
28

29
    return L, support_data

1
data_set = [
2
    ['I1', 'I2', 'I5'],
3
    ['I2', 'I4'],
4
    ['I2', 'I3'],
5
    ['I1', 'I2', 'I4'],
6
    ['I1', 'I3'],
7
    ['I2', 'I3'],
8
    ['I1', 'I3'],
9
    ['I1', 'I2', 'I3', 'I5'],
10
    ['I1', 'I2', 'I3'],
11
]
12

13
print("=" * 80)
14
print("数据集展示")
15
print("=" * 80)
16
for idx, trans in enumerate(data_set, 1):
17
    print(f"  T{idx}: {trans}")
18
print()
19
# 调用函数生成频繁项集
20
L, support_data = generate_L(data_set, k=3, min_support=0.2)
21

22
print("\n" + "=" * 80)
23
print("频繁项集结果")
24
print("=" * 80)
25
for idx, lk in enumerate(L, 1):
26
    print(f"\n【频繁{idx}-项集 L{idx}】(共 {len(lk)} 个)")
27
    print("-" * 80)
28

29
    # 按支持度排序
30
    sorted_lk = sorted(lk, key=lambda x: support_data[x], reverse=True)
31

32
    for item in sorted_lk:
33
        support = support_data[item]
34
        count = int(support * len(data_set))
35
        items_str = str(set(item))
36
        print(f"  {items_str:25s} | 支持度: {support:.3f} ({support*100:5.1f}%) | 计数: {count}")

1
from itertools import combinations
2

3
def generate_big_rules(L, support_data, min_conf):
4
    big_rule_list = []
5

6
    # 从L2开始遍历（L1不能生成规则）
7
    for i in range(1, len(L)):
8
        for itemset in L[i]:
9
            # 生成该项集的所有可能规则
10
            rules = generate_rules_from_itemset(
11
                itemset,
12
                support_data,
13
                min_conf
14
            )
15

16
            # 将满足条件的规则添加到结果中
17
            big_rule_list.extend(rules)
18

19
    return big_rule_list
20

21
def generate_rules_from_itemset(itemset, support_data, min_conf):
22
    rules = []
23
    itemset_support = support_data[itemset]
24

25
    # 枚举所有可能的前件大小（从1到len-1）
26
    for i in range(1, len(itemset)):
27
        for antecedents in combinations(itemset, i):
28
            # 获取真子集
29
            antecedent = frozenset(antecedents)
30

31
            # 后件 = 项集 - 前件
32
            consequent = itemset - antecedent
33

34
            # 检查前件是否在support_data中（必须是频繁项集）
35
            if antecedent in support_data:
36
                # 计算置信度
37
                conf = float(itemset_support) / float(support_data[antecedent])
38

39
                # 如果置信度满足要求，添加规则
40
                if conf >= min_conf:
41
                    rules.append((antecedent, consequent, conf))
42

43
    return rules

1
def generate_rules_from_itemset(itemset, support_data, min_conf, calculate_lift=True):
2
    rules = []
3
    itemset_support = support_data[itemset]
4

5
    for i in range(1, len(itemset)):
6
        for antecedent_tuple in combinations(itemset, i):
7
            antecedent = frozenset(antecedent_tuple)
8
            consequent = itemset - antecedent
9

10
            if antecedent in support_data and consequent in support_data:
11
                # 计算置信度
12
                conf = float(itemset_support) / float(support_data[antecedent])
13

14
                if conf >= min_conf:
15
                    if calculate_lift:
16
                        # 计算有趣度
17
                        lift = float(itemset_support) / (
18
                            float(support_data[antecedent]) * float(support_data[consequent])
19
                        )
20
                        rules.append((antecedent, consequent, conf, lift))
21
                    else:
22
                        rules.append((antecedent, consequent, conf))
23

24
    return rules