Code & Queries

Der Begriff Random Walk (zufällige Irrfahrt) klingt zunächst wie ein Spaziergang ohne bestimmtes Ziel – und das ist gar nicht so weit hergeholt. Doch was hat das mit Datenanalyse, Aktienkursen und Business Intelligence zu tun? In diesem Blogbeitrag erklären wir, was ein Random Walk ist, warum er wichtig ist, und wie er in der Praxis angewendet wird.

---

Was ist ein Random Walk?

Ein Random Walk beschreibt einen Prozess, bei dem der nächste Schritt ausschließlich vom aktuellen Zustand abhängt und zufällig erfolgt. Stellen Sie sich vor, Sie machen einen Spaziergang und entscheiden bei jedem Schritt zufällig, ob Sie nach rechts oder links abbiegen. Ihr Weg ist unvorhersehbar, und genau das ist die Essenz eines Random Walks.

In der Welt der Datenanalyse und Finanzmärkte bedeutet dies, dass zukünftige Entwicklungen nicht durch vergangene Muster oder Trends vorhergesagt werden können. Ein Random Walk ist ein stochastischer Prozess, bei dem die nächste Bewegung rein zufällig ist.

---

Random Walk in der Praxis: Aktienkurse

Ein klassisches Beispiel für einen Random Walk sind Aktienkurse. Viele Analysten versuchen, durch die Identifikation von Trends, saisonalen Mustern oder anderen Regelmäßigkeiten präzise Vorhersagen zu treffen. Doch was, wenn sich der Kurs als Random Walk verhält?

In einem solchen Fall sind zukünftige Kursbewegungen weitgehend zufällig. Das bedeutet, dass Versuche, auf Basis historischer Daten exakte Prognosen zu erstellen, oft wenig zielführend sind. Ein Random Walk unterstreicht, dass nicht alle Entwicklungen deterministisch erklärbar sind – und das ist eine wichtige Erkenntnis für Investoren und Analysten.

---

Warum ist das wichtig für Analytics und Business Intelligence?

Die Erkenntnis, dass ein Prozess einem Random Walk folgt, hat weitreichende Auswirkungen auf die Datenanalyse und Entscheidungsfindung. Hier sind drei zentrale Punkte:

1. Realistische Einschätzungen

Wenn ein Prozess einem Random Walk folgt, sind präzise Vorhersagen auf Basis von Mustern oder Trends oft nicht zuverlässig. Stattdessen ist es sinnvoller, die zufällige Natur des Prozesses anzuerkennen und sich auf Wahrscheinlichkeiten und Schwankungsbreiten zu konzentrieren.

Beispiel: Ein Unternehmen, das seine Umsatzprognosen auf saisonale Muster stützt, könnte enttäuscht werden, wenn sich herausstellt, dass die Umsatzentwicklung einem Random Walk folgt.

2. Risikomanagement

Anstatt exakte Prognosen zu erstellen, kann die Betrachtung der zu erwartenden Schwankungsbreite helfen, Unsicherheiten besser zu managen. Dies ist besonders in der Finanzwelt relevant, wo Risikomanagement eine zentrale Rolle spielt.

Beispiel: Ein Portfolio-Manager könnte sich darauf konzentrieren, die Volatilität seiner Anlagen zu begrenzen, anstatt zu versuchen, den genauen Kurs einer Aktie vorherzusagen.

3. Modellauswahl

In Fällen, in denen ein Random Walk vorliegt, ist es oft sinnvoller, einfachere Modelle zu verwenden, die die zufällige Natur des Prozesses anerkennen, anstatt komplexe Modelle zu erstellen, die nur kleine Muster vorhersagen können.

Beispiel: Statt eines aufwendigen maschinellen Lernmodells könnte ein einfacher Durchschnittswert oder eine Monte-Carlo-Simulation bessere Ergebnisse liefern.

---

Wie erkennt man einen Random Walk?

In der Praxis gibt es statistische Tests, um festzustellen, ob ein Prozess einem Random Walk folgt. Ein häufig verwendeter Test ist der Augmented Dickey-Fuller-Test (ADF-Test), der in Python mit Bibliotheken wie statsmodels in nur wenigen Codezeilen durchgeführt werden kann.

Beispielcode in Python:

from statsmodels.tsa.stattools import adfuller

# Beispiel: Zeitreihendaten
data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# ADF-Test durchführen
result = adfuller(data)
print('ADF-Statistik:', result[0])
print('p-Wert:', result[1])

Ein niedriger p-Wert (typischerweise < 0,05) deutet darauf hin, dass die Zeitreihe kein Random Walk ist.

---

Fazit: Die Kunst der Anpassung

Die Analyse eines Prozesses als Random Walk unterstreicht, dass nicht alle Entwicklungen vorhersehbar sind. Für die Vorhersage solcher Prozesse empfiehlt es sich, kürzere Vorhersagezeiträume zu wählen und Modelle fortlaufend an aktuelle Entwicklungen anzupassen.

Ein Random Walk ist kein Grund zur Verzweiflung – im Gegenteil. Er erinnert uns daran, Flexibilität und Realismus in unsere Analysen einzubauen. Und dank moderner Tools wie statsmodels ist es einfacher denn je, die Natur eines Prozesses zu verstehen und die richtigen Schlüsse daraus zu ziehen. 👞📈

---

In der heutigen datengetriebenen Welt ist die Fähigkeit, zukünftige Trends vorherzusagen, ein entscheidender Wettbewerbsvorteil. Insbesondere im Bereich der Verkaufsdaten kann die Vorhersage von Kundenumsätzen Unternehmen dabei helfen, fundierte Entscheidungen zu treffen, Lagerbestände zu optimieren und Marketingstrategien zu verbessern. In diesem Blogbeitrag werden wir uns damit beschäftigen, wie man mit SQL Server und Python eine Vorhersage von Kundenumsätzen erstellen kann. Wir werden sowohl T-SQL als auch Python-Skripte verwenden, um die Daten zu analysieren und Vorhersagen zu treffen.

