利用create_C1函数生成候选一项集C1
时间: 2023-06-05 08:06:13 浏览: 73
可以回答这个问题。生成候选一项集C1是Apriori算法中的一个重要步骤,需要遍历所有事务记录,挖掘出出现频率较高的单一物品,然后将它们组合成长度为2的项集。具体实现的话,可以使用字典数据结构,对于每一个出现的单一物品,在字典中对应的计数器加1,最后筛选出出现次数大于等于支持度阈值的物品。生成候选一项集C1的代码如下所示:
def create_C1(data_set):
C1 = []
for transaction in data_set:
for item in transaction:
if [item] not in C1:
C1.append([item])
C1.sort()
return list(map(frozenset, C1))
其中data_set是一个列表,包含多个列表,每个子列表代表一条事务记录,而C1是一个候选一项集的列表,其中每个元素都是一个只包含单一物品的集合。函数返回值是一个经过类型转换的C1列表,其中C1中的每个元素都被转换为一个不可变的frozenset类型,以便后面可以将这些集合用作字典的键。
相关问题
def generate_L(data_set, k, min_support): """ Generate all frequent itemsets. Args: data_set: A list of transactions. Each transaction contains several items. k: Maximum number of items for all frequent itemsets. min_support: The minimum support. Returns: L: The list of Lk. support_data: A dictionary. The key is frequent itemset and the value is support. """ support_data = {} C1 = create_C1(data_set) L1 = generate_Lk_by_Ck(data_set, C1, min_support, support_data) Lksub1 = L1.copy() L = [] L.append(Lksub1) for i in range(2, k + 1): Ci = create_Ck(Lksub1, i) Li = generate_Lk_by_Ck(data_set, Ci, min_support, support_data) Lksub1 = Li.copy() L.append(Lksub1) return L, support_data
这段代码实现了Apriori算法中的频繁项集挖掘过程。Apriori算法是一种常见的关联规则挖掘算法,用于发现数据集中的频繁项集。
函数generate_L的输入参数包括数据集data_set、最大项数k和最小支持度min_support。其中,数据集data_set是一个列表,每个元素表示一条交易记录,其中包含多个项;最大项数k是指挖掘的频繁项集中最多包含的项数;最小支持度min_support是指一个项集在所有交易记录中出现的次数占比必须大于等于min_support才能被认为是频繁项集。
函数内部首先创建了一个空字典support_data,用于存储频繁项集及其支持度信息。然后调用函数create_C1创建初始候选项集C1,再调用函数generate_Lk_by_Ck根据C1生成频繁1项集L1。接着,将L1存储在列表L中,并将L1赋值给Lksub1,表示当前频繁项集的项数为1。
接下来,函数generate_L通过一个循环,依次生成包含2~k个项的频繁项集。在每次循环中,首先调用函数create_Ck根据Lksub1生成候选项集Ci,然后调用函数generate_Lk_by_Ck根据Ci生成频繁项集Li。将Li存储在列表L中,并将Li赋值给Lksub1,表示当前频繁项集的项数为i。最后,函数generate_L返回频繁项集列表L和支持度字典support_data。
def create_C1(dataset): C1 = [] for transaction in dataset: for item in transaction: if not [item] in C1: C1.append([item]) C1.sort() return list(map(frozenset, C1)) # print(len(create_C1(dataset))) def scan_D(D, Ck, min_support): ssCnt = {} for tid in D: for can in Ck: if can.issubset(tid): if not can in ssCnt: ssCnt[can] = 1 else: ssCnt[can] += 1 num_items = float(len(D)) retList = [] support_data = {} for key in ssCnt: support = ssCnt[key] / num_items if support >= min_support: retList.insert(0, key) support_data[key] = support return retList, support_data def apriori_gen(Lk, k): retList = [] len_Lk = len(Lk) for i in range(len_Lk): for j in range(i + 1, len_Lk): L1 = list(Lk[i])[:k - 2] L2 = list(Lk[j])[:k - 2] L1.sort() L2.sort() if L1 == L2: retList.append(Lk[i] | Lk[j]) return retList def apriori(dataset, min_support): C1 = create_C1(dataset) D = list(map(set, dataset)) L1, support_data = scan_D(D, C1, min_support) L = [L1] k = 2 while len(L[k - 2]) > 0: Ck = apriori_gen(L[k - 2], k) Lk, support_k = scan_D(D, Ck, min_support) support_data.update(support_k) L.append(Lk) k += 1 return L, support_data如果我想在这段代码中加入置信度,怎么加
在这段代码中加入置信度,实际上是要实现关联规则算法。在Apriori算法的基础上,可以通过以下步骤来实现关联规则算法:
1. 从频繁项集L中生成候选规则集合,即对于每个频繁项集,生成包含该项集中所有元素的所有子集。
2. 对于每个候选规则,计算其置信度,并筛选出满足最小置信度要求的规则。
下面是修改后的代码实现:
```python
def generate_rules(L, support_data, min_conf):
rules_list = []
for i in range(1, len(L)):
for freq_set in L[i]:
H1 = [frozenset([item]) for item in freq_set]
if i > 1:
rules_from_conseq(freq_set, H1, support_data, rules_list, min_conf)
else:
calc_conf(freq_set, H1, support_data, rules_list, min_conf)
return rules_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
def rules_from_conseq(freq_set, H, support_data, brl, min_conf):
m = len(H[0])
if len(freq_set) > (m + 1):
Hmp1 = apriori_gen(H, m + 1)
Hmp1 = calc_conf(freq_set, Hmp1, support_data, brl, min_conf)
if len(Hmp1) > 1:
rules_from_conseq(freq_set, Hmp1, support_data, brl, min_conf)
def apriori(dataset, min_support, min_conf):
C1 = create_C1(dataset)
D = list(map(set, dataset))
L1, support_data = scan_D(D, C1, min_support)
L = [L1]
k = 2
while len(L[k - 2]) > 0:
Ck = apriori_gen(L[k - 2], k)
Lk, support_k = scan_D(D, Ck, min_support)
support_data.update(support_k)
L.append(Lk)
k += 1
rules_list = generate_rules(L, support_data, min_conf)
return L, support_data, rules_list
```
其中,generate_rules函数用于生成关联规则,calc_conf函数用于计算规则的置信度,rules_from_conseq函数用于从频繁项集中生成候选规则,apriori函数用于调用Apriori算法和关联规则算法,并返回频繁项集、支持度数据和关联规则列表。在调用apriori函数时,需要传入最小支持度和最小置信度阈值。