Algoritmo a priori de Python

1. Explicación del Algoritmo A priori
2. Algoritmo a priori en Python
3. Implementar el algoritmo de clasificación topológica en Python

Este tutorial discutirá la implementación del algoritmo a priori en Python.

Explicación del Algoritmo A priori

El Algoritmo A priori se usa ampliamente para el análisis de la canasta de mercado, es decir, para analizar qué artículos se venden y qué otros artículos. Este es un algoritmo útil para los propietarios de tiendas que desean aumentar sus ventas colocando los artículos vendidos juntos u ofreciendo descuentos.

Este algoritmo establece que si un conjunto de elementos es frecuente, todos los subconjuntos que no estén vacíos también deben ser frecuentes. Veamos un pequeño ejemplo para ayudar a ilustrar esta noción.

Digamos que en nuestra tienda, la leche, la mantequilla y el pan se venden juntos con frecuencia. Esto implica que la leche, la mantequilla y la leche, el pan y la mantequilla, el pan también se venden juntos con frecuencia.

El Algoritmo Apriori también establece que la frecuencia de un conjunto de elementos nunca puede exceder la frecuencia de sus subconjuntos no vacíos. Podemos ilustrar esto aún más ampliando un poco más nuestro ejemplo anterior.

En nuestra tienda, la leche, la mantequilla y el pan se venden juntos 3 veces. Esto implica que todos sus subconjuntos no vacíos como leche, mantequilla y leche, pan y mantequilla, pan se venden juntos al menos 3 veces o más.

Algoritmo a priori en Python

Antes de implementar este algoritmo, necesitamos entender cómo funciona el algoritmo a priori.

Al comienzo del algoritmo, especificamos el umbral de soporte. El umbral de soporte es solo la probabilidad de que ocurra un artículo en una transacción.

$$
Soporte (A) = (Número de transacciones que contienen el artículo A) / (Número total de transacciones)
$$

Además del soporte, existen otras medidas como la confianza y el impulso, pero no tenemos que preocuparnos por ellas en este tutorial.

Los pasos que debemos seguir para implementar el algoritmo a priori se enumeran a continuación.

1. Nuestro algoritmo comienza con solo un conjunto de 1 elemento. Aquí, 1 significa el número de elementos en nuestro conjunto de elementos.
2. Elimina todos los elementos de nuestros datos que no cumplen con el requisito mínimo de soporte.
3. Ahora, nuestro algoritmo aumenta la cantidad de elementos (k) en nuestro conjunto de elementos y repite los pasos 1 y 2 hasta que se alcanza el k especificado o no hay conjuntos de elementos que cumplan con los requisitos mínimos de soporte.

Implementar el algoritmo de clasificación topológica en Python

Para implementar el Algoritmo Apriori, utilizaremos el módulo apyori de Python. Es un módulo externo y, por lo tanto, debemos instalarlo por separado.

El comando pip para instalar el módulo apyori se encuentra a continuación.

pip install apyori

Usaremos el conjunto de datos de optimización de la cesta de la compra de Kaggle.

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

Hemos importado todas las bibliotecas requeridas para nuestras operaciones en el código dado arriba. Ahora, necesitamos leer el conjunto de datos usando pandas.

Esto se ha implementado en el siguiente fragmento de código.

market_data = pd.read_csv("Market_Basket_Optimisation.csv", header=None)

Ahora, verifiquemos el número total de transacciones en nuestro conjunto de datos.

len(market_data)

Producción :

7501

El resultado muestra que tenemos 7501 registros en nuestro conjunto de datos. Solo hay dos pequeños problemas con estos datos; estas transacciones son de duración variable.

Dados los escenarios del mundo real, esto tiene mucho sentido.

Para realizar el algoritmo a priori, necesitamos convertir estas transacciones arbitrarias en transacciones de longitud equivalente. Esto se ha implementado en el siguiente fragmento de código.