Inhaltsverzeichnis

1. Einführung in die Zeitreihenvorhersage
2. Datenvorbereitung in SQL Server
3. Vorhersagemodell mit Python erstellen
4. Integration der Vorhersage in SQL Server
5. Visualisierung der Ergebnisse
6. Fazit

---

1. Einführung in die Zeitreihenvorhersage

Die Zeitreihenvorhersage ist eine Technik, die verwendet wird, um zukünftige Werte auf der Grundlage historischer Daten vorherzusagen. Im Kontext von Verkaufsdaten kann dies bedeuten, zukünftige Umsätze auf der Grundlage vergangener Verkaufszahlen vorherzusagen. Es gibt verschiedene Methoden zur Zeitreihenvorhersage, darunter:

• ARIMA (AutoRegressive Integrated Moving Average)
• Exponentielle Glättung
• Maschinelles Lernen (z.B. Random Forest, LSTM)

In diesem Beitrag werden wir uns auf die Verwendung von ARIMA konzentrieren, einer der am häufigsten verwendeten Methoden zur Zeitreihenvorhersage.

---

2. Datenvorbereitung in SQL Server

Bevor wir mit der Vorhersage beginnen können, müssen wir sicherstellen, dass unsere Daten in SQL Server korrekt vorbereitet sind. Angenommen, wir haben eine Tabelle Sales mit den folgenden Spalten:

• CustomerID (int)
• SaleDate (date)
• SaleAmount (decimal)

Unser Ziel ist es, die zukünftigen Umsätze für jeden Kunden vorherzusagen.

Beispiel-T-SQL-Skript zur Datenvorbereitung:

-- Erstellen einer temporären Tabelle für die aggregierten Verkaufsdaten
CREATE TABLE #AggregatedSales (
    CustomerID INT,
    SaleDate DATE,
    TotalSaleAmount DECIMAL(18, 2)
);

-- Aggregieren der Verkaufsdaten pro Kunde und Datum
INSERT INTO #AggregatedSales (CustomerID, SaleDate, TotalSaleAmount)
SELECT 
    CustomerID,
    SaleDate,
    SUM(SaleAmount) AS TotalSaleAmount
FROM 
    Sales
GROUP BY 
    CustomerID, SaleDate
ORDER BY 
    CustomerID, SaleDate;

-- Anzeigen der aggregierten Daten
SELECT * FROM #AggregatedSales;

Dieses Skript aggregiert die Verkaufsdaten pro Kunde und Datum, sodass wir eine Zeitreihe für jeden Kunden erhalten.

---

3. Vorhersagemodell mit Python erstellen

Nachdem wir die Daten in SQL Server vorbereitet haben, können wir Python verwenden, um ein Vorhersagemodell zu erstellen. Wir werden die Bibliothek pandas für die Datenmanipulation und statsmodels für die ARIMA-Modellierung verwenden.

Beispiel-Python-Skript zur Vorhersage:

import pandas as pd
import numpy as np
from statsmodels.tsa.arima.model import ARIMA
import pyodbc

# Verbindung zur SQL Server-Datenbank herstellen
conn = pyodbc.connect('DRIVER={SQL Server};SERVER=dein_server;DATABASE=deine_datenbank;UID=dein_user;PWD=dein_passwort')

# Daten aus der temporären Tabelle abrufen
query = "SELECT CustomerID, SaleDate, TotalSaleAmount FROM #AggregatedSales"
df = pd.read_sql(query, conn)

# Funktion zur Vorhersage der Umsätze
def forecast_sales(customer_data, periods=12):
    model = ARIMA(customer_data['TotalSaleAmount'], order=(5,1,0))
    model_fit = model.fit()
    forecast = model_fit.forecast(steps=periods)
    return forecast

# Vorhersage für jeden Kunden erstellen
forecast_results = {}
for customer_id in df['CustomerID'].unique():
    customer_data = df[df['CustomerID'] == customer_id]
    forecast = forecast_sales(customer_data)
    forecast_results[customer_id] = forecast

# Ergebnisse anzeigen
for customer_id, forecast in forecast_results.items():
    print(f"Customer {customer_id} Forecast: {forecast}")

Dieses Skript verbindet sich mit der SQL Server-Datenbank, ruft die aggregierten Verkaufsdaten ab und erstellt für jeden Kunden eine Vorhersage der zukünftigen Umsätze.

---

4. Integration der Vorhersage in SQL Server

Nachdem wir die Vorhersagen in Python erstellt haben, können wir diese wieder in SQL Server integrieren, um sie für weitere Analysen oder Berichte zu verwenden.

Beispiel-T-SQL-Skript zur Speicherung der Vorhersagen:

-- Erstellen einer Tabelle für die Vorhersageergebnisse
CREATE TABLE SalesForecast (
    CustomerID INT,
    ForecastDate DATE,
    ForecastAmount DECIMAL(18, 2)
);

-- Einfügen der Vorhersageergebnisse in die Tabelle
INSERT INTO SalesForecast (CustomerID, ForecastDate, ForecastAmount)
VALUES
(1, '2023-11-01', 1500.00),
(1, '2023-12-01', 1600.00),
(2, '2023-11-01', 2000.00),
(2, '2023-12-01', 2100.00);
-- (Weitere Vorhersagen einfügen...)

-- Anzeigen der Vorhersageergebnisse
SELECT * FROM SalesForecast;

---

5. Visualisierung der Ergebnisse

Die Visualisierung der Vorhersageergebnisse ist ein wichtiger Schritt, um die Daten besser zu verstehen und zu interpretieren. Wir können Python-Bibliotheken wie matplotlib oder seaborn verwenden, um die Vorhersagen grafisch darzustellen.

