1. Conocimiento requerido

Reglas de asociación

La regla de asociación es una expresión de implicación de la forma x-> y, donde x e y son conjuntos de elementos disjuntos, es decirX∩Y = ∅

Conjuntos de artículos

Mantenga 0 o más artículosColeccionSi el número de conjuntos de elementos es k, se denomina conjuntos de elementos K.
Ejemplo: {egg, fruit, cake} es un conjunto vacío de 3 elementos.

Reglas de fuerza de asociación

Generalmente se mide por el apoyo y la confianza.

Apoyo

Orden de transacción	Mercancia
0 0	Pañales de cola de leche de huevo
1	Cerveza huevo cola
2	Huevos de leche

En la lista anterior,
el soporte de huevos es 3/3, la
leche es 2/3, los
pañales 1/3 de
coca cola 2/3
(huevos, pañales) es 0
(egg cola) es 1/3
, es decir, el soporte de un conjunto de elementos es que él está en Aparecer en todos los elementosFrecuencia

Credibilidad (confianza)

Credibilidad y estadística matemática Probabilidad condicionalSimilar a
la confianza en comprar x y comprar y al mismo tiempo que
confianza (x-> y) = P (y / x) = P (x, y) / P (x) = comprar x, y al mismo tiempo / comprar x
coca cola-> huevos credibilidad a
también comprar huevos de Coca-Cola = 1/3 - (huevos, cola) de apoyo
para comprar dos tercios de Coca-Cola - apoyo de la de Coca-Cola
resultado es 1/2 - dividido por
la misma razón los huevos -> Coca-Cola
2 / 3

Ascensor (no usado)

