Apriori挖掘的频繁项集是什么
时间: 2024-02-26 14:33:47 浏览: 19
Apriori算法是一种基于频繁项集的关联规则挖掘算法。它通过迭代的方式挖掘所有满足支持度和置信度阈值的频繁项集,并由此发现它们之间的关联规则。频繁项集是指在数据集中经常出现的一组物品的集合,其中支持度定义为包含该物品集合的事务数与总事务数之比。因此,Apriori挖掘的频繁项集是指在数据集中出现频率较高的一组物品的集合。
相关问题
使用python生成用Apriori算法挖掘频繁项集的代码
可以的,以下是用Python实现Apriori算法来挖掘频繁项集的简单代码:
```python
def loadDataSet():
return [[1,3,4],[2,3,5],[1,2,3,5],[2,5]]
def createC1(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))
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
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
def aprioriGen(Lk, k):
retList = []
lenLk = len(Lk)
for i in range(lenLk):
for j in range(i+1, lenLk):
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, minSupport = 0.5):
C1 = createC1(dataSet)
D = list(map(set, dataSet))
L1, supportData = scanD(D, C1, minSupport)
L = [L1]
k = 2
while (len(L[k-2]) > 0):
Ck = aprioriGen(L[k-2], k)
Lk, supK = scanD(D, Ck, minSupport)
supportData.update(supK)
L.append(Lk)
k += 1
return L, supportData
```
希望对你有所帮助!~
python 频繁项集_Apriori算法:从数据中挖掘频繁项集
好的,我可以为你解答有关 Python 中的频繁项集和 Apriori 算法的问题。
频繁项集是指在一个数据集中经常同时出现的一组项,例如在一个购物清单中,经常一起被购买的商品就是一个频繁项集。Apriori 算法是一种挖掘频繁项集的算法,它的基本思想是利用项集的支持度来筛选出频繁项集。
下面是一个简单的 Python 示例,演示如何使用 Apriori 算法从数据中挖掘频繁项集:
```python
# 导入需要的库
from itertools import combinations
from collections import defaultdict
# 定义 Apriori 算法
def apriori(data, min_support=0.5):
# 计算项集的支持度
item_counts = defaultdict(int)
for trans in data:
for item in trans:
item_counts[item] += 1
# 筛选出频繁项集
freq_items = set()
n = len(data)
for item, count in item_counts.items():
support = count / n
if support >= min_support:
freq_items.add(item)
k = 2
freq_sets = set(combinations(freq_items, k))
while freq_sets:
item_counts = defaultdict(int)
for trans in data:
for item_set in freq_sets:
if set(item_set).issubset(set(trans)):
item_counts[item_set] += 1
freq_items = set()
for item_set, count in item_counts.items():
support = count / n
if support >= min_support:
freq_items.add(item_set)
freq_sets = set(combinations(freq_items, k))
k += 1
return freq_items
# 测试数据
data = [
['apple', 'banana', 'orange', 'pear'],
['banana', 'orange'],
['apple', 'banana', 'orange'],
['apple', 'pear'],
['apple', 'banana', 'orange', 'pear']
]
# 挖掘频繁项集
freq_items = apriori(data, 0.5)
print(freq_items)
```
在这个示例中,我们定义了一个 `apriori` 函数来实现 Apriori 算法。该函数接受一个数据集 `data` 和一个最小支持度 `min_support` 作为参数,并返回一个包含频繁项集的集合。在函数内部,我们首先计算每个项的支持度,然后筛选出频繁项集。接下来,我们以递增的大小迭代项集的长度,直到没有更多的频繁项集为止。
在这个示例中,我们使用了一个简单的示例数据集,包含了一些购物清单。我们使用 `apriori` 函数来挖掘该数据集中的频繁项集,并输出结果。