Utilizzo dell'algoritmo Apriori in Python per l'analisi di associazione

La ricerca di relazioni implicite tra articoli in grandi dataset è chiamata analisi di associazione o apprendimento di regole di associazione. Il processo si suddivide in due fasi: 1. Estrazione di set di frequenti. 2. Estrazione di regole di associazione dai set di frequenti.

Un insieme di frequenti è una raccolta di articoli che compaiono spesso insieme.
Le regole di associazione suggeriscono che esista una relazione molto forte tra due articoli.
Il supporto di un insieme è definito come la percentuale di record nel dataset che contengono l'insieme, utilizzato per rappresentare la frequenza dell'insieme. La supporto è definita sull'insieme.
La confidenza o la fiducia è definita per una regola di associazione come {pannolini}->{vino}. La confidenza di questa regola è definita come “supporto({pannolini, vino})/supporto({pannolini})”.

Cercare set di frequenti

Principio di Apriori: se un insieme è frequente, allora tutte le sue sottosette sono frequenti. Al contrario, se un insieme è un insieme non frequente, allora tutti i suoi superinsiemi sono non frequenti.

L'algoritmo Apriori è un metodo per trovare set di frequenti. L'algoritmo genera prima una lista di insiemi di singoli articoli, quindi scansiona le registrazioni delle transazioni per vedere quali insiemi soddisfano i requisiti di supporto minimo, e quegli insiemi che non soddisfano i requisiti di supporto minimo vengono rimossi. Poi combina i rimanenti insiemi per generare insiemi che contengono due elementi. Poi scansiona di nuovo le registrazioni delle transazioni, rimuovendo gli insiemi che non soddisfano i requisiti di supporto minimo, e questo processo si ripete fino a quando tutti gli insiemi vengono rimossi.
Codice pseudo di Apriori

Quando il numero di elementi nella lista è maggiore di 0:
　　　 Controllare i dati per confermare che ogni insieme sia frequente
　　　 Rimettere i set di frequenti e costruire una lista di candidati a k+1 elementi

Estrarre regole di associazione dai set di frequenti

Quando la confidenza è superiore alla confidenza minima, può essere considerato che contiene regole di associazione. È possibile osservare che se una regola non soddisfa i requisiti di confidenza minima, allora tutte le sue sottosette non soddisferanno anche i requisiti di confidenza minima.
Puoi iniziare da un insieme frequente, quindi creare un elenco di regole dove la parte destra contiene solo un elemento, quindi testare queste regole, quindi unire, creando un nuovo elenco di regole dove la parte destra contiene due elementi, e così via.

Ogni insieme frequente:
　　　 while(len(L)>1)
　　　　　　　 (elenco delle regole k)
　　　　　　　 Soddisfano il minimo livello di confidenza
　　　　　　　 Creare regole k+1

Codice complessivo:

import numpy as np
def loadDataSet():
  ritorna [[1, 3, 4], [2, 3, 5], [1, 2, 3, 5], [2, 5]]
def createC1(dateSet):
  c1 = []
  per line in dateSet:
    per item in line:
      se not [item] in c1:
        c1.append([item])
  c1.sort()
  ritorna lista(map(frozenset,c1))
def scanData(data,ck,minSupport):# Cerca gli insiemi di item che soddisfano il minimo supporto
  ssCnt = {}
  per tid in data:
    per can in ck:
      se can.issubset(tid):
        se can not in ssCnt.keys():
          ssCnt[can] = 0
        ssCnt[can] += 1
  numItems = len(data)
  retList = []
  supportData = {}
  per key in ssCnt.keys():
    support = ssCnt[key]/numItems
    se support >= minSupport:
      retList.append(key)
    supportData[key] = support
  ritorna retList, supportData
def aprioriGen(Lk,k): # Genera l'elenco k a partire dall'elenco k-1
  retList = []
  lenLk = len(Lk)
  per i in range(lenLk):
    per j in range(i+1, lenLk):
      l1 = elenco(Lk[i])[:k-2]
      l2 = list(Lk[j])[:k-2]
      l1.sort()
      l2.sort()
      se l1 == l2:
        retList.append(Lk[i] | Lk[j])
  return retList
def apriori(dataSet,minSupport = 0.5):#genera le insiemi frequenti
  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):#genera le regole
  bigRuleList = []
  per i in range(1,len(L)):
    per freqSet in L[i]:
      H1 = [frozenset([item]) for item in freqSet]
      se 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):#calcola le regole soddisfacenti la confidenza
  prunedH = []
  per conseq in H:
    conf = suppurtData[freqSet]/suppurtData[freqSet-conseq]
    se conf > minConf:
      brl.append((freqSet-conseq,conseq,conf))
      prunedH.append(conseq)
  return prunedH
def rulesFromConseq(freqSet, H, supportData, brl, minConf=0.7):#generazione ricorsiva di regole
  m = len(H[0])
  if len(freqSet) >= (m+1):
    Hmp1 = calcConf(freqSet, H, supportData, brl, minConf)
    if (len(Hmp1) > 1):
      Hmp1 = aprioriGen(Hmp1, m+1)
      rulesFromConseq(freqSet, Hmp1, 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)

Download di codice e dataset:Apriori

Questo è tutto il contenuto dell'articolo, speriamo che sia utile per la tua apprendimento, e speriamo che tutti possano sostenere e gridare le lezioni.

Dichiarazione: il contenuto di questo articolo è stato raccolto da Internet, il copyright è di proprietà del rispettivo autore, il contenuto è stato contribuito e caricato autonomamente dagli utenti di Internet, questo sito non detiene il diritto di proprietà, non è stato editato manualmente e non assume alcuna responsabilità legale correlata. Se trovi contenuti sospetti di copyright, ti preghiamo di inviare una email a notice#oldtoolbag.com (al momento dell'invio dell'email, sostituisci # con @) per segnalare, fornendo prove pertinenti. Una volta verificata, questo sito eliminerà immediatamente i contenuti sospetti di copyright.