Code & Queries

Eine Warenkorbanalyse (oder Market Basket Analysis) ist eine Methode, die vor allem im Einzelhandel und E-Commerce zur Analyse des Kaufverhaltens von Kunden verwendet wird. Mit Python und DuckDB lässt sich eine solche Analyse effizient durchführen. Hier eine grobe Übersicht zum Vorgehen:

1. Einrichtung von DuckDB und Laden der Daten

DuckDB ist besonders effizient für OLAP-Abfragen und eignet sich gut für Ad-hoc-Analysen großer Datensätze. Mit DuckDB in Python können Sie direkt aus CSV- oder Parquet-Dateien lesen oder sogar SQL-Abfragen auf Pandas DataFrames ausführen.

import duckdb
import pandas as pd

# Verbindung zur DuckDB herstellen (entweder in Memory oder eine Datei)
con = duckdb.connect()

# Laden der Daten, z.B. aus einer Parquet-Datei
df = con.execute("SELECT * FROM 'transactions.parquet'").df()

2. Datenaufbereitung

Stellen Sie sicher, dass Ihre Daten die relevanten Informationen enthalten. Typischerweise benötigt man für eine Warenkorbanalyse: - TransactionID (Bestell-ID) - ProductID (Produkt-ID oder Name des Produkts)

Beispiel:

# Überprüfen, ob alle relevanten Spalten vorhanden sind
print(df.head())

# Optional: Gruppieren nach TransactionID und ProductID falls nötig

3. Berechnung der Support-, Confidence- und Lift-Werte

Warenkorbanalysen basieren auf Assoziationsregeln. Drei wichtige Kennzahlen sind: - Support: Häufigkeit, mit der bestimmte Produkte zusammen gekauft werden. - Confidence: Wahrscheinlichkeit, dass Produkt B gekauft wird, wenn Produkt A gekauft wurde. - Lift: Verhältnis der Confidence zur Wahrscheinlichkeit des Einzelkaufs von B (zeigt an, ob es eine echte Assoziation gibt).

from mlxtend.frequent_patterns import apriori, association_rules

# Umwandeln in das Format für `mlxtend`
# E.g., eine Transaktionsmatrix erstellen
basket = df.pivot_table(index='TransactionID', columns='ProductID', aggfunc='size', fill_value=0)

# Berechnen der frequent itemsets mit einem Mindest-Support
frequent_itemsets = apriori(basket, min_support=0.01, use_colnames=True)

# Generieren der Assoziationsregeln basierend auf den frequent itemsets
rules = association_rules(frequent_itemsets, metric="lift", min_threshold=1)

print(rules.head())

4. Analyse und Interpretation der Ergebnisse

Nun können Sie die Regeln interpretieren, um zu verstehen, welche Produkte häufig zusammen gekauft werden. Die wichtigsten Kennzahlen hier sind: - Lift > 1 bedeutet eine positive Assoziation zwischen Produkten. - Confidence-Werte geben Hinweise auf das Cross-Selling-Potenzial.

5. Erweiterung: Visualisierung und Reporting

Für ein besseres Verständnis können die Ergebnisse visualisiert werden, z.B. mithilfe von networkx für Assoziationsnetzwerke oder seaborn für Heatmaps.

import networkx as nx
import matplotlib.pyplot as plt

# Netzwerk der Assoziationsregeln
G = nx.from_pandas_edgelist(rules, 'antecedents', 'consequents')
nx.draw(G, with_labels=True)
plt.show()

Vorteile von DuckDB in der Warenkorbanalyse

• Performance: DuckDB ist schnell und ermöglicht SQL-Abfragen direkt auf großen DataFrames und Parquet-Dateien.
• Integrierbar in Python: Perfekt für Datenanalyse- und ML-Workflows.
• Flexibel mit Speicherformaten: Direktes Arbeiten mit CSV, Parquet und anderen Formaten.

Mit diesen Schritten haben Sie die Grundlagen für Warenkorbanalysen in Python und DuckDB, und die Ergebnisse können zur Optimierung von Produktempfehlungen und Marketingaktionen verwendet werden.

---

Warenkorbanalyse (oder Market Basket Analysis) mit Python & DUCKDB Teil 2

Schritte zur Erstellung eines Dashboards mit Streamlit und DuckDB

1. Streamlit und DuckDB installieren

Installieren Sie die benötigten Bibliotheken:

pip install streamlit duckdb pandas

2. Verbindung zu DuckDB und Laden der Daten

Erstellen Sie eine Datei dashboard.py, und starten Sie mit der Verbindung zur DuckDB-Datenbank:

import duckdb
import pandas as pd
import streamlit as st

# Verbindung zu DuckDB (entweder in Memory oder als Datei)
con = duckdb.connect(database='data.db', read_only=True)