Beispiel-Python-Skript zur Visualisierung:

import matplotlib.pyplot as plt

# Visualisierung der Vorhersageergebnisse
for customer_id, forecast in forecast_results.items():
    plt.plot(forecast, label=f'Customer {customer_id}')

plt.title('Sales Forecast')
plt.xlabel('Months')
plt.ylabel('Sales Amount')
plt.legend()
plt.show()

---

6. Fazit

Die Vorhersage von Kundenumsätzen ist ein mächtiges Werkzeug, das Unternehmen dabei helfen kann, zukünftige Trends zu antizipieren und strategische Entscheidungen zu treffen. Durch die Kombination von SQL Server und Python können wir eine robuste Lösung zur Datenvorbereitung, Modellierung und Visualisierung erstellen. Die Verwendung von ARIMA-Modellen ermöglicht es uns, präzise Vorhersagen zu treffen, die auf historischen Daten basieren.

Mit den in diesem Beitrag vorgestellten Skripten und Techniken können Sie Ihre eigenen Vorhersagemodelle erstellen und in Ihre bestehenden Datenpipelines integrieren. Probieren Sie es aus und sehen Sie, wie Sie Ihre Verkaufsstrategien optimieren können!

---

In diesem Blogbeitrag werden wir Schritt für Schritt eine CI/CD-Pipeline (Continuous Integration/Continuous Deployment) mit Python und DuckDB erstellen. DuckDB ist eine leistungsstarke, in-memory OLAP-Datenbank, die sich hervorragend für analytische Workloads eignet. Wir werden eine Pipeline aufbauen, die automatisch Tests durchführt, die Datenbank aktualisiert und bei Bedarf neue Versionen bereitstellt.

Voraussetzungen

Bevor wir beginnen, stellen Sie sicher, dass Sie folgende Tools installiert haben:

• Python 3.8 oder höher
• DuckDB: Installieren Sie DuckDB mit pip install duckdb.
• Git: Für die Versionskontrolle.
• GitHub Actions oder ein anderer CI/CD-Dienst (z.B. GitLab CI, Jenkins).
• Ein GitHub-Repository: Wo wir unseren Code und die Pipeline speichern werden.

Schritt 1: Projektstruktur erstellen

Zuerst erstellen wir eine grundlegende Projektstruktur:

my_duckdb_project/
│
├── .github/
│   └── workflows/
│       └── ci_cd_pipeline.yml
├── src/
│   └── main.py
├── tests/
│   └── test_main.py
├── requirements.txt
└── README.md

• .github/workflows/ci_cd_pipeline.yml: Hier definieren wir unsere CI/CD-Pipeline.
• src/main.py: Unser Hauptskript, das DuckDB verwendet.
• tests/test_main.py: Unit-Tests für unser Skript.
• requirements.txt: Liste der Python-Abhängigkeiten.
• README.md: Dokumentation des Projekts.

Schritt 2: Python-Skript mit DuckDB erstellen

In src/main.py schreiben wir ein einfaches Python-Skript, das DuckDB verwendet:

import duckdb

def create_table():
    conn = duckdb.connect('my_db.duckdb')
    conn.execute("CREATE TABLE IF NOT EXISTS my_table (id INTEGER, name STRING)")
    conn.close()

def insert_data(id, name):
    conn = duckdb.connect('my_db.duckdb')
    conn.execute(f"INSERT INTO my_table VALUES ({id}, '{name}')")
    conn.close()

def query_data():
    conn = duckdb.connect('my_db.duckdb')
    result = conn.execute("SELECT * FROM my_table").fetchall()
    conn.close()
    return result

if __name__ == "__main__":
    create_table()
    insert_data(1, 'Alice')
    insert_data(2, 'Bob')
    print(query_data())

Dieses Skript erstellt eine Tabelle, fügt Daten ein und gibt die Daten aus der Tabelle zurück.

Schritt 3: Unit-Tests schreiben

In tests/test_main.py schreiben wir Unit-Tests für unser Skript:

import unittest
from src.main import create_table, insert_data, query_data

class TestDuckDB(unittest.TestCase):
    def test_create_table(self):
        create_table()
        # Überprüfen, ob die Tabelle erstellt wurde
        self.assertTrue(True)  # Platzhalter für echte Überprüfung

    def test_insert_data(self):
        insert_data(1, 'Alice')
        data = query_data()
        self.assertIn((1, 'Alice'), data)

if __name__ == "__main__":
    unittest.main()

Schritt 4: Abhängigkeiten festlegen

In requirements.txt listen wir unsere Python-Abhängigkeiten auf:

duckdb==0.5.0

Schritt 5: CI/CD-Pipeline mit GitHub Actions erstellen

In .github/workflows/ci_cd_pipeline.yml definieren wir unsere CI/CD-Pipeline:

name: CI/CD Pipeline for DuckDB Project

on:
  push:
    branches:
      - main
  pull_request:
    branches:
      - main

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2
    - name: Set up Python
      uses: actions/setup-python@v2
      with:
        python-version: '3.8'
    - name: Install dependencies
      run: |
        python -m pip install --upgrade pip
        pip install -r requirements.txt
    - name: Run tests
      run: |
        python -m unittest discover -s tests

  deploy:
    needs: test
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2
    - name: Set up Python
      uses: actions/setup-python@v2
      with:
        python-version: '3.8'
    - name: Install dependencies
      run: |
        python -m pip install --upgrade pip
        pip install -r requirements.txt
    - name: Run main script
      run: |
        python src/main.py

Diese Pipeline führt die folgenden Schritte aus:

1. Test-Job: Führt die Unit-Tests aus, wenn ein Push oder Pull Request auf den main-Branch erfolgt.
2. Deploy-Job: Führt das Hauptskript aus, wenn die Tests erfolgreich sind.

Schritt 6: Pipeline in Aktion