lift (x-> y) = P (x, y) / (P (x) * P (y) = P (y / x) / P (y)
Hay muchos tipos de métodos de cálculo
que se refieren a comprar x vs comprar y ¿Hay un efecto de elevación, es útil si el valor es mayor que 1, 1 no es relevante, menos de 1 correlación negativa
Coque-> huevos , el grado de promoción es
1/3 / (2/3 * 1) = 2 comprar Coca tiene un efecto de elevación en la compra de huevos

Proyecto

Los campos en la base de datos de transacciones,
es decir, varios productos son un artículo, el huevo es un artículo, la leche es un artículo

Negocios

Una colección de todos los artículos en una transacción,
es decir , todo lo que una persona compra una vez {huevos, leche} es una transacción. Compra todo en nombre de los transeúntes A

Conjuntos de artículos frecuentes

Todos los conjuntos de elementos cuyo soporte es mayor que el soporte mínimo se denominanConjuntos de artículos frecuentes, Denominado conjunto de frecuencias (el usuario especifica el soporte mínimo)

Máximo conjunto de artículos frecuentesSon conjuntos de elementos frecuentes que no están contenidos por otros elementos

Teoremas relevantes de conjuntos de elementos

Teorema (atributo Apriori 1).
Si el conjunto de elementos X es un conjunto de elementos frecuente, entonces todos sus subconjuntos no vacíos son
teoremas de conjuntos de elementos frecuentes (atributo Apriori 2).
Si el conjunto de elementos X es un conjunto de elementos no frecuente, entonces todos sus superconjuntos Ambos son conjuntos de elementos no frecuentes.
Las pruebas son simples y fáciles de entender, solo comprenda desde la definición.

Problema de minería de reglas de asociación

El problema de minería de reglas de asociación se puede dividir en dos subproblemas:

Buscar conjuntos de elementos frecuentes: a través del Minsupport proporcionado por el usuario, encuentre todos los conjuntos de elementos frecuentes o los conjuntos de elementos frecuentes más grandes.
Genere reglas de asociación: a través del Minconfidence dado por el usuario, encuentre las reglas de asociación en el conjunto de proyectos frecuentes.

Regla de asociación fuerte

La regla de asociación que D satisface el soporte mínimo y la confianza mínima (Confianza mínima) en I se llama la regla de asociación fuerte (Regla de asociación fuerte).

Es decir, necesitamos encontrar las reglas de acuerdo con el mínimo apoyo y la mínima confianza que le damos.

2. Ejemplos

1. Encuentra los conjuntos de artículos más frecuentes

Inserte la descripción de la imagen aquí
Cada vez que se escanea la base de datos, comenzando con 1 conjunto de elementos, elimine los elementos que no cumplan con el soporte mínimo especificado por el usuario (aquí 2). El grado de soporte es 0.5, y luego combine dos pares para generar el conjunto de elementos i + 1 y luego elimine hasta que el final sea único. Encontramos el conjunto de elementos frecuentes más grande {B, C, E} Los otros tres conjuntos de elementos no cumplen con el soporte mínimo, esta cifra no está marcada, hay {A, B, C}, {A, C, E en C3 }, {A, B, E} solo admiten 1/4

2. Genere reglas de asociación fuertes

Inserte la descripción de la imagen aquí
Si tomamos la credibilidad mínima como 80% y mayor que 0.8, podemos ser creíbles

Conjuntos de elementos máximos frecuentes (soporte)	Subconjunto (soporte)	Credibilidad	Reglas	Si fuerte asociación
B, C, E (50%)	B, C （50%）	100%	BC-> E	Si
B, C, E (50%)	B, E （75%）	67%	BE-> C	No
B, C, E (50%)	C, E (50%)	100%	CE-> B	Si
B, C, E (50%)	B （75%）	67%	B-> CE	No
B, C, E (50%)	C （75%）	67%	C-> BE	No
B, C, E (50%)	E （75%）	67%	E-> BC	No

De esta manera, se encuentra una fuerte regla de asociación BC-> E y CE-> B

3. Algoritmo

Algoritmo de Python, la escritura también es copiada por otros, agregué un orden lexicográfico para que se vea mejor

Los comentarios son escritos por mí mismo

Consulte al segundo autor del
autor original.



def load_data_set():
    '''
    给出数据库事务集
    :return: data
    '''
    data_set = [
        ['A' ,'C' ,'D'],
        ['B' ,'C' ,'E'],
        ['A' ,'B' ,'C' ,'E'],
        ['B' ,'E']
    ]

    data =[
        ['a','c','d','e','f'],
        ['b','c','f'],
        ['a','d','f'],
        ['a','c','d','e'],
        ['a','b','d','e','f']
    ]
    return data_set


def Create_C1(data_set):
    '''
    生成候选1项集
    '''
    C1 = set()
    for t in data_set:  # 每一个事务
        for item in t:  #每一个商品
            item_set = frozenset([item]) # { 'a' } 的形式，
            # 用frozenset 是因为键值对的键要满足不可变 不然就破坏了键的唯一性和确定性
            # 为生成频繁项目集时扫描数据库时以提供issubset()功能.
            C1.add(item_set)
    return C1  # 类似[ {'a'} ,{'b'}]


def is_apriori(Ck_item, Lk_sub_1):
    '''
    参数：候选频繁k项集，频繁k-1项集  原理是只要含有不频繁项集的项集就是不频繁的 用于剪枝
    '''
    for item in Ck_item:  # 校验候选k项集中是否每一项的真子集是频繁k-1项集
        sub_item = Ck_item - frozenset([item])
        if sub_item not in Lk_sub_1:
            return False
    return True


def Create_Ck(Lk_sub_1, k):
    '''
    # 参数：频繁k-1项集，当前要生成的候选频繁几项集 切k>2
    '''
    Ck = set()
    len_Lk_sub_1 = len(Lk_sub_1)
    list_Lk_sub_1 = list(Lk_sub_1)
    for i in range(0,len_Lk_sub_1):  #遍历每一项 索引是i
        for j in range(i + 1, len_Lk_sub_1):  # 遍历接下来的每一项 索引是j 相当于两两组合  （自连接）
            l1 = list(list_Lk_sub_1[i])
            l2 = list(list_Lk_sub_1[j])
            # 排序便于比较  顺序是字典序
            l1.sort()
            l2.sort()
            # 判断l1的前k-1-1个元素与l2的前k-1-1个元素对应位是否全部相同
            # 因为我们要产生的是 候选频繁k项集，所以对于频繁k-1项集 只需要k-2项相等，1项不相等连接才能产生
            if l1[0:k - 2] == l2[0:k - 2]:
                Ck_item = list_Lk_sub_1[i] | list_Lk_sub_1[j]  # 求集合的并 相当于生成候选频繁k项集了
                if is_apriori(Ck_item, Lk_sub_1):   # 剪枝
                    Ck.add(Ck_item)
    return Ck


def Generate_Lk_By_Ck(data_set, Ck, min_support, support_data):
    '''
    参数：数据库事务集，候选频繁k项集，最小支持度，项目集-支持度dic
    '''
    Lk = set()
    # 通过dic记录候选频繁k项集的事务支持个数
    item_count = {}
    for t in data_set:
        for Ck_item in Ck:
            if Ck_item.issubset(t):  # 候选频繁k项集中每一项 对事务集开始 统计支持度
                if Ck_item not in item_count:
                    item_count[Ck_item] = 1
                else:
                    item_count[Ck_item] += 1
    data_num = float(len(data_set))
    for item in item_count:
        if (item_count[item] / data_num) >= min_support: # 满足最小支持度加入频繁k项集,把支持度也加入支持度字典中
            Lk.add(item)
            support_data[item] = item_count[item] / data_num
    return Lk


def Generate_L(data_set, max_k, min_support):  #求最大频繁项集 和所有的频繁项集
    '''
    参数：数据库事务集，求的最高项目集为k项，最小支持度
    '''
    # 创建一个频繁项目集为key，其支持度为value的dic
    support_data = {}
    C1 = Create_C1(data_set)
    L1 = Generate_Lk_By_Ck(data_set, C1, min_support, support_data)
    Lk_sub_1 = L1.copy()  # 对L1进行浅copy
    L = []
    L.append(Lk_sub_1)  # 末尾添加指定元素
    for k in range(2, max_k + 1):   # 结尾不包括 所以加1
        Ck = Create_Ck(Lk_sub_1, k)
        Lk = Generate_Lk_By_Ck(data_set, Ck, min_support, support_data)
        Lk_sub_1 = Lk.copy()
        L.append(Lk_sub_1)
    return L, support_data


def Generate_Rule(L, support_data, min_confidence):
    '''
    参数：所有的频繁项目集，项目集-支持度dic，最小置信度
    '''
    rule_list = []
    sub_set_list = []
    for i in range(len(L)):
        for frequent_set in L[i]:  # 每一个频繁k项集
            for sub_set in sub_set_list:  # 每一个频繁k项的子集
                if sub_set.issubset(frequent_set):  #必须是频繁项集的子集
                    conf = support_data[frequent_set] / support_data[sub_set]  #可信度
                    # 强关联规则格式为 子集 频繁项集  可信度
                    rule = (sub_set, frequent_set - sub_set, conf)
                    if conf >= min_confidence and rule not in rule_list: # 去重 并添加规则
                        rule_list.append(rule)
            sub_set_list.append(frequent_set)
    return rule_list


if __name__ == "__main__":
    data_set = load_data_set()
    '''
    print("Test")
    # 数据库事务打印
    for t in data_set:
        print(t) 
    '''
    '''
    print("Test")
    # 候选频繁1项集打印
    C1 = Create_C1(data_set)
    for item in C1:
        print(item)
    '''
    '''
    # 频繁1项集打印
    print("Test")
    L = Generate_L(data_set, 1, 0.2)
    for item in L:
        print(item)
    '''
    '''
    # 频繁k项集打印
    print("Test")
    L, support_data = Generate_L(data_set, 2, 0.2)
    for item in L:
        print(item)
    '''
    '''
    # 关联规则测试
    print("Test")
    L, support_data = Generate_L(data_set, 3, 0.2)
    rule_list = Generate_Rule(L, support_data, 0.7)
    for item in support_data:
        print(item, ": ", support_data[item])
    print("-----------------------")
    for item in rule_list:
        print(item[0], "=>", item[1], "'s conf:", item[2])
    '''
    # 最大频繁项集的项数 k 最小支持度 最小可信度
    maxK=3
    minsupport=0.5
    minconfidence=0.8


    L, support_data = Generate_L(data_set, maxK, minsupport)
    rule_list = Generate_Rule(L, support_data, minconfidence)


    print()
    print()
    print("最小支持度:"+str(minsupport)+"\t最小置信度："+str(minsupport)+"\t最大频繁项的项数:"+str(maxK))
    for Lk in L:
        print("=" * 40)
        print("frequent " + str(len(list(Lk)[0])) + "-itemsets\t\tsupport")
        #print("=" * 40)
        for frequent_set in Lk:
            s="{}\t\t\t{}"
            a=list(frequent_set)
            a.sort()  # 排序字典序
            print(s.format(a, support_data[frequent_set]))
    print()
    print("Rules\t\t\t\t最小置信度"+str(minsupport))
    for item in rule_list:
        a=list(item[0])
        a.sort()
        print(a, "=>", list(item[1]), "'s conf: ", item[2])