# Laden der Daten, z.B. Transaktionen und Produkte
df = con.execute("SELECT * FROM transactions").df()

3. Benutzeroberfläche und Auswahlfelder in Streamlit

Fügen Sie in Streamlit interaktive Auswahlfelder hinzu, z.B. zur Filterung von Produktkategorien, Datum oder anderen Parametern.

# Titel des Dashboards
st.title("Warenkorb Analyse Dashboard")

# Auswahlfelder für Filteroptionen
category = st.selectbox("Kategorie wählen", df["ProductCategory"].unique())
date_range = st.date_input("Zeitraum auswählen", [])

# Daten filtern basierend auf den Auswahlfeldern
filtered_df = df[(df["ProductCategory"] == category)]
if date_range:
    filtered_df = filtered_df[(filtered_df["Date"] >= date_range[0]) & (filtered_df["Date"] <= date_range[1])]

# Anzeige der gefilterten Daten
st.write("Gefilterte Transaktionen", filtered_df)

4. Berechnung und Visualisierung der Assoziationsregeln

Berechnen Sie die Warenkorbanalyse und zeigen Sie die Ergebnisse an. Dazu können Sie die mlxtend-Bibliothek für Assoziationsregeln nutzen und die Ergebnisse visuell darstellen.

from mlxtend.frequent_patterns import apriori, association_rules

# Umwandeln in eine Matrix für die Berechnung
basket = filtered_df.pivot_table(index='TransactionID', columns='ProductID', aggfunc='size', fill_value=0)
frequent_itemsets = apriori(basket, min_support=0.01, use_colnames=True)
rules = association_rules(frequent_itemsets, metric="lift", min_threshold=1)

# Anzeige der Regeln
st.write("Assoziationsregeln", rules)

5. Interaktive Diagramme hinzufügen

Mit streamlit.plotly_chart() oder matplotlib lassen sich Diagramme und Heatmaps integrieren, um die Assoziationsregeln und Produktbeziehungen darzustellen.

import matplotlib.pyplot as plt
import seaborn as sns

# Beispiel: Heatmap für Lift-Werte
fig, ax = plt.subplots(figsize=(10, 6))
sns.heatmap(rules.pivot("antecedents", "consequents", "lift"), annot=True, cmap="YlGnBu", ax=ax)
st.pyplot(fig)

6. Starten des Dashboards

Um das Dashboard zu starten, führen Sie folgenden Befehl im Terminal aus:

streamlit run dashboard.py

Das Dashboard sollte jetzt in Ihrem Browser verfügbar sein, und die Benutzer können die Filteroptionen ändern, um Ergebnisse in Echtzeit zu sehen.

Erweiterungen

• Datenaktualisierung: Laden Sie regelmäßig aktuelle Daten in DuckDB, um Live-Daten anzuzeigen.
• Weitere Filter und Widgets: Fügen Sie Dropdowns, Schieberegler und Auswahloptionen hinzu, um spezifischere Filterungen zu ermöglichen.
• Interaktive Visualisierungen: Nutzen Sie Plotly oder Altair für noch interaktivere Diagramme.

Mit diesen Schritten können Sie ein leistungsfähiges und interaktives Dashboard für Warenkorbanalysen bauen, das Benutzern erlaubt, dynamisch Werte auszuwählen und die Ergebnisse sofort zu sehen.

---

Ja, auf Kaggle gibt es mehrere geeignete Datensätze und Projekte zur Warenkorbanalyse (Market Basket Analysis), die sich für Ihre Arbeit eignen könnten:

1. Instacart Market Basket Analysis: Dieser beliebte Datensatz enthält Informationen über Online-Lebensmittelbestellungen von Instacart-Kunden. Er bietet umfassende Details zu Produktkäufen und ermöglicht das Testen von Assoziationsanalysen und Empfehlungen. Der Datensatz enthält über drei Millionen Bestellungen und wird oft für Assoziationsregelanalysen genutzt, um Einkaufsgewohnheiten zu identifizieren Kaggle - Instacart Market Basket Analysis.

2. Groceries Dataset for Market Basket Analysis: Ein kleinerer Datensatz für die Marktanalyse, der 9835 Transaktionen und 169 Produkte umfasst. Er ist ideal, um Assoziationsregelalgorithmen wie Apriori oder FP-Growth zu testen und eignet sich für Anwender, die eher einen kompakten Datensatz bevorzugen Kaggle - Groceries Dataset.

3. Online Retail Dataset: Dieser Datensatz stammt aus einem Online-Retail-Geschäft und enthält Informationen zu Bestellungen in einem Zeitraum von einem Jahr. Er eignet sich besonders zur Analyse von Kaufverhalten und Segmentierung von Kunden für die Warenkorbanalyse Kaggle - Market Basket Analysis for Online Retail Dataset.