Sobald Sie den Code in Ihr GitHub-Repository pushen, wird die Pipeline automatisch ausgeführt. Sie können den Fortschritt und die Ergebnisse der Pipeline in der GitHub Actions-Ansicht überprüfen.

Fazit

In diesem Blogbeitrag haben wir eine einfache CI/CD-Pipeline mit Python und DuckDB erstellt. Diese Pipeline führt automatisch Tests durch und stellt bei Erfolg das Skript bereit. Dieses Setup kann je nach Bedarf erweitert werden, z.B. durch das Hinzufügen von Datenbank-Migrationen, weiteren Tests oder Deployment-Schritten.

In der heutigen Geschäftswelt ist die Kundenzufriedenheit und -bindung von entscheidender Bedeutung. Unternehmen investieren viel Zeit und Ressourcen, um ihre Kunden zu halten und deren Zufriedenheit zu steigern. Ein wichtiger Aspekt dabei ist die Analyse des Customer Churn, also der Kundenabwanderung. In diesem Blogbeitrag werden wir eine detaillierte Customer Churn Analysis mit Python durchführen. Wir werden verschiedene Techniken und Methoden anwenden, um Muster zu erkennen, Vorhersagen zu treffen und schließlich Strategien zur Reduzierung der Kundenabwanderung zu entwickeln.

Was ist Customer Churn?

Customer Churn, oder Kundenabwanderung, bezieht sich auf den Prozess, bei dem Kunden den Dienst eines Unternehmens nicht mehr nutzen. Dies kann verschiedene Gründe haben, wie z.B. Unzufriedenheit mit dem Service, bessere Angebote von Wettbewerbern oder einfach eine Veränderung der Bedürfnisse des Kunden. Die Analyse des Churns hilft Unternehmen, die Gründe für die Abwanderung zu verstehen und Maßnahmen zu ergreifen, um die Kundenbindung zu verbessern.

Warum ist eine Churn-Analyse wichtig?

• Kostenersparnis: Es ist oft kostengünstiger, bestehende Kunden zu halten, als neue zu gewinnen.
• Umsatzsteigerung: Zufriedene Kunden neigen dazu, mehr zu kaufen und länger zu bleiben.
• Wettbewerbsvorteil: Durch die Reduzierung der Abwanderung kann ein Unternehmen seinen Marktanteil sichern und ausbauen.

Schritt-für-Schritt-Anleitung zur Customer Churn Analysis mit Python

In diesem Abschnitt werden wir eine detaillierte Churn-Analyse mit Python durchführen. Wir verwenden ein fiktives Dataset, das typische Merkmale von Kunden enthält, wie z.B. Alter, Geschlecht, Vertragslaufzeit, monatliche Gebühren und ob der Kunde abgewandert ist oder nicht.

1. Importieren der notwendigen Bibliotheken

Zuerst müssen wir die notwendigen Python-Bibliotheken importieren. Dazu gehören pandas für die Datenmanipulation, numpy für numerische Operationen, matplotlib und seaborn für die Visualisierung sowie scikit-learn für maschinelles Lernen.

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report, confusion_matrix

2. Laden und Erkunden der Daten

Als Nächstes laden wir das Dataset und verschaffen uns einen Überblick über die Daten.

# Laden des Datasets
data = pd.read_csv('customer_churn.csv')

# Erste fünf Zeilen anzeigen
print(data.head())

# Informationen über das Dataset
print(data.info())

# Statistische Zusammenfassung
print(data.describe())

3. Datenbereinigung und Vorverarbeitung

Bevor wir mit der Analyse beginnen, müssen wir sicherstellen, dass die Daten sauber und vorverarbeitet sind. Dazu gehören das Handeln von fehlenden Werten, das Konvertieren von kategorischen Variablen in numerische und das Skalieren der Daten.

# Überprüfen auf fehlende Werte
print(data.isnull().sum())

# Fehlende Werte behandeln (z.B. durch Mittelwert oder Median)
data['TotalCharges'] = data['TotalCharges'].replace(' ', np.nan)
data['TotalCharges'] = data['TotalCharges'].astype(float)
data['TotalCharges'].fillna(data['TotalCharges'].median(), inplace=True)

# Konvertieren von kategorischen Variablen in numerische
data['Churn'] = data['Churn'].map({'Yes': 1, 'No': 0})
data = pd.get_dummies(data, drop_first=True)

# Skalieren der Daten
scaler = StandardScaler()
X = data.drop('Churn', axis=1)
y = data['Churn']
X_scaled = scaler.fit_transform(X)

4. Exploratory Data Analysis (EDA)

Die explorative Datenanalyse hilft uns, Muster und Beziehungen in den Daten zu erkennen. Wir verwenden Visualisierungen, um die Verteilung der Daten und die Beziehung zwischen den Variablen zu verstehen.

# Verteilung der Zielvariable (Churn)
sns.countplot(x='Churn', data=data)
plt.title('Verteilung der Kundenabwanderung')
plt.show()

# Korrelationsmatrix
corr_matrix = data.corr()
sns.heatmap(corr_matrix, annot=True, cmap='coolwarm')
plt.title('Korrelationsmatrix')
plt.show()

# Verteilung der monatlichen Gebühren
sns.histplot(data['MonthlyCharges'], kde=True)
plt.title('Verteilung der monatlichen Gebühren')
plt.show()

5. Modellierung und Vorhersage

Nachdem wir die Daten vorbereitet haben, können wir ein maschinelles Lernmodell erstellen, um den Churn vorherzusagen. In diesem Beispiel verwenden wir eine logistische Regression.

# Aufteilen der Daten in Trainings- und Testsets
X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.3, random_state=42)

# Erstellen und Trainieren des Modells
model = LogisticRegression()
model.fit(X_train, y_train)

# Vorhersagen auf dem Testset
y_pred = model.predict(X_test)

