Minería de reglas de asociación a través del algoritmo Apriori en Python

    La minería de reglas de asociación es una técnica para identificar las relaciones subyacentes entre diferentes elementos. Tomemos un ejemplo de un Supermercado donde los clientes pueden comprar una variedad de artículos. Por lo general, existe un patrón en lo que compran los clientes. Por ejemplo, las madres con bebés compran productos para bebés como leche y pañales. Las doncellas pueden comprar artículos de maquillaje, mientras que los solteros pueden comprar cervezas y patatas fritas, etc. En resumen, las transacciones implican un patrón. Se pueden generar más ganancias si se puede identificar la relación entre los artículos comprados en diferentes transacciones.

    Por ejemplo, si los artículos A y B se compran juntos con más frecuencia, se pueden tomar varias medidas para aumentar las ganancias. Por ejemplo:

    • A y B se pueden colocar juntos para que cuando un cliente compre uno de los productos no tenga que ir muy lejos para comprar el otro producto.
    • Las personas que compran uno de los productos pueden ser dirigidas a través de una campaña publicitaria para comprar el otro.
    • Se pueden ofrecer descuentos colectivos en estos productos si el cliente compra ambos.
    • Tanto A como B se pueden empaquetar juntos.

    El proceso de identificación de asociaciones entre productos se denomina minería de reglas de asociación.

    Algoritmo a priori para minería de reglas de asociación

    Se han desarrollado diferentes algoritmos estadísticos para implementar la minería de reglas de asociación, y Apriori es uno de esos algoritmos. En este artículo estudiaremos la teoría detrás de la Algoritmo a priori y luego implementará el algoritmo Apriori en Python.

    Teoría del algoritmo a priori

    Hay tres componentes principales del algoritmo Apriori:

    • Apoyo
    • Confianza
    • Ascensor

    Explicaremos estos tres conceptos con la ayuda de un ejemplo.

    Suponga que tenemos un registro de mil transacciones de clientes y queremos encontrar el soporte, la confianza y el impulso para dos elementos, por ejemplo, hamburguesas y salsa de tomate. De mil transacciones, 100 contienen salsa de tomate mientras que 150 contienen una hamburguesa. De 150 transacciones en las que se compra una hamburguesa, 50 transacciones también contienen salsa de tomate. Con estos datos, queremos encontrar el apoyo, la confianza y el impulso.

    Apoyo

    El soporte se refiere a la popularidad predeterminada de un artículo y se puede calcular encontrando el número de transacciones que contienen un artículo en particular dividido por el número total de transacciones. Supongamos que queremos encontrar soporte para el elemento B. Esto se puede calcular como:

    Support(B) = (Transactions containing (B))/(Total Transactions)
    

    Por ejemplo, si de 1000 transacciones, 100 transacciones contienen Ketchup, entonces el soporte para el artículo Ketchup se puede calcular como:

    Support(Ketchup) = (Transactions containingKetchup)/(Total Transactions)
    
    Support(Ketchup) = 100/1000
                     = 10%
    

    Confianza

    La confianza se refiere a la probabilidad de que también se compre un artículo B si se compra el artículo A. Se puede calcular encontrando el número de transacciones en las que A y B se compran juntos, dividido por el número total de transacciones en las que se compra A. Matemáticamente, se puede representar como:

    Confidence(A→B) = (Transactions containing both (A and B))/(Transactions containing A)
    

    Volviendo a nuestro problema, tuvimos 50 transacciones en las que Burger y Ketchup se compraron juntas. Mientras que en 150 transacciones se compran hamburguesas. Entonces podemos encontrar la probabilidad de comprar salsa de tomate cuando se compra una hamburguesa se puede representar como la confianza de Burger -> Ketchup y se puede escribir matemáticamente como:

    Confidence(Burger→Ketchup) = (Transactions containing both (Burger and Ketchup))/(Transactions containing A)
    
    Confidence(Burger→Ketchup) = 50/150
                               = 33.3%
    

    Puede notar que esto es similar a lo que vería en el algoritmo Naive Bayes, sin embargo, los dos algoritmos están diseñados para diferentes tipos de problemas.

    Ascensor

    Lift(A -> B) se refiere al aumento en la razón de venta de B cuando se vende A. La elevación (A -> B) se puede calcular dividiendo Confidence(A -> B) dividido por Support(B). Matemáticamente se puede representar como:

    Lift(A→B) = (Confidence (A→B))/(Support (B))
    

    Volviendo a nuestro problema de hamburguesas y ketchup, el Lift(Burger -> Ketchup) se puede calcular como:

    Lift(Burger→Ketchup) = (Confidence (Burger→Ketchup))/(Support (Ketchup))
    
    Lift(Burger→Ketchup) = 33.3/10
                         = 3.33
    

    Básicamente, Lift nos dice que la probabilidad de comprar una hamburguesa y salsa de tomate juntas es 3.33 veces mayor que la probabilidad de comprar solo salsa de tomate. Un aumento de 1 significa que no hay asociación entre los productos A y B. El aumento de más de 1 significa que es más probable que los productos A y B se compren juntos. Finalmente, Lift de menos de 1 se refiere al caso en el que es poco probable que se compren dos productos juntos.

    Pasos involucrados en el algoritmo a priori

    Para grandes conjuntos de datos, puede haber cientos de elementos en cientos de miles de transacciones. El algoritmo Apriori intenta extraer reglas para cada combinación posible de elementos. Por ejemplo, la elevación se puede calcular para el artículo 1 y el artículo 2, el artículo 1 y el artículo 3, el artículo 1 y el artículo 4 y luego el artículo 2 y el artículo 3, el artículo 2 y el artículo 4 y luego las combinaciones de artículos, por ejemplo, artículo 1, artículo 2 y artículo 3; de manera similar, el artículo 1, el artículo 2 y el artículo 4, y así sucesivamente.

    Como puede ver en el ejemplo anterior, este proceso puede ser extremadamente lento debido a la cantidad de combinaciones. Para acelerar el proceso, debemos realizar los siguientes pasos:

    • Establezca un valor mínimo de apoyo y confianza. Esto significa que solo estamos interesados ​​en encontrar reglas para los elementos que tienen cierta existencia predeterminada (por ejemplo, soporte) y tienen un valor mínimo de co-ocurrencia con otros elementos (por ejemplo, confianza).
    • Extraiga todos los subconjuntos que tengan un valor de soporte superior al umbral mínimo.
    • Seleccione todas las reglas de los subconjuntos con un valor de confianza superior al umbral mínimo.
    • Ordene las reglas por orden descendente de elevación.

    Implementando el algoritmo Apriori con Python

    Basta de teoría, ahora es el momento de ver el algoritmo Apriori en acción. En esta sección usaremos el algoritmo Apriori para encontrar reglas que describan asociaciones entre diferentes productos dadas 7500 transacciones en el transcurso de una semana en una tienda minorista francesa. El conjunto de datos se puede descargar desde el siguiente enlace:

    https://drive.google.com/file/d/1y5DYn0dGoSbC22xowBq2d4po6h1JxcTQ/view?usp=sharing

    Otro punto interesante es que no necesitamos escribir el guión para calcular el apoyo, la confianza y el impulso para todas las combinaciones posibles de elementos. Usaremos una biblioteca lista para usar donde ya se ha implementado todo el código.

    La biblioteca a la que me refiero es apyori y la fuente se puede encontrar aquí. Le sugiero que descargue e instale la biblioteca en la ruta predeterminada para sus bibliotecas de Python antes de continuar.

    Nota: Todos los scripts de este artículo se han ejecutado utilizando IDE de Spyder para Python.

    Siga estos pasos para implementar el algoritmo Apriori en Python:

    Importar las bibliotecas

    El primer paso, como siempre, es importar las bibliotecas necesarias. Ejecute el siguiente script para hacerlo:

    import numpy as np
    import matplotlib.pyplot as plt
    import pandas as pd
    from apyori import apriori
    

    En el script anterior importamos las bibliotecas pandas, numpy, pyplot y apriori.

    Importar el conjunto de datos

    Ahora importemos el conjunto de datos y veamos con qué estamos trabajando. Descargue el conjunto de datos y colóquelo en la carpeta “Conjuntos de datos” de la unidad “D” (o cambie el código a continuación para que coincida con la ruta del archivo en su computadora) y ejecute el siguiente script:

    store_data = pd.read_csv('D:\Datasets\store_data.csv')
    

    Llamemos al head() función para ver cómo se ve el conjunto de datos:

    store_data.head()
    

    En la captura de pantalla anterior se muestra un fragmento del conjunto de datos. Si observa detenidamente los datos, podemos ver que el encabezado es en realidad la primera transacción. Cada fila corresponde a una transacción y cada columna corresponde a un artículo comprado en esa transacción específica. los NaN nos dice que el artículo representado por la columna no fue comprado en esa transacción específica.

    En este conjunto de datos no hay una fila de encabezado. Pero por defecto, pd.read_csv La función trata la primera fila como encabezado. Para deshacerse de este problema, agregue header=None opción a pd.read_csv función, como se muestra a continuación:

    store_data = pd.read_csv('D:\Datasets\store_data.csv', header=None)
    

    Ahora ejecuta el head() función:

    store_data.head()
    

    En este resultado actualizado, verá que la primera línea ahora se trata como un registro en lugar de un encabezado como se muestra a continuación:

    Ahora usaremos el algoritmo Apriori para averiguar qué artículos se venden comúnmente juntos, de modo que el propietario de la tienda pueda tomar medidas para colocar los artículos relacionados juntos o publicitarlos juntos para tener mayores ganancias.

    Procesamiento de datos

    La biblioteca Apriori que vamos a usar requiere que nuestro conjunto de datos tenga la forma de una lista de listas, donde todo el conjunto de datos es una gran lista y cada transacción en el conjunto de datos es una lista interna dentro de la gran lista externa. Actualmente tenemos datos en forma de marco de datos de pandas. Para convertir nuestro marco de datos de pandas en una lista de listas, ejecute el siguiente script:

    records = []
    for i in range(0, 7501):
        records.append([str(store_data.values[i,j]) for j in range(0, 20)])
    

    Aplicación de Apriori

    El siguiente paso es aplicar el algoritmo Apriori en el conjunto de datos. Para hacerlo, podemos usar el apriori clase que importamos de la biblioteca apyori.

    los apriori La clase requiere algunos valores de parámetros para funcionar. El primer parámetro es la lista de la lista de la que desea extraer reglas. El segundo parámetro es el min_support parámetro. Este parámetro se utiliza para seleccionar los elementos con valores de soporte superiores al valor especificado por el parámetro. A continuación, el min_confidence parámetro filtra aquellas reglas que tienen una confianza mayor que el umbral de confianza especificado por el parámetro. Del mismo modo, el min_lift El parámetro especifica el valor de elevación mínimo para las reglas de la lista corta. Finalmente, el min_length El parámetro especifica el número mínimo de elementos que desea en sus reglas.

    Supongamos que queremos reglas solo para aquellos artículos que se compran al menos 5 veces al día, o 7 x 5 = 35 veces en una semana, ya que nuestro conjunto de datos es para un período de tiempo de una semana. El soporte para esos elementos se puede calcular como 35/7500 = 0,0045. La confianza mínima para las reglas es 20% o 0,2. De manera similar, especificamos el valor de elevación como 3 y finalmente min_length es 2 ya que queremos al menos dos productos en nuestras reglas. Estos valores en su mayoría se eligen arbitrariamente, por lo que puede jugar con estos valores y ver qué diferencia hay en las reglas que recupera.

    Ejecute el siguiente script:

    association_rules = apriori(records, min_support=0.0045, min_confidence=0.2, min_lift=3, min_length=2)
    association_results = list(association_rules)
    

    En la segunda línea aquí convertimos las reglas encontradas por el apriori clase en un list ya que es más fácil ver los resultados en este formulario.

    Ver los resultados

    Primero encontremos el número total de reglas extraídas por el apriori clase. Ejecute el siguiente script:

    print(len(association_rules))
    

    La secuencia de comandos anterior debe devolver 48. Cada elemento corresponde a una regla.

    Imprimamos el primer elemento del association_rules lista para ver la primera regla. Ejecute el siguiente script:

    print(association_rules[0])
    

    La salida debería verse así:

    RelationRecord(items=frozenset({'light cream', 'chicken'}), support=0.004532728969470737, ordered_statistics[OrderedStatistic(items_base=frozenset({'light cream'}), items_add=frozenset({'chicken'}), confidence=0.29059829059829057, lift=4.84395061728395)])
    

    El primer elemento de la lista es una lista que contiene tres elementos. El primer elemento de la lista muestra los artículos comestibles de la regla.

    Por ejemplo, en el primer artículo, podemos ver que la crema ligera y el pollo comúnmente se compran juntos. Esto tiene sentido ya que las personas que compran crema ligera tienen cuidado con lo que comen, por lo que es más probable que compren pollo, es decir, carne blanca en lugar de carne roja, es decir, carne de res. O esto podría significar que la crema ligera se usa comúnmente en recetas de pollo.

    El valor de soporte para la primera regla es 0,0045. Este número se calcula dividiendo el número de transacciones que contienen crema ligera dividido por el número total de transacciones. El nivel de confianza para la regla es 0.2905, lo que muestra que de todas las transacciones que contienen crema ligera, el 29.05% de las transacciones también contienen pollo. Finalmente, el incremento de 4.84 nos dice que los clientes que compran crema ligera tienen 4.84 veces más probabilidades de que compren pollo en comparación con la probabilidad predeterminada de venta de pollo.

    La siguiente secuencia de comandos muestra la regla, el apoyo, la confianza y el impulso para cada regla de una manera más clara:

    for item in association_rules:
    
        # first index of the inner list
        # Contains base item and add item
        pair = item[0] 
        items = [x for x in pair]
        print("Rule: " + items[0] + " -> " + items[1])
    
        #second index of the inner list
        print("Support: " + str(item[1]))
    
        #third index of the list located at 0th
        #of the third index of the inner list
    
        print("Confidence: " + str(item[2][0][2]))
        print("Lift: " + str(item[2][0][3]))
        print("=====================================")
    

    Si ejecuta el script anterior, verá todas las reglas devueltas por el apriori clase. Las primeras cuatro reglas devueltas por apriori la clase se ve así:

    Rule: light cream -> chicken
    Support: 0.004532728969470737
    Confidence: 0.29059829059829057
    Lift: 4.84395061728395
    =====================================
    Rule: mushroom cream sauce -> escalope
    Support: 0.005732568990801126
    Confidence: 0.3006993006993007
    Lift: 3.790832696715049
    =====================================
    Rule: escalope -> pasta
    Support: 0.005865884548726837
    Confidence: 0.3728813559322034
    Lift: 4.700811850163794
    =====================================
    Rule: ground beef -> herb & pepper
    Support: 0.015997866951073192
    Confidence: 0.3234501347708895
    Lift: 3.2919938411349285
    =====================================
    

    Ya hemos hablado de la primera regla. Analicemos ahora la segunda regla. La segunda regla establece que la salsa de crema de champiñones y el escalope se compran con frecuencia. El apoyo para la salsa de crema de champiñones es 0,0057. La confianza para esta regla es 0.3006, lo que significa que de todas las transacciones que contienen hongos, es probable que el 30.06% de las transacciones también contengan escalope. Finalmente, el aumento de 3.79 muestra que el escalope tiene 3.79 más probabilidades de ser comprado por los clientes que compran salsa de crema de champiñones, en comparación con su venta predeterminada.

    Conclusión

    Los algoritmos de minería de reglas de asociación como Apriori son muy útiles para encontrar asociaciones simples entre nuestros elementos de datos. Son fáciles de implementar y tienen una gran capacidad de explicación. Sin embargo, para conocimientos más avanzados, como los utilizados por Google o Amazon, etc., algoritmos más complejos, como sistemas de recomendación, son usados. Sin embargo, probablemente pueda ver que este método es una forma muy simple de obtener asociaciones básicas si eso es todo lo que necesita en su caso de uso.

     

    Etiquetas:

    Deja una respuesta

    Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *