【无标题】Apior算法

def loadDataSet():

   list1= [[1, 3, 4], [2, 3, 5], [1, 2, 3, 5], [2, 5]]

   return list1

 

def createC1(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))

 

def scanD(D, Ck, min_support):

    ss_cnt = {}

    retlist = []

    support_data = {}

    num_items = float(len(D))

    for tid in D:

        for can in Ck:

            if can.issubset(tid):

                if can not in ss_cnt:

                    ss_cnt[can] = 1

                else:

                    ss_cnt[can] += 1

    for key in ss_cnt:

        support = ss_cnt[key] / num_items

        if support >= min_support:

            retlist.append(key)

            support_data[key] = support

    return retlist, support_data

 

def aprioriGen(Lk, k):

    ret_list = []

    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:

                if doNothaveInfreqSet(Lk[i] | Lk[j], Lk):

                    ret_list.append(Lk[i] | Lk[j])

    return ret_list

 

def doNothaveInfreqSet(ck_plus_1, Lk):

    for item in ck_plus_1:

        sub_ck = ck_plus_1 - frozenset([item])

        if sub_ck not in Lk:

            return False

    return True

 

def apriori(data_set, min_support=0.5):

    C1 = createC1(data_set)

    L1, support_data = scanD(data_set, C1, min_support)

    L = [L1]

    k = 2

    while len(L[k - 2]) > 0:

        Ck = aprioriGen(L[k - 2], k)

        Lk, sup_k = scanD(data_set, Ck, min_support)

        support_data.update(sup_k)

        L.append(Lk)

        k += 1

    return L, support_data

 

# 调用示例

dataset = loadDataSet()

L, supportData = apriori(dataset)