# Auswertung des Modells
print(confusion_matrix(y_test, y_pred))
print(classification_report(y_test, y_pred))

6. Interpretation der Ergebnisse

Die Auswertung des Modells gibt uns Aufschluss über die Leistung unseres Modells. Die Konfusionsmatrix zeigt die Anzahl der richtig und falsch klassifizierten Fälle, während der Klassifikationsbericht Präzision, Recall und F1-Score liefert.

# Konfusionsmatrix
conf_matrix = confusion_matrix(y_test, y_pred)
sns.heatmap(conf_matrix, annot=True, fmt='d', cmap='Blues')
plt.title('Konfusionsmatrix')
plt.xlabel('Vorhergesagt')
plt.ylabel('Tatsächlich')
plt.show()

# Klassifikationsbericht
print(classification_report(y_test, y_pred))

7. Maßnahmen zur Reduzierung des Churns

Basierend auf den Ergebnissen unserer Analyse können wir nun Maßnahmen zur Reduzierung des Churns ableiten. Zum Beispiel könnten wir feststellen, dass Kunden mit höheren monatlichen Gebühren eher abwandern. In diesem Fall könnten wir spezielle Angebote oder Rabatte für diese Kunden einführen, um sie zu halten.

Fazit

Die Customer Churn Analysis ist ein mächtiges Werkzeug, um die Kundenabwanderung zu verstehen und zu reduzieren. Mit Python und den richtigen Techniken können wir tiefgehende Einblicke in die Daten gewinnen und fundierte Entscheidungen treffen. Durch die Anwendung von maschinellen Lernmodellen können wir nicht nur den Churn vorhersagen, sondern auch gezielte Maßnahmen zur Verbesserung der Kundenbindung entwickeln.

Ich hoffe, dieser Blogbeitrag hat Ihnen geholfen, die Grundlagen der Customer Churn Analysis mit Python zu verstehen. Wenn Sie Fragen haben oder weitere Details benötigen, zögern Sie nicht, mich zu kontaktieren. Viel Erfolg bei Ihren Analysen!

---

Hinweis: Das in diesem Beitrag verwendete Dataset ist fiktiv und dient nur zu Demonstrationszwecken. In der Praxis sollten Sie reale Daten verwenden, um aussagekräftige Ergebnisse zu erzielen.

Datenverschlüsselung ist ein wichtiger Aspekt der Datensicherheit, sowohl bei der Speicherung (at rest) als auch während der Übertragung (in transit). In diesem Kontext werden wir die Verschlüsselung mit Microsoft SQL Server und Python betrachten.

1. Datenverschlüsselung in SQL Server

a. Verschlüsselung at rest

SQL Server bietet mehrere Möglichkeiten, Daten at rest zu verschlüsseln:

• Transparent Data Encryption (TDE): TDE verschlüsselt die gesamte Datenbank auf der Festplatte. Dies umfasst die Datenbankdateien, Backup-Dateien und Transaktionsprotokolle. Die Verschlüsselung erfolgt auf der Ebene des Speichersystems, ohne dass Änderungen an der Anwendung erforderlich sind.

  -- Aktivieren von TDE für eine Datenbank
  CREATE DATABASE ENCRYPTION KEY
  WITH ALGORITHM = AES_256
  ENCRYPTION BY SERVER CERTIFICATE MyServerCert;
  
  ALTER DATABASE MyDatabase
  SET ENCRYPTION ON;
  

• Column-Level Encryption: Diese Methode ermöglicht die Verschlüsselung einzelner Spalten in einer Tabelle. Sie ist nützlich, wenn nur bestimmte sensible Daten verschlüsselt werden sollen.

  -- Erstellen eines symmetrischen Schlüssels
  CREATE SYMMETRIC KEY MyColumnKey
  WITH ALGORITHM = AES_256
  ENCRYPTION BY PASSWORD = 'MyPassword';
  
  -- Verschlüsseln einer Spalte
  OPEN SYMMETRIC KEY MyColumnKey
  DECRYPTION BY PASSWORD = 'MyPassword';
  
  UPDATE MyTable
  SET MyEncryptedColumn = EncryptByKey(Key_GUID('MyColumnKey'), MySensitiveData);
  

b. Verschlüsselung in transit

SQL Server verwendet standardmäßig TLS (Transport Layer Security), um Daten während der Übertragung zu verschlüsseln. Um dies zu aktivieren, müssen Sie ein Zertifikat auf dem SQL Server installieren und die entsprechenden Netzwerkeinstellungen konfigurieren.

• TLS-Konfiguration:

  1. Erwerben Sie ein Zertifikat von einer vertrauenswürdigen Zertifizierungsstelle (CA).
  2. Installieren Sie das Zertifikat auf dem SQL Server.
  3. Konfigurieren Sie SQL Server, um das Zertifikat zu verwenden.

  -- Überprüfen des Zertifikats
  SELECT * FROM sys.certificates;
  

2. Datenverschlüsselung mit Python

a. Verschlüsselung at rest

Python bietet verschiedene Bibliotheken zur Verschlüsselung von Daten, wie z.B. cryptography und pycryptodome.

• Beispiel mit cryptography:

  from cryptography.fernet import Fernet
  
  # Schlüssel generieren
  key = Fernet.generate_key()
  cipher_suite = Fernet(key)
  
  # Daten verschlüsseln
  data = b"My sensitive data"
  encrypted_data = cipher_suite.encrypt(data)
  
  # Daten entschlüsseln
  decrypted_data = cipher_suite.decrypt(encrypted_data)
  

b. Verschlüsselung in transit

Für die Verschlüsselung in transit kann Python die ssl-Bibliothek verwenden, um sichere Verbindungen zu erstellen.