4. Customer Segmentation and Market Basket Analysis: Diese Ressource bietet nicht nur einen Datensatz, sondern auch eine umfassende Analyse, die Techniken zur Segmentierung von Kunden und zur Warenkorbanalyse kombiniert. Dies ist nützlich für eine tiefere Analyse, um das Kundenverhalten besser zu verstehen und gezielte Marketingstrategien zu entwickeln Kaggle - Customer Segmentation and Market Basket Analysis.

Diese Ressourcen bieten Daten und Beispiele, die Ihnen helfen, Techniken zur Warenkorbanalyse in Python umzusetzen und benutzerdefinierte Dashboards zu erstellen.

Python-Skript zur Anomalie- und Betrugserkennung

import pandas as pd
import numpy as np
from sklearn.ensemble import IsolationForest
from sklearn.preprocessing import StandardScaler
import matplotlib.pyplot as plt

# Generiere einen größeren Datensatz mit Kreditkartentransaktionen
def generate_dataset(num_samples=100000):
    np.random.seed(42)
    data = {
        'TransactionID': np.arange(num_samples),
        'Amount': np.random.exponential(scale=100, size=num_samples),  # Transaktionsbeträge
        'Time': np.random.randint(0, 86400, num_samples),  # Zeitstempel in Sekunden des Tages
        'CustomerID': np.random.randint(1000, 2000, num_samples),  # Kunden-ID
        'Fraud': np.random.binomial(1, 0.01, num_samples)  # 1% Betrugsfälle
    }

    # Einfügen von Betrugsmustern
    fraud_indices = np.where(data['Fraud'] == 1)[0]
    data['Amount'][fraud_indices] = data['Amount'][fraud_indices] * np.random.uniform(2, 10, size=len(fraud_indices))
    data['Time'][fraud_indices] = np.random.choice(range(80000, 86400), size=len(fraud_indices))

    return pd.DataFrame(data)

# Datensatz generieren
df = generate_dataset()

# Datenbeschreibung
description = df.describe()

# Datenvorverarbeitung
scaler = StandardScaler()
scaled_data = scaler.fit_transform(df[['Amount', 'Time']])

# Isolation Forest Modell
model = IsolationForest(contamination=0.01, random_state=42)
df['Anomaly'] = model.fit_predict(scaled_data)

# Visualisierung
plt.figure(figsize=(10, 6))
plt.scatter(df['Amount'], df['Time'], c=df['Anomaly'], cmap='coolwarm', alpha=0.6)
plt.xlabel('Amount')
plt.ylabel('Time')
plt.title('Anomaly Detection in Credit Card Transactions')
plt.colorbar(label='Anomaly Score')
plt.show()

# Ausgabe der ersten Zeilen des Datensatzes und der Beschreibung
print(df.head())
print(description)

Beschreibung des Datensatzes

Der generierte Datensatz enthält 100.000 Kreditkartentransaktionen mit den folgenden Spalten:

• TransactionID: Eine eindeutige Identifikationsnummer für jede Transaktion.
• Amount: Der Betrag der Transaktion in einer fiktiven Währungseinheit.
• Time: Der Zeitstempel der Transaktion in Sekunden seit Mitternacht.
• CustomerID: Eine eindeutige Identifikationsnummer für den Kunden, der die Transaktion durchgeführt hat.
• Fraud: Ein Indikator, ob die Transaktion betrügerisch ist (1) oder nicht (0).

Zusätzlich wird eine Anomaliespalte (Anomaly) basierend auf dem Isolation Forest Modell hinzugefügt, die anzeigt, ob eine Transaktion als Anomalie erkannt wurde.

Erklärung des Codes

1. Datengenerierung: Ein synthetischer Datensatz mit 100.000 Transaktionen wird erstellt. Betrügerische Transaktionen werden durch höhere Beträge und spätere Zeiten am Tag simuliert.
2. Datenbeschreibung: Statistische Beschreibungen des Datensatzes werden berechnet.
3. Datenvorverarbeitung: Die Transaktionsbeträge und Zeiten werden standardisiert.
4. Isolation Forest Modell: Ein Isolation Forest Modell wird trainiert, um Anomalien im Datensatz zu erkennen.
5. Visualisierung: Die Anomalien werden in einem Streudiagramm visualisiert, wobei Anomalie-Scores farblich dargestellt werden.

Dieser Ansatz bietet eine grundlegende Pipeline für die Anomalie- und Betrugserkennung in Kreditkartentransaktionen und kann weiter verfeinert werden, um spezifischere Anforderungen zu erfüllen.