Python-Apriori-Algorithmus

1. Erläuterung des Apriori-Algorithmus
2. Apriori-Algorithmus in Python
3. Implementieren Sie den topologischen Sortieralgorithmus in Python

In diesem Tutorial wird die Implementierung des Apriori-Algorithmus in Python erläutert.

Erläuterung des Apriori-Algorithmus

Der Apriori-Algorithmus wird häufig für Warenkorbanalysen verwendet, d. h. um zu analysieren, welche Artikel verkauft werden und welche anderen Artikel. Dies ist ein nützlicher Algorithmus für Ladenbesitzer, die ihren Umsatz steigern möchten, indem sie die verkauften Artikel nahe beieinander platzieren oder Rabatte anbieten.

Dieser Algorithmus besagt, dass wenn eine Itemmenge häufig ist, alle nicht leeren Teilmengen ebenfalls häufig sein müssen. Schauen wir uns ein kleines Beispiel an, um diesen Begriff zu veranschaulichen.

Nehmen wir an, in unserem Geschäft werden häufig Milch, Butter und Brot zusammen verkauft. Dies impliziert, dass Milch, Butter und Milch, Brot und Butter, Brot auch häufig zusammen verkauft werden.

Der Apriori-Algorithmus besagt auch, dass die Häufigkeit einer Artikelmenge niemals die Häufigkeit ihrer nicht leeren Teilmengen überschreiten kann. Wir können dies weiter veranschaulichen, indem wir unser vorheriges Beispiel etwas erweitern.

In unserem Geschäft werden Milch, Butter und Brot 3 Mal zusammen verkauft. Dies impliziert, dass alle nicht leeren Teilmengen wie Milch, Butter und Milch, Brot und Butter, Brot mindestens dreimal oder öfter zusammen verkauft werden.

Apriori-Algorithmus in Python

Bevor wir diesen Algorithmus implementieren, müssen wir verstehen, wie der Apriori-Algorithmus funktioniert.

Zu Beginn des Algorithmus geben wir die Unterstützungsschwelle an. Die Unterstützungsschwelle ist nur die Wahrscheinlichkeit des Auftretens eines Elements in einer Transaktion.

$$
Unterstützung (A) = (Anzahl der Transaktionen, die den Artikel A enthalten) / (Gesamtzahl der Transaktionen)
$$

Abgesehen von der Unterstützung gibt es noch andere Maßnahmen wie Vertrauen und Auftrieb, aber um die brauchen wir uns in diesem Tutorial nicht zu kümmern.

Die Schritte, die wir befolgen müssen, um den Apriori-Algorithmus zu implementieren, sind unten aufgeführt.

1. Unser Algorithmus beginnt mit nur einem 1-itemset. Hier bedeutet 1 die Anzahl der Artikel in unserem Artikelsatz.
2. Entfernt alle Elemente aus unseren Daten, die die Mindestunterstützungsanforderungen nicht erfüllen.
3. Nun erhöht unser Algorithmus die Anzahl der Items (k) in unserem Itemset und wiederholt die Schritte 1 und 2, bis das angegebene k erreicht ist oder es keine Itemsets mehr gibt, die die Mindestunterstützungsanforderungen erfüllen.

Implementieren Sie den topologischen Sortieralgorithmus in Python

Um den Apriori-Algorithmus zu implementieren, verwenden wir das apyori-Modul von Python. Es ist ein externes Modul und muss daher separat installiert werden.

Der pip-Befehl zum Installieren des apyori-Moduls ist unten.

pip install apyori

Wir verwenden das Market Basket Optimization dataset von Kaggle.

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

Wir haben alle für unsere Operationen erforderlichen Bibliotheken in den oben angegebenen Code importiert. Jetzt müssen wir den Datensatz mit pandas lesen.

Dies wurde im folgenden Codeausschnitt implementiert.

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

Lassen Sie uns nun die Gesamtzahl der Transaktionen in unserem Datensatz überprüfen.

len(market_data)

Ausgang:

7501

Die Ausgabe zeigt, dass wir 7501 Datensätze in unserem Dataset haben. Es gibt nur zwei kleine Probleme mit diesen Daten; diese Transaktionen sind von variabler Länge.

Angesichts der realen Szenarien macht dies sehr viel Sinn.

Um den Apriori-Algorithmus auszuführen, müssen wir diese willkürlichen Transaktionen in Transaktionen gleicher Länge umwandeln. Dies wurde im folgenden Codeausschnitt implementiert.

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

Im obigen Code haben wir die Liste transacts initialisiert und darin unsere Transaktionen der Länge 20 gespeichert. Das Problem hierbei ist, dass wir Nullwerte in Transaktionen mit weniger als 20 Elementen einfügen.

Aber wir müssen uns darüber keine Gedanken machen, weil das apriori-Modul automatisch mit Nullwerten umgeht.

Aus unseren Daten generieren wir nun Assoziationsregeln mit dem Klassenkonstruktor apriori. Dies wird im folgenden Codeblock demonstriert.

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

Wir haben unsere Schwellen für die Mindestunterstützung, das Vertrauen und die Hebeschwellen des Konstrukteurs angegeben. Außerdem haben wir die minimale und die maximale Anzahl von Artikeln in einem Artikelset auf 2 festgelegt, d. h. wir möchten Artikelpaare generieren, die häufig zusammen verkauft wurden.

Die Assoziationsregeln des Apriori-Algorithmus werden im Generatorobjekt rules gespeichert. Wir brauchen jetzt einen Mechanismus, um diese Regeln in einen pandas-Datenrahmen umzuwandeln.

Das folgende Code-Snippet zeigt eine Funktion inspect(), die das von unserem apriori()-Konstruktor zurückgegebene Generatorobjekt rules in einen pandas-Datenrahmen umwandelt.

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)

Ausgang:

         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

Wir können diesen Datenrahmen jetzt nach Unterstützungsstufe sortieren und die Top-5-Datensätze in unserem Datensatz mit dem folgenden Code anzeigen.

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

Ausgang:

      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

Apriori ist ein sehr grundlegender und einfacher Algorithmus für die Warenkorbanalyse. Es kann hilfreiche Insider liefern, um den Verkauf von Artikeln auf einem Markt oder in einem Geschäft zu steigern.

Der einzige Nachteil dieses Algorithmus ist, dass er für große Datensätze viel Speicher benötigt. Dies liegt daran, dass viele Kombinationen häufig vorkommender Elemente erstellt werden.

Wir hatten diese Einschränkung auch, da dieses Tutorial mit dem UCI-Online-Einzelhandelsdatensatz arbeiten sollte, aber aufgrund von Speicherbeschränkungen mussten wir unseren Datensatz auf Warenkorboptimierung umstellen.