• Beispiel mit ssl:

  import ssl
  import socket
  
  # Erstellen eines sicheren Sockets
  context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
  context.load_cert_chain(certfile="server.crt", keyfile="server.key")
  
  with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
    with context.wrap_socket(sock, server_side=True) as ssock:
        ssock.bind(('localhost', 443))
        ssock.listen(5)
        conn, addr = ssock.accept()
        with conn:
            print('Connected by', addr)
            data = conn.recv(1024)
            print('Received', data)
            conn.sendall(data)
  

3. Kombination von SQL Server und Python

Wenn Sie Python verwenden, um mit einer SQL Server-Datenbank zu interagieren, können Sie die Verschlüsselungsfunktionen von SQL Server nutzen, um die Daten at rest zu schützen, und die ssl-Bibliothek von Python, um die Daten in transit zu verschlüsseln.

• Beispiel für eine sichere Verbindung zu SQL Server mit pyodbc:

  import pyodbc
  import ssl
  
  # SSL-Kontext erstellen
  context = ssl.create_default_context()
  
  # Verbindung zur SQL Server-Datenbank herstellen
  conn = pyodbc.connect(
    'DRIVER={ODBC Driver 17 for SQL Server};'
    'SERVER=my_server;'
    'DATABASE=my_database;'
    'UID=my_username;'
    'PWD=my_password;',
    sslcontext=context
  )
  
  cursor = conn.cursor()
  cursor.execute("SELECT * FROM MyTable")
  rows = cursor.fetchall()
  for row in rows:
    print(row)
  

Fazit

Die Verschlüsselung von Daten at rest und in transit ist entscheidend für die Sicherheit Ihrer Anwendungen. SQL Server bietet robuste Mechanismen für die Verschlüsselung von Daten at rest und in transit, während Python flexible Bibliotheken für die Verschlüsselung und sichere Kommunikation bereitstellt. Durch die Kombination dieser Technologien können Sie ein hohes Maß an Datensicherheit erreichen.

Datenvisualisierung ist ein mächtiges Werkzeug, um komplexe Informationen verständlich und ansprechend darzustellen. Python bietet eine Vielzahl von Bibliotheken, die dir helfen, Daten in beeindruckende Grafiken und Diagramme zu verwandeln. In diesem Blogbeitrag stelle ich dir die besten Python-Bibliotheken für Datenvisualisierung vor und zeige dir anhand von Beispielen und Skripten, wie du sie effektiv nutzen kannst.

---

1. Matplotlib: Die Grundlage der Python-Visualisierung

Matplotlib ist eine der ältesten und am weitesten verbreiteten Bibliotheken für Datenvisualisierung in Python. Sie bietet eine hohe Flexibilität und ist die Grundlage für viele andere Visualisierungsbibliotheken.

Beispiel: Liniendiagramm

import matplotlib.pyplot as plt
import numpy as np

# Daten erstellen
x = np.linspace(0, 10, 100)
y = np.sin(x)

# Diagramm erstellen
plt.plot(x, y, label='Sin(x)')
plt.title('Liniendiagramm mit Matplotlib')
plt.xlabel('X-Achse')
plt.ylabel('Y-Achse')
plt.legend()
plt.show()

---

2. Seaborn: Statistische Visualisierungen leicht gemacht

Seaborn baut auf Matplotlib auf und bietet eine höhere Abstraktionsebene. Es ist besonders nützlich für statistische Visualisierungen und bietet integrierte Funktionen für Heatmaps, Pairplots und mehr.

Beispiel: Heatmap

import seaborn as sns
import pandas as pd

# Daten erstellen
data = pd.DataFrame({
    'A': np.random.rand(10),
    'B': np.random.rand(10),
    'C': np.random.rand(10)
})

# Heatmap erstellen
sns.heatmap(data, annot=True, cmap='viridis')
plt.title('Heatmap mit Seaborn')
plt.show()

---

3. Plotly: Interaktive Visualisierungen

Plotly ist eine leistungsstarke Bibliothek für interaktive Visualisierungen. Mit Plotly kannst du Diagramme erstellen, die sich zoomen, drehen und anklicken lassen.

Beispiel: Interaktives Liniendiagramm

import plotly.express as px
import pandas as pd

# Daten erstellen
df = pd.DataFrame({
    'Jahr': [2010, 2011, 2012, 2013, 2014],
    'Umsatz': [200, 220, 250, 275, 300]
})

# Interaktives Diagramm erstellen
fig = px.line(df, x='Jahr', y='Umsatz', title='Umsatzentwicklung')
fig.show()

---

4. Pandas: Einfache Visualisierungen direkt aus DataFrames

Pandas bietet integrierte Visualisierungsfunktionen, die auf Matplotlib basieren. Sie sind ideal für schnelle und einfache Visualisierungen direkt aus DataFrames.

Beispiel: Balkendiagramm

import pandas as pd

# Daten erstellen
data = {'Produkt': ['A', 'B', 'C', 'D'], 'Verkäufe': [23, 45, 12, 67]}
df = pd.DataFrame(data)

# Balkendiagramm erstellen
df.plot(kind='bar', x='Produkt', y='Verkäufe', title='Verkäufe nach Produkt')
plt.show()

---

5. Bokeh: Interaktive Web-Visualisierungen

Bokeh ist eine Bibliothek für interaktive Visualisierungen, die besonders für Webanwendungen geeignet ist. Mit Bokeh kannst du komplexe, interaktive Dashboards erstellen.

Beispiel: Interaktives Streudiagramm

from bokeh.plotting import figure, show
from bokeh.io import output_notebook

# Daten erstellen
x = [1, 2, 3, 4, 5]
y = [6, 7, 2, 4, 5]

# Interaktives Diagramm erstellen
p = figure(title="Interaktives Streudiagramm", x_axis_label='X', y_axis_label='Y')
p.circle(x, y, size=10, color="navy", alpha=0.5)
output_notebook()
show(p)

---

6. Altair: Deklarative Visualisierungen