transacts = []
for i in range(0, len(market_data)):
    transacts.append([str(market_data.values[i, j]) for j in range(0, 20)])

En el código anterior, inicializamos la lista de transacciones y almacenamos nuestras transacciones de 20 de longitud en ella. El problema aquí es que insertamos valores nulos dentro de transacciones con menos de 20 elementos.

Pero no tenemos que preocuparnos por eso porque el módulo apriori maneja los valores nulos automáticamente.

Ahora generamos reglas de asociación a partir de nuestros datos con el constructor de clases apriori. Esto se demuestra en el siguiente bloque de código.

rules = apriori(
    transactions=transacts,
    min_support=0.003,
    min_confidence=0.2,
    min_lift=3,
    min_length=2,
    max_length=2,
)

Especificamos nuestros umbrales para los umbrales mínimos de soporte, confianza y elevación del constructor. También especificamos que el número mínimo y máximo de artículos en un conjunto de artículos sea 2, es decir, queremos generar pares de artículos que se vendan juntos con frecuencia.

Las reglas de asociación del algoritmo a priori se almacenan dentro del objeto generador de reglas. Ahora necesitamos un mecanismo para convertir estas “reglas” en un marco de datos pandas.

El siguiente fragmento de código muestra una función inspect() que toma el objeto generador reglas devuelto por nuestro constructor apriori() y lo convierte en un marco de datos pandas.

def inspect(output):
    Left_Hand_Side = [tuple(result[2][0][0])[0] for result in output]
    support = [result[1] for result in output]
    confidence = [result[2][0][2] for result in output]
    lift = [result[2][0][3] for result in output]
    Right_Hand_Side = [tuple(result[2][0][1])[0] for result in output]
    return list(zip(Left_Hand_Side, support, confidence, lift, Right_Hand_Side))


output = list(rules)
output_data = pd.DataFrame(
    inspect(output),
    columns=["Left_Hand_Side", "Support", "Confidence", "Lift", "Right_Hand_Side"],
)
print(output_data)

Producción :

         Left_Hand_Side   Support  Confidence      Lift Right_Hand_Side
0           light cream  0.004533    0.290598  4.843951         chicken
1  mushroom cream sauce  0.005733    0.300699  3.790833        escalope
2                 pasta  0.005866    0.372881  4.700812        escalope
3         fromage blanc  0.003333    0.245098  5.164271           honey
4         herb & pepper  0.015998    0.323450  3.291994     ground beef
5          tomato sauce  0.005333    0.377358  3.840659     ground beef
6           light cream  0.003200    0.205128  3.114710       olive oil
7     whole wheat pasta  0.007999    0.271493  4.122410       olive oil
8                 pasta  0.005066    0.322034  4.506672          shrimp

Ahora podemos ordenar este marco de datos por nivel de soporte y mostrar los 5 registros principales en nuestro conjunto de datos con el siguiente código.

print(output_data.nlargest(n=5, columns="Lift"))

Producción :

      Left_Hand_Side   Support  Confidence      Lift Right_Hand_Side
3      fromage blanc  0.003333    0.245098  5.164271           honey
0        light cream  0.004533    0.290598  4.843951         chicken
2              pasta  0.005866    0.372881  4.700812        escalope
8              pasta  0.005066    0.322034  4.506672          shrimp
7  whole wheat pasta  0.007999    0.271493  4.122410       olive oil

A priori es un algoritmo muy básico y simple para el análisis de la canasta de mercado. Puede proporcionar información útil para aumentar las ventas de artículos en un mercado o una tienda.

La única desventaja de este algoritmo es que requiere mucha memoria para grandes conjuntos de datos. Esto se debe a que crea muchas combinaciones de elementos frecuentes.

También experimentamos esta limitación ya que este tutorial estaba destinado a funcionar con el conjunto de datos minoristas en línea de UCI, pero debido a las limitaciones de memoria, tuvimos que cambiar nuestro conjunto de datos a la optimización de la cesta de la compra.