Cómo entender el algoritmo a priori de la regla de asociación
Comprenda el algoritmo a priori de reglas de asociación: el algoritmo a priori es el primer algoritmo de minería de reglas de asociación y el algoritmo más clásico. Utiliza un método iterativo de búsqueda capa por capa para encontrar la relación entre conjuntos de elementos. la base de datos para formar reglas, el proceso consiste en conectar operaciones matriciales y podar para eliminar resultados intermedios innecesarios.
Comprensión del algoritmo de regla de asociación a priori:
1. Concepto
Tabla 1 Base de datos de transacciones de un supermercado
Número de transacción TID
Artículos adquiridos por clientes
Número de transacción TID
Artículos adquiridos por clientes
T1
pan, nata, leche , té
T6
pan, té
T2
pan, nata, leche
T7
cerveza, leche, té
T3
pastel, leche
T8
pan, té
T4
leche, té
T9
pan, nata, leche, té
T5
pan, pastel, leche
T10
pan, leche, té
Definición 1: Supongamos I={i1,i2,?,im}, que es m Una colección de proyectos diferentes, cada ik se llama proyecto. La colección I de elementos se llama conjunto de elementos. El número de sus elementos se denomina longitud del conjunto de elementos, y un conjunto de elementos de longitud k se denomina conjunto de elementos k. En el ejemplo, cada producto es un artículo, el conjunto de artículos es I = {pan, cerveza, pastel, crema, leche, té} y la longitud de I es 6.
Definición 2: Cada transacción T es un subconjunto del conjunto de elementos I. Correspondiente a cada transacción, existe un número de transacción de identificación único, registrado como TID. Todas las transacciones constituyen la base de datos de transacciones D, y |D| es igual al número de transacciones en D. El ejemplo contiene 10 transacciones, por lo que |D|=10.
Definición 3: Para el conjunto de elementos X, establezca count(X?T) para que sea el número de transacciones que contienen X en el conjunto de transacciones D, luego el soporte del conjunto de elementos >support(X)=count(X?T )/|D|
En el ejemplo, X={pan, leche} aparece en T1, T2, T5, T9 y T10, por lo que el soporte es 0,5.
Definición 4: El soporte mínimo es el umbral de soporte mínimo del conjunto de elementos, registrado como SUPmin, que representa la importancia mínima de las reglas de asociación que le interesan al usuario. Los conjuntos de elementos cuyo soporte no es menor que SUPmin se denominan conjuntos frecuentes, y los conjuntos frecuentes de longitud k se denominan conjuntos k-frecuentes. Si SUPmin se establece en 0,3, el soporte de {pan, leche} en el ejemplo es 0,5, por lo que es un conjunto de 2 frecuencias.
Definición 5: La regla de asociación es una implicación:
R: X?Y
¿Dónde X?I, Y?I y X∩Y=? . Indica que si el conjunto de elementos X aparece en una determinada transacción, Y también aparecerá con cierta probabilidad. Las reglas de asociación que interesan a los usuarios se pueden medir mediante dos estándares: apoyo y credibilidad.
Definición 6: El soporte de la regla de asociación R es la relación entre el número de transacciones en las que el conjunto de transacciones contiene X e Y y |D|. Es decir:
soporte(X?Y)=count(X?Y)/|D|
El soporte refleja la probabilidad de que X e Y aparezcan al mismo tiempo. El soporte de reglas de asociación es igual al soporte de conjuntos frecuentes.
Definición 7: Para la regla de asociación R, la credibilidad se refiere a la relación entre el número de transacciones que contienen X e Y y el número de transacciones que contienen X. Es decir:
confianza(X?Y)=soporte(X?Y)/soporte(X)
La confianza refleja que si la transacción contiene X, entonces la transacción contiene Y Probabilidad . En términos generales, sólo las reglas de asociación con un alto apoyo y credibilidad son de interés para los usuarios.
Definición 8: Establecer el soporte mínimo y la credibilidad mínima de las reglas de asociación como SUPmin y CONFmin. Si el apoyo y la credibilidad de la regla R no son menores que SUPmin y CONFmin, se denomina regla de asociación fuerte. El propósito de la minería de reglas de asociación es encontrar reglas de asociación sólidas para guiar la toma de decisiones de los comerciantes.
Estas ocho definiciones incluyen varios conceptos básicos importantes relacionados con las reglas de asociación. Hay dos problemas principales en la minería de reglas de asociación:
Encontrar todos los valores en la base de datos de transacciones que sean mayores. Mayor o igual que los conjuntos de elementos frecuentes especificados por el usuario con soporte mínimo. Se utilizan conjuntos de elementos frecuentes para generar las reglas de asociación requeridas y las reglas de asociación sólidas se filtran en función de la credibilidad mínima establecida por el usuario. En la actualidad, los investigadores están estudiando principalmente el primer problema: es difícil encontrar conjuntos frecuentes, pero es relativamente fácil generar reglas de asociación sólidas con conjuntos frecuentes.
2. Bases teóricas
Primero, veamos las propiedades de un conjunto frecuente.
Teorema: Si el conjunto de elementos X es un conjunto frecuente, entonces sus subconjuntos no vacíos son todos conjuntos frecuentes.
Según el teorema, dado el conjunto de elementos X de un conjunto k-frecuente, todos los subconjuntos de orden k-1 de conjuntos de elementos difieren sólo en un elemento y son iguales a X después de la concatenación. Esto demuestra que el conjunto k-candidato generado al concatenar k-1 conjuntos frecuentes cubre el conjunto k-frecuente. Al mismo tiempo, si el conjunto de elementos Y en el conjunto k-candidato contiene un subconjunto de orden k-1 que no pertenece al conjunto frecuente k-1, entonces Y no puede ser un conjunto frecuente y debe eliminarse del conjunto candidato. El algoritmo Apriori aprovecha esta propiedad de los conjuntos frecuentes.
3. Pasos del algoritmo:
El primero son los datos de prueba:
ID de transacción
Lista de ID de producto
T100
I1, I2, I5
T200
I2, I4
T300
I2, I3
T400
I1, I2, I4
T500
I1, I3
T600
I2, I3
T700
I1, I3
T800
I1, I2, I3, I5
T900
I1, I2, I3
Diagrama de pasos del algoritmo:
Se puede observar que el candidato seleccionado en la tercera ronda tiene se ha reducido significativamente.
Tenga en cuenta las dos condiciones para seleccionar conjuntos candidatos:
1. Las dos condiciones para que se conecten dos conjuntos de elementos K son que tengan elementos K-1 que sean iguales. Por lo tanto, (I2, I4) y (I3, I5) no se pueden conectar. El conjunto de candidatos se reduce.
2. Si un conjunto de elementos es un conjunto frecuente, entonces no tiene un conjunto frecuente que no sea un subconjunto. Por ejemplo, (I1, I2) y (I1, I4) obtienen (I1, I2, I4), y el subconjunto (I1, I4) de (I1, I2, I4) no es un conjunto frecuente. El conjunto de candidatos se reduce.
El apoyo de los dos conjuntos de candidatos obtenidos en la tercera vuelta es exactamente igual al apoyo mínimo. Por lo tanto, todos están incluidos en conjuntos frecuentes.
En este momento, observe el conjunto de candidatos y el conjunto frecuente en la cuarta ronda. Los resultados están vacíos
¡Puede ver que el conjunto de candidatos y el conjunto frecuente están en realidad vacíos! Debido a que el conjunto frecuente obtenido en la tercera ronda es autoconectado para obtener {I1, I2, I3, I5}, tiene el subconjunto {I2, I3, I5} y {I2, I3, I5} no es un conjunto frecuente. y no satisface: frecuente El subconjunto del conjunto también es un conjunto frecuente, por lo que se elimina mediante poda.
Por lo tanto, todo el algoritmo finaliza y el conjunto frecuente obtenido mediante el último cálculo se toma como resultado final del conjunto frecuente:
Es decir:,]
longitud = [] para i en locdata:
p>length.append(len(i)) # Calcular longitud y almacenar
# imprimir(longitud)
ki = longitud[longitud .index(max(length) )] # print(length[length.index(max(length))]) # length.index(max(length) lee la posición del valor máximo y luego localiza y recupera el valor máximo
return locdata, kidef create_C1(data_set): """
Cree un conjunto de elementos C1 candidato frecuente escaneando el conjunto de datos.
Args:
data_set: una lista de transacciones. Cada transacción contiene varios elementos.
Devuelve:
C1: un conjunto que contiene todos los conjuntos de 1 elemento candidatos frecuentes """
C1 = set() para t en data_set: para elemento en t:
item_set = frozenset([item])
C1.add(item_set) return C1def is_apriori(Ck_item, Lksub1): """
Juzgue si un conjunto de elementos k candidato frecuente satisface la propiedad de Apriori.
Args:
Ck_item: un candidato frecuente k-itemset en Ck que contiene todos los k-itemsets candidatos frecuentes.
Lksub1: Lk-1, un conjunto que contiene todos los k-itemsets candidatos frecuentes (k-1).
Devuelve:
Verdadero: satisface la propiedad Apriori.
Falso: No satisface la propiedad Apriori """
para el elemento en Ck_item:
sub_Ck = Ck_item - frozenset([item]) si sub_Ck no está en Lksub1: return False return Truedef create_Ck(Lksub1, k): """
Crea Ck, un conjunto que contiene todos los k-itemsets candidatos frecuentes
mediante la propia operación de conexión de Lk-1.
Args:
Lksub1: Lk-1, un conjunto que contiene todos conjuntos de elementos candidatos frecuentes (k-1).
k: el número de elemento de un conjunto de elementos frecuentes.
Devolución:
Ck: un conjunto que contiene todos. todos los conjuntos de elementos k candidatos frecuentes """
Ck = set()
len_Lksub1 = len(Lksub1)
list_Lksub1 = list(Lksub1) para i. en rango(len_Lksub1): para j en rango (1, len_Lksub1):
l1 = lista(list_Lksub1[i])
l2 = lista(list_Lksub1[j])
l1.sort()
l2.sort() si l1[0:k-2] == l2[0:k-2]:
Ck_item = list_Lksub1[i] | list_Lksub1[j] # poda
if is_apriori(Ck_item, Lksub1):
Ck.add(Ck_item) return Ckdef generate_Lk_by_Ck(data_set, Ck, min_support, support_data): """
Genera Lk ejecutando una política de eliminación desde Ck.
Args:
data_set: una lista de transacciones. Cada transacción contiene varias items.
Ck: un conjunto que contiene todos los k-itemsets candidatos frecuentes.
min_support: el soporte mínimo.
support_data: un diccionario. es un conjunto de elementos frecuentes y el valor es soporte.
Devuelve:
Lk: un conjunto que contiene todos los k-conjuntos de elementos frecuentes """
Lk =. set()
item_count = {} para t en data_set: para elemento en Ck: if item.issubset(t): si el elemento no está en item_count:
item_count[item] = 1 más:
item_count[item] += 1
t_num = float(len(data_set)) para el artículo en item_count: if (item_count[item] / t_num) >= min_support :
Lk add(item)
support_data[item] = item_count[item] / t_num return Lkdef generate_L(data_set, k, min_support): """
Genera todos los conjuntos de elementos frecuentes.
Args:
data_set: una lista de transacciones. Cada transacción contiene varios elementos.
k: número máximo de elementos. para todos los conjuntos de elementos frecuentes.
min_support: el soporte mínimo.
Devuelve:
L: la lista de Lk.
support_data: Un diccionario La clave es un conjunto de elementos frecuentes y el valor es soporte """
support_data = {}
C1 = create_C1(data_set)
L1 =. generate_Lk_by_Ck(data_set, C1, min_support, support_data)
Lksub1 = L1.copy()
L = []
L.append(Lksub1) para i en rango(2, k+1):
Ci = create_Ck(Lksub1, i)
Li = generate_Lk_by_Ck(data_set, Ci, min_support, support_data)
Lksub1 = Li.copy()
L.append(Lksub1) return L, support_datadef generate_big_rules(L, support_data, min_conf): """
Genera grandes reglas a partir de conjuntos de elementos frecuentes .
Args:
L: La lista de Lk.
support_data: Un diccionario La clave es un conjunto de elementos frecuentes y el valor es soporte.
min_conf: Confianza mínima.
Devuelve:
big_rule_list: Una lista que contiene todas las reglas importantes. Cada regla importante se representa
como un 3. -tuple. """
big_rule_list = []
sub_set_list = [] para i en rango(0, len(L)): para freq_set en L[i]: para sub_set en sub_set_list: if sub_set.issubset(freq_set):
conf = support_data[freq_set] / support_data[freq_set - sub_set]
big_rule = (freq_set - sub_set, sub_set, conf) si conf >= min_conf y big_rule no están en big_rule_list : # print freq_set-sub_set, " => ", sub_set, "conf: ", conf big_rule_list.append(big_rule)
sub_set_list.append(freq_set) return big_rule_listif __name__ == "__main__": "" "
Prueba """
file_path = "test_aa.xlsx"
data_set,k = local_data(file_path )
L, support_data = generate_L(data_set, k, min_support=0.2)
big_rules_list = generate_big_rules(L, support_data, min_conf=0.4) print(L) para Lk en L: if len(list(Lk)) == 0: break
print("="*50) print("frecuente " + str(len(list(Lk)[0])) + "- soporte de conjuntos de elementos") print("="* 50) para freq_set en Lk: print(freq_set, support_data[freq_set]) print() print("Big Rules") para elemento en big_rules_list: print(item[0], "= >", elemento[1], "conf : ", elemento[2]) Formato de archivo:
test_aa.xlsx
nombre con
T1 2, 3,5T2 1,2,4T3 3, 5T5 2,3,4T6 2,3,5T7 1,2,4T8 3,5T9 2,3,4T10 1,2,3,4,5 Recomendaciones de aprendizaje gratuitas relacionadas: vídeo de Python tutorial