Altair ist eine deklarative Visualisierungsbibliothek, die auf Vega-Lite basiert. Sie ist besonders nützlich für die Erstellung von komplexen Visualisierungen mit minimalem Code.

Beispiel: Streudiagramm

import altair as alt
import pandas as pd

# Daten erstellen
data = pd.DataFrame({
    'X': np.random.rand(100),
    'Y': np.random.rand(100)
})

# Streudiagramm erstellen
chart = alt.Chart(data).mark_circle().encode(
    x='X',
    y='Y',
    tooltip=['X', 'Y']
).interactive()

chart.show()

---

7. Geopandas: Geografische Visualisierungen

Geopandas erweitert Pandas um Funktionen für geografische Daten. Es ist ideal für die Visualisierung von Karten und geografischen Informationen.

Beispiel: Kartenvisualisierung

import geopandas as gpd
import matplotlib.pyplot as plt

# Weltkarte laden
world = gpd.read_file(gpd.datasets.get_path('naturalearth_lowres'))

# Karte anzeigen
world.plot()
plt.title('Weltkarte mit Geopandas')
plt.show()

---

Fazit

Python bietet eine Vielzahl von Bibliotheken für Datenvisualisierung, die für unterschiedliche Anwendungsfälle geeignet sind. Ob du einfache Diagramme, interaktive Visualisierungen oder geografische Karten erstellen möchtest – mit diesen Bibliotheken hast du die richtigen Werkzeuge zur Hand. Probiere die Beispiele aus und entdecke die Möglichkeiten, die Python für die Datenvisualisierung bietet.

---

In der heutigen datengetriebenen Welt ist die Fähigkeit, Daten effizient zu sammeln, zu verarbeiten und zu analysieren, von entscheidender Bedeutung. Eine Datenpipeline ist ein zentrales Konzept, das diesen Prozess automatisiert und optimiert. In diesem Blogbeitrag werden wir eine umfassende Datenpipeline mit Python erstellen, die Daten aus verschiedenen Quellen sammelt, transformiert und in einer Datenbank speichert.

Was ist eine Datenpipeline?

Eine Datenpipeline ist eine Reihe von Prozessen, die Daten von einer Quelle zu einem Ziel transportieren, wobei die Daten auf dem Weg transformiert, bereinigt oder angereichert werden können. Typische Schritte in einer Datenpipeline umfassen:

1. Datenerfassung: Daten aus verschiedenen Quellen wie APIs, Dateien oder Datenbanken sammeln.
2. Datenbereinigung: Ungültige oder fehlende Daten entfernen oder korrigieren.
3. Datentransformation: Daten in ein geeignetes Format für die Analyse oder Speicherung umwandeln.
4. Datenspeicherung: Die verarbeiteten Daten in einer Datenbank, einem Data Warehouse oder einem anderen Speichersystem ablegen.

Beispiel: Eine Datenpipeline für Wetterdaten

In diesem Beispiel erstellen wir eine Datenpipeline, die Wetterdaten von einer öffentlichen API abruft, die Daten bereinigt und transformiert und sie schließlich in einer SQLite-Datenbank speichert.

Voraussetzungen

Bevor wir beginnen, stellen Sie sicher, dass Sie die folgenden Python-Bibliotheken installiert haben:

pip install requests pandas sqlite3

Schritt 1: Datenerfassung

Zuerst müssen wir die Wetterdaten von einer API abrufen. Wir verwenden die OpenWeatherMap API, die aktuelle Wetterdaten für verschiedene Städte bereitstellt.

import requests
import pandas as pd
import sqlite3

# API-Schlüssel und URL
API_KEY = 'dein_api_schluessel'
BASE_URL = 'http://api.openweathermap.org/data/2.5/weather'

# Funktion zum Abrufen von Wetterdaten
def fetch_weather_data(city):
    params = {
        'q': city,
        'appid': API_KEY,
        'units': 'metric'
    }
    response = requests.get(BASE_URL, params=params)
    if response.status_code == 200:
        return response.json()
    else:
        print(f"Fehler beim Abrufen der Daten für {city}: {response.status_code}")
        return None

# Liste der Städte, für die wir Wetterdaten abrufen möchten
cities = ['Berlin', 'Munich', 'Hamburg', 'Frankfurt', 'Cologne']

# Wetterdaten für alle Städte abrufen
weather_data = [fetch_weather_data(city) for city in cities]

Schritt 2: Datenbereinigung und -transformation

Die von der API zurückgegebenen Daten sind im JSON-Format. Wir werden diese Daten in ein Pandas DataFrame umwandeln und bereinigen.

# Funktion zur Transformation der Wetterdaten
def transform_weather_data(data):
    transformed_data = []
    for entry in data:
        if entry:
            transformed_data.append({
                'city': entry['name'],
                'temperature': entry['main']['temp'],
                'humidity': entry['main']['humidity'],
                'pressure': entry['main']['pressure'],
                'wind_speed': entry['wind']['speed'],
                'weather_description': entry['weather'][0]['description']
            })
    return pd.DataFrame(transformed_data)

# Wetterdaten transformieren
weather_df = transform_weather_data(weather_data)

# Datenbereinigung: Entfernen von Zeilen mit fehlenden Werten
weather_df.dropna(inplace=True)

Schritt 3: Datenspeicherung

Schließlich speichern wir die transformierten Daten in einer SQLite-Datenbank.

# Verbindung zur SQLite-Datenbank herstellen
conn = sqlite3.connect('weather_data.db')

# DataFrame in die Datenbank schreiben
weather_df.to_sql('weather', conn, if_exists='replace', index=False)

# Verbindung schließen
conn.close()

Vollständiges Skript

Hier ist das vollständige Skript, das alle Schritte kombiniert:

import requests
import pandas as pd
import sqlite3

