def rules_from_conseq(freqSet, H, support_data, bigRuleList, minConf):
hmp1 = apriori.aprioriGen(H)
if len(freqSet) == len(hmp1[0]):
return
hmp1 = calc_conf(freqSet, hmp1, support_data, bigRuleList, minConf)
if len(hmp1) == 1:
return
else:
rules_from_conseq(freqSet, hmp1, support_data, bigRuleList, minConf)
def rulesFromConseq(freqSet, H, supportData, brl, minConf=0.7):
"""
该函数是为了从最初的频繁项集中生成更多的规则。
:param freqSet: 频繁项集中的元素
:param H: 频繁项集中的元素的集合。
:param supportData: 所有元素的支持度的字典
:param brl: 关联规则列表的空数组
:param minConf: 最小可信度
:return:
"""
m = len(H[0])
#先计算H中的频繁集大小m, 接下来查看频繁项集是否大到可以移除大小为m的子集。如果可以的话，则将其移除。
if (len(freqSet) > (m + 1)):
# 生成H中的无重复组合，这也是下一次迭代的H列表，Hmp1包含所有可能的规则
Hmp1 = apriori.aprioriGen(H, m+1)
Hmp1 = calcConf(freqSet, Hmp1, supportData, brl, minConf)
if (len(Hmp1) > 1): #如果不止一条规则满足要求，那么就使用Hmp1迭代调用rulesFromConseq()函数来判断是否进一步组合这些规则。
rulesFromConseq(freqSet, Hmp1, supportData, brl, minConf)
#!/usr/bin/env python
import sys
from apriori import createC1
from apriori import scanD
from apriori import aprioriGen
a = []
for i in sys.stdin:
i = i.strip()
v = i.split()
a.append(v)
c1 = createC1(a)
d = map(set, a)
K = 2
ps = 0.3
for i in range(K):
L1, sp = scanD(d, c1, ps)
c1 = aprioriGen(L1, i + 1)
for i in L1:
x, y = i
x = int(x)
y = int(y)
print "%d %d" % (x, y)
D = list(map(set, dataSet)) # 把数据转换成集合的形式存放在列表中
D
L1, supportData0 = apriori.scanD(
D, C1, 0.5) # 以0.5支持度为要求，计算候选集的每一个项的支持度，并返回大于支持度的集合L1
L1
supportData0
# 根据支持度生成频繁集
reload(apriori)
L, supportData = apriori.apriori(dataSet)
L # 获得支持度大于0.5的频繁集合
L[0] # 包含一个元素的
L[1] # 包含两个元素的
L[2] # 包含三个元素的
L[3]
apriori.aprioriGen(L[0], 2) # 看一下如何生成的未和支持度比较的‘L[1]’
L, supportData = apriori.apriori(dataSet, minSupport=0.7) # 更大的支持度，获得少的结果了
# 根据可信度生成关联规则
reload(apriori)
L, supportData = apriori.apriori(dataSet, minSupport=0.5)
rules = apriori.generateRules(L, supportData, minConf=0.7) # 0.7的可信度生成的规则
rules = apriori.generateRules(L, supportData, minConf=0.5) # 0.5的可信度生成的规则
# 在毒蘑菇的数据集上测试下效果如何
mushDataSet = [line.split() for line in open('mushroom.dat').readlines()]
# 这个数据集第一列是标签是否有毒
L, supportData = apriori.apriori(mushDataSet, minSupport=0.3)
for item in L[3]:
if item.intersection('2'): # 看下包含特征有毒为2的频繁项集
print(item)
import random
import loadText
support = 0.4
loadText.importFromFile('spanish_db.txt')
dataset = loadText.rawPriori
#print dataset
C1 = apriori.createC1(dataset)
#print 'C1', C1
D = map(set,dataset)
#print 'D', D
L1, support_data = apriori.scanD(D,C1,support)
#print 'L1', L1
#print 'support_data', support_data
k_length = 2
transactions = apriori.aprioriGen(L1, k_length)
#print 'transactions', transactions
#print '\n*** *** ***'
L,support_data = apriori.apriori(dataset, support)
#print 'L', L
#print 'support_data', support_data
rules = apriori.generateRules(L, support_data, min_confidence=0.7)
#print 'rules', rules
ruleDict = apriori.generateRuleDict(rules)
'''
print 'ruleDict', ruleDict
print '*** *** ***'
'''
print 'keys', ruleDict.keys()
C1 = apriori.createC1(dataSet)
C1
D = list(map(set, dataSet))
D
L1, suppData0 = apriori.scanD(D, C1, 0.5)
L1
from importlib import reload
reload(apriori)
L, suppData = apriori.apriori(dataSet)
L
L[0]
L[1]
L[2]
L[3]
apriori.aprioriGen(L[0], 2)
L, suppData = apriori.apriori(dataSet, minSupport=0.7)
L
# 测试关联规则函数
reload(apriori)
L, suppData = apriori.apriori(dataSet, minSupport=0.5)
rules = apriori.generateRules(L, suppData, minConf=0.7)
rules
rules = apriori.generateRules(L, suppData, minConf=0.5)
rules
# 示例：发现毒蘑菇的相似特征
mushDatSet = [line.split() for line in open('mushroom.dat').readlines()]
L, suppData = apriori.apriori(mushDatSet, minSupport=0.3)
for item in L[1]:
support = 0.1
loadText.importFromFile('snowflakes_db.txt')
dataset = loadText.rawPriori
#print dataset
C1 = apriori.createC1(dataset)
#print 'C1', C1
D = map(set, dataset)
#print 'D', D
L1, support_data = apriori.scanD(D, C1, support)
#print 'L1', L1
#print 'support_data', support_data
print 'support_data'
for k, v in support_data.iteritems():
print k, v
k_length = 2
transactions = apriori.aprioriGen(L1, k_length)
#print 'transactions', transactions
#print '\n*** *** ***'
L, support_data = apriori.apriori(dataset, support)
#print 'L', L
#print 'support_data', support_data
rules = apriori.generateRules(L, support_data, min_confidence=0.7)
#print 'rules', rules
ruleDict = apriori.generateRuleDict(rules)
print 'ruleDict'
for k, v in ruleDict.iteritems():
print '\t', k, "".join(
' '
for i in range(30 - len(''.join(item
'''
prunedH = []
for conseq in H:
conf = supportData[freqSet] / supportData[freqSet - conseq]
if conf >= minConfident:
print freqSet - conseq, '-->', conseq, 'conf:', conf
brl.append((freqSet - conseq, conseq, conf))
prunedH.append(conseq)
return prunedH
def rulesFromConseq(freqSet, H, supportData, brl, minConfident=0.5):
'''
Genere conjuntos de reglas candidatas, por ejemplo, {2,3} genera reglas candidatas {2} ➞ {3}, {3} ➞ {2}.
Genere el conjunto de reglas candidatas del siguiente nivel de acuerdo con el conjunto de reglas candidatas actual H
Genere más reglas de asociación a partir del conjunto de elementos inicial.
Esta función tiene dos parámetros: FreqSet de elementos frecuentes, que puede aparecer en la lista de elementos H a la derecha de la regla.
Los parámetros restantes: supportData guarda el soporte del conjunto de elementos, brl guarda las reglas de asociación generadas y minConf es lo mismo que la función principal.
La función primero calcula el tamaño del conjunto de elementos frecuentes m en H. A continuación, compruebe si el conjunto de elementos frecuentes es lo suficientemente grande como para eliminar un subconjunto de tamaño m.
Si es posible, retírelo. Utilice la función aprioriGen () para generar una combinación no repetida de elementos en H, y el resultado se guarda en Hmp1, que también es la lista H para la siguiente iteración.
'''
m = len(H[0])
while (len (freqSet)> m): # Juzgue la longitud> m, entonces se puede obtener la credibilidad de H
H = calcConf(freqSet, H, supportData, brl, minConfident)
if (len (H)> 1): # Determine si hay un elemento con una credibilidad mayor que el umbral después de que se calcula la credibilidad para generar la siguiente capa de H
H = apriori.aprioriGen(H, m + 1)
m +=1
else: # No se puede continuar generando el siguiente nivel de reglas de asociación de candidatos, salga del ciclo antes
break
#https://programmerclick.com/article/8103986113/
import apriori dataSet = apriori.loadDataSet() print dataSet C1 = apriori.createC1(dataSet) print C1 D = map(set, dataSet) print D L1, suppData0 = apriori.scanD(D, C1, 0.5) print L1 reload(apriori) L, suppData = apriori.apriori(dataSet) print L print L[0] print L[1] print L[2] print L[3] print apriori.aprioriGen(L[0], 2) L, suppData = apriori.apriori(dataSet, minSupport=0.7) print L reload(apriori) L, suppData = apriori.apriori(dataSet, minSupport=0.5) rules = apriori.generateRules(L, suppData, minConf=0.7) print rules rules = apriori.generateRules(L, suppData, minConf=0.5) print rules