Uso del algoritmo Apriori en Python para análisis de asociación

La búsqueda de relaciones implícitas entre artículos en conjuntos de datos a gran escala se llama análisis de asociación o aprendizaje de reglas de asociación. El proceso se divide en dos pasos:1. Extraer conjuntos de items frecuentes.2. Extraer reglas de asociación de conjuntos de items frecuentes.

Un conjunto de items frecuentes es una colección de artículos que aparecen juntos con frecuencia.
Las reglas de asociación sugieren que dos artículos pueden tener una relación muy fuerte entre sí.
El soporte de un conjunto de items se define como la proporción de registros en el conjunto de datos que contienen ese conjunto de items, se utiliza para representar la frecuencia del conjunto de items. La definición de soporte se aplica a los conjuntos de items.
La credibilidad o confianza es para una regla como {pañal}-Las reglas de asociación de {vino} definidas. La credibilidad de esta regla se define como 'soporte ({pañal, vino})'/Soporte ({pañal})

Búsqueda de conjuntos de items frecuentes

Principio de Apriori: si un conjunto de items es frecuente, entonces todos sus subconjuntos también son frecuentes. Por el contrario, si un conjunto de items es un conjunto no frecuente, entonces todos sus superconjuntos también son no frecuentes.

El algoritmo Apriori es un método para encontrar conjuntos de items frecuentes. Este algoritmo primero genera una lista de conjuntos de items individuales, luego escanea los registros de transacciones para ver qué conjuntos de items satisfacen los requisitos de soporte mínimo. Los conjuntos de items que no satisfacen los requisitos de soporte mínimo se eliminan. Luego, se combinan los conjuntos restantes para generar conjuntos de items que contienen dos elementos. A continuación, se escanea nuevamente los registros de transacciones, eliminando los conjuntos de items que no satisfacen los requisitos de soporte mínimo, y este proceso se repite hasta que todos los conjuntos de items se eliminan.
Pseudocódigo de Apriori

cuando el número de elementos en la lista sea mayor de 0:
　　　 verificar los datos para confirmar que cada conjunto de elementos sea frecuente
　　　 mantener conjuntos de elementos frecuentes y construir k+1lista de conjuntos de elementos candidatos formados por elementos

extraer reglas de asociación de conjuntos de elementos frecuentes

Cuando la confianza sea mayor que la confianza mínima, se puede considerar que contiene reglas de asociación. Se puede observar que si una regla no cumple con el requisito de confianza mínima, entonces todas las subconjuntos de esa regla tampoco cumplirán con el requisito de confianza mínima.
puede comenzar primero con un conjunto de elementos frecuentes, luego crear una lista de reglas, donde la parte derecha de las reglas contiene solo un elemento, luego probar estas reglas, luego fusionar, creando una nueva lista de reglas donde la parte derecha de las reglas contiene dos elementos, y así sucesivamente.

cada conjunto de elementos frecuentes:
　　　 while(len(L)>1)
　　　　　　　 (lista de reglas k)
　　　　　　　 satisfaciendo la confianza mínima
　　　　　　　 creación de k+1reglas

código completo:

import numpy as np
def loadDataSet():
  return [[1, 3, 4], [2, 3, 5], [1, 2, 3, 5], [2, 5]
def createC1(dateSet):
  c1 =
  for line in dateSet:
    for item in line:
      if not [item] in c1:
        c1.append([item])
  c1.sort()
  return list(map(frozenset,c1))
def scanData(data,ck,minSupport):#buscando conjuntos de elementos que satisfacen el apoyo mínimo
  ssCnt = {}
  for tid in data:
    for can in ck:
      if can.issubset(tid):
        if can not in ssCnt.keys():
          ssCnt[can] = 0
        ssCnt[can] += 1
  numItems = len(data)
  retList = []
  supportData = {}
  for key in ssCnt.keys():
    support = ssCnt[key]/numItems
    if support >= minSupport:
      retList.append(key)
    supportData[key] = support
  return retList,supportData
def aprioriGen(Lk,k): #según k-1generación de conjuntos de elementos k
  retList = []
  for i in range(lenLk):
  for j in range(i
    ,lenLk):+1= list(Lk[i])[:k
      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 = scanData(D,c1,minSupport)
  L = [l1]
  k = 2
  while(len(L[k-2])>0):
    ck = aprioriGen(L[k-2],k)
    lk,supk = scanData(D,ck,minSupport)
    k = k + 1
    L.append(lk)
    supportData.update(supk)
  return L,supportData
def generaterRules(L,supportData,minConf=0.7)#生成规则
  bigRuleList = []
  for i in range(1,len(L)):
    for freqSet in L[i]:
      H1 = [frozenset([item]) for item in freqSet]
      if i>1:
        rulesFromConseq(freqSet,H1,supportData,bigRuleList,minConf)
      else:
        calcConf(freqSet,H1,supportData,bigRuleList,minConf)
  return bigRuleList
def calcConf(freqSet,H,suppurtData,brl,minConf = 0.7)#计算满足置信度的规则
  prunedH = []
  for conseq in H:
    conf = suppurtData[freqSet/suppurtData[freqSet-conseq]
    if conf > minConf:
      brl.append((freqSet-conseq,conseq,conf))
      prunedH.append(conseq)
  prunedH.append(conseq)
return prunedH7def rulesFromConseq(freqSet,H,supportData,brl,minConf=0.
  ):#Generación recursiva de reglas
  m = len(H[0])+1) >
    ):1 if len(freqSet)>=(m
    = calcConf(freqSet,H,supportData,brl,minConf)1if (len(Hmp 1) >
      ):1 Hmp1= aprioriGen(Hmp+1)
      ,m1,supportData,brl,minConf)
data = [line.split() for line in open('mushroom.dat').readlines()]
L,support = apriori(data,minSupport=0.3)
for i in range(len(L)):
  for item in L[i]:
    if item & {2':
      print(item)

Descarga de código y conjuntos de datos:Apriori

Esto es todo el contenido de este artículo, espero que sea útil para su aprendizaje y que todos apoyen el tutorial de clamor.

Declaración: el contenido de este artículo se obtiene de la red, es propiedad del autor original, el contenido se contribuye y carga de manera autónoma por los usuarios de Internet, este sitio no posee los derechos de propiedad, no se ha procesado editorialmente y no asume ninguna responsabilidad legal relacionada. Si encuentra contenido sospechoso de infracción de derechos de autor, por favor envíe un correo electrónico a: notice#oldtoolbag.com (al enviar un correo electrónico, por favor reemplace # con @) para denunciar, y proporcionar evidencia relevante. Una vez confirmado, este sitio eliminará inmediatamente el contenido sospechoso de infracción.