# API-Schlüssel und URL
API_KEY = 'dein_api_schluessel'
BASE_URL = 'http://api.openweathermap.org/data/2.5/weather'

# Funktion zum Abrufen von Wetterdaten
def fetch_weather_data(city):
    params = {
        'q': city,
        'appid': API_KEY,
        'units': 'metric'
    }
    response = requests.get(BASE_URL, params=params)
    if response.status_code == 200:
        return response.json()
    else:
        print(f"Fehler beim Abrufen der Daten für {city}: {response.status_code}")
        return None

# Funktion zur Transformation der Wetterdaten
def transform_weather_data(data):
    transformed_data = []
    for entry in data:
        if entry:
            transformed_data.append({
                'city': entry['name'],
                'temperature': entry['main']['temp'],
                'humidity': entry['main']['humidity'],
                'pressure': entry['main']['pressure'],
                'wind_speed': entry['wind']['speed'],
                'weather_description': entry['weather'][0]['description']
            })
    return pd.DataFrame(transformed_data)

# Liste der Städte, für die wir Wetterdaten abrufen möchten
cities = ['Berlin', 'Munich', 'Hamburg', 'Frankfurt', 'Cologne']

# Wetterdaten für alle Städte abrufen
weather_data = [fetch_weather_data(city) for city in cities]

# Wetterdaten transformieren
weather_df = transform_weather_data(weather_data)

# Datenbereinigung: Entfernen von Zeilen mit fehlenden Werten
weather_df.dropna(inplace=True)

# Verbindung zur SQLite-Datenbank herstellen
conn = sqlite3.connect('weather_data.db')

# DataFrame in die Datenbank schreiben
weather_df.to_sql('weather', conn, if_exists='replace', index=False)

# Verbindung schließen
conn.close()

print("Datenpipeline erfolgreich abgeschlossen!")

Fazit

In diesem Blogbeitrag haben wir eine einfache Datenpipeline mit Python erstellt, die Wetterdaten von einer API abruft, diese Daten bereinigt und transformiert und sie schließlich in einer SQLite-Datenbank speichert. Diese Pipeline kann leicht erweitert werden, um zusätzliche Datenquellen, komplexere Transformationen oder andere Speichersysteme zu integrieren.

1. Library-Wahl für die Lineage-Analyse

Es gibt spezialisierte Libraries für Data Lineage, zum Beispiel: - Great Expectations: Eine Bibliothek, die oft zur Datenvalidierung genutzt wird und die auch Lineage-Informationen erfassen kann. - OpenLineage und Marquez: Diese beiden Open-Source-Projekte wurden speziell für Data Lineage entwickelt und könnten für die Integration mit DuckDB angepasst werden. - Apache Airflow: Falls du Airflow für dein ETL-Management einsetzt, kannst du Lineage auch über seine integrierten Features verfolgen.

2. Manuelle Implementierung mit Python

Du kannst Data Lineage auch mit einer individuelleren Lösung in Python verfolgen, indem du:

• Jede Transformation und jeden Load-Schritt dokumentierst: Du könntest Log-Dateien oder eine Meta-Datenbank verwenden, die für jeden Verarbeitungsschritt Metadaten wie Quelltabellen, Zieltabellen, Transformationen und Timestamps speichert.

• Datenfluss-Graphen erstellen: Mit Bibliotheken wie NetworkX kannst du ein graphisches Modell des Datenflusses erstellen. Jeder Knoten im Graphen steht für eine Tabelle, und die Kanten zeigen Transformationen oder Load-Schritte an.

• SQL-Parsing: Wenn du SQL-Statements verwendest, können Tools wie sqlparse oder Jinja2 dir helfen, die SQL-Statements zu analysieren und Informationen über Datenbewegungen zwischen Tabellen zu extrahieren.

3. Implementierungsschritte

1. Initialisierung: Setze eine zentrale Logging- oder Metadatenkomponente auf, die jeden Verarbeitungsschritt dokumentiert.
2. Verfolgung der Transformationen: Füge in jedem ETL-Schritt eine Funktion hinzu, die Metadaten wie Quelldateien, Zieltabellen und Transformationen speichert.
3. Generierung einer Lineage-Dokumentation: Mit den gesammelten Metadaten kannst du am Ende für jede Dimension oder Faktentabelle die Herkunft und Verarbeitungsschritte rekonstruieren.
4. Visualisierung: Optional kannst du mit Graphviz oder Plotly eine visuelle Übersicht des Datenflusses erstellen.

4. Automatische Lineage-Erfassung in Parquet und DuckDB

Wenn deine Lineage den Parquet-Dateien und DuckDB zugeordnet werden soll, könntest du: - In den Parquet-Metadaten relevante Lineage-Informationen speichern. Parquet unterstützt Metadaten, die du mit Pandas oder PyArrow ergänzen könntest. - DuckDB verwenden, um die Lineage zu speichern: Du könntest in DuckDB eine eigene Lineage-Tabelle anlegen, in der Transformationen und Abhängigkeiten gespeichert werden.

5. Beispiel für eine einfache Lineage-Implementierung

import logging
import datetime

# Logger initialisieren
logging.basicConfig(filename='lineage_log.log', level=logging.INFO)

def log_lineage(source, target, transformation):
    timestamp = datetime.datetime.now()
    logging.info(f"{timestamp} | Source: {source} | Target: {target} | Transformation: {transformation}")

# Beispiel für ETL-Prozess
def load_data(source_file, target_table):
    # Lade und verarbeite Daten
    transformation = "Load and transform data from source file to target table"
    log_lineage(source=source_file, target=target_table, transformation=transformation)
    # ... Lade- und Transformationslogik ...

# Aufruf des ETL-Schritts
load_data('stations.parquet', 'fact_price_changes')

Mit diesem Grundgerüst kannst du deine Lineage Schritt für Schritt aufbauen und später erweitern, um detailliertere Informationen zu erfassen.

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.