Einführung
Im vergangenen Monat betrachtete ich mein Bankkonto und versuchte herauszufinden, wohin mein Geld tatsächlich fließt. Tabellenkalkulationen erschienen mir umständlich. Die bestehenden Apps wirken wie Black Boxes, und das Schlimmste ist, dass sie verlangen, dass ich meine sensiblen Finanzdaten auf einen Cloud-Server hochlade. Ich wollte etwas anderes. Ich benötigte einen KI-Datenanalysten, der meine Ausgaben analysiert, ungewöhnliche Transaktionen erkennt und mir klare Einblicke gibt – und das alles, während meine Daten zu 100 % lokal bleiben. Daher entwickelte ich eine solche Lösung.
Was als Wochenendprojekt begann, entwickelte sich zu einer eingehenden Auseinandersetzung mit der Vorverarbeitung von realen Daten, praktischen Aspekten des maschinellen Lernens und der Leistungsfähigkeit lokaler großer Sprachmodelle (LLMs). In diesem Artikel werde ich Ihnen zeigen, wie ich eine KI-gestützte Finanzanalyse-App mit Python und „Vibe Coding“ erstellt habe. Auf dem Weg dorthin werden Sie viele praktische Konzepte kennenlernen, die auf jedes Data-Science-Projekt anwendbar sind, sei es die Analyse von Verkaufsprotokollen, Sensordaten oder Kundenfeedback.
Am Ende werden Sie verstehen:
- Wie man eine robuste Datenvorverarbeitungspipeline aufbaut, die mit unordentlichen, realen CSV-Dateien umgeht.
- Wie man maschinelle Lernmodelle auswählt und implementiert, wenn nur begrenzte Trainingsdaten zur Verfügung stehen.
- Wie man interaktive Visualisierungen gestaltet, die tatsächlich die Fragen der Benutzer beantworten.
- Wie man ein lokales LLM integriert, um Einblicke in natürlicher Sprache zu generieren, ohne die Privatsphäre zu gefährden.
Der vollständige Quellcode ist auf GitHub verfügbar. Sie können ihn gerne forken, erweitern oder als Ausgangspunkt für Ihren eigenen KI-Datenanalysten verwenden.
Abbildung 1: Dashboard der App, das die Ausgabenaufteilung und KI-Einblicke zeigt.
Das Problem: Warum ich dies entwickelt habe
Die meisten persönlichen Finanz-Apps haben einen grundlegenden Mangel: Ihre Daten verlassen Ihre Kontrolle. Sie laden Bankauszüge auf Dienste hoch, die Ihre Informationen speichern, verarbeiten und möglicherweise monetarisieren. Ich wollte ein Tool, das:
- Es mir ermöglicht, Daten sofort hochzuladen und zu analysieren.
- Alles lokal verarbeitet – keine Cloud, keine Datenlecks.
- KI-gestützte Einblicke bietet, nicht nur statische Diagramme.
Dieses Projekt wurde zu meinem Vehikel, um mehrere Konzepte zu lernen, die jeder Data Scientist kennen sollte, wie z.B. den Umgang mit inkonsistenten Datenformaten, die Auswahl von Algorithmen, die mit kleinen Datensätzen arbeiten, und den Aufbau von datenschutzfreundlichen KI-Funktionen.
Projektarchitektur
Bevor wir in den Code eintauchen, hier eine Projektstruktur, die zeigt, wie die Teile zusammenpassen:
project/ ├── app.py # Haupt-Streamlit-App ├── config.py # Einstellungen (Kategorien, Ollama-Konfiguration) ├── preprocessing.py # Automatische Erkennung von CSV-Formaten, Normalisierung der Daten ├── ml_models.py # Transaktionsklassifizierer + Isolation Forest-Anomalieerkennung ├── visualizations.py # Plotly-Diagramme (Kreis-, Balken-, Zeitachse-, Heatmap) ├── llm_integration.py # Ollama-Streaming-Integration ├── requirements.txt # Abhängigkeiten ├── README.md # Dokumentation mit "Deep Dive"-Lektionen └── sample_data/ ├── sample_bank_statement.csv └── sample_bank_format_2.csv
Wir werden jede Schicht Schritt für Schritt aufbauen.
Schritt 1: Aufbau einer robusten Datenvorverarbeitungspipeline
Die erste Lektion, die ich gelernt habe, war, dass reale Daten unordentlich sind. Verschiedene Banken exportieren CSVs in völlig unterschiedlichen Formaten. Chase Bank verwendet „Transaktionsdatum“ und „Betrag“. Bank of America verwendet „Datum“, „Zahlungsempfänger“ und separate Spalten für „Lastschrift“/“Gutschrift“. Moniepoint und OPay haben jeweils ihre eigenen Stile.
Eine Vorverarbeitungspipeline muss diese Unterschiede automatisch handhaben.
Automatische Erkennung von Spaltenzuordnungen
Ich baute ein Mustererkennungssystem, das Spalten unabhängig von den Benennungen identifiziert. Mithilfe von regulären Ausdrücken können wir unklare Spaltennamen den Standardfeldern zuordnen.
import re
COLUMN_PATTERNS = {
"date": [r"date", r"trans.*date", r"posting.*date"],
"description": [r"description", r"memo", r"payee", r"merchant"],
"amount": [r"^amount$", r"transaction.*amount"],
"debit": [r"debit", r"withdrawal", r"expense"],
"credit": [r"credit", r"deposit", r"income"],
}
def detect_column_mapping(df):
mapping = {}
for field, patterns in COLUMN_PATTERNS.items():
for col in df.columns:
for pattern in patterns:
if re.search(pattern, col.lower()):
mapping[field] = col
break
return mapping
Der entscheidende Einblick: Entwerfen Sie für Unterschiede, nicht für spezifische Formate. Dieser Ansatz funktioniert für jede CSV, die gängige Finanzbegriffe verwendet.
Normalisierung in ein Standard-Schema
Sobald die Spalten erkannt sind, normalisieren wir alles in eine konsistente Struktur. Beispielsweise müssen Banken, die Lastschriften und Gutschriften aufteilen, in eine einzige Betragskolonne kombiniert werden (negativ für Ausgaben, positiv für Einnahmen):
if "debit" in mapping and "credit" in mapping: debit = df[mapping["debit"]].apply(parse_amount).abs() * -1 credit = df[mapping["credit"]].apply(parse_amount).abs() normalized["amount"] = credit + debit
Wichtige Erkenntnis: Normalisieren Sie Ihre Daten so früh wie möglich. Es vereinfacht jede nachfolgende Operation, wie Feature Engineering, maschinelles Lernen und Visualisierung.
Abbildung 2: Der Vorverarbeitungsbericht zeigt, was die Pipeline erkannt hat und bietet den Benutzern Transparenz.
Schritt 2: Auswahl von maschinellen Lernmodellen für begrenzte Daten
Die zweite große Herausforderung sind begrenzte Trainingsdaten. Benutzer laden ihre eigenen Auszüge hoch, und es gibt kein großes gekennzeichnetes Dataset, um ein tiefes Lernmodell zu trainieren. Wir benötigen Algorithmen, die gut mit kleinen Proben arbeiten und mit einfachen Regeln ergänzt werden können.
Transaktionsklassifizierung: Ein hybrider Ansatz
Anstatt reines maschinelles Lernen zu verwenden, baute ich ein hybrides System:
- Regelbasierte Zuordnung für sichere Fälle (z.B. Schlüsselwörter wie „WALMART“ → Lebensmittel)
- Musterbasierte Rückfallstrategie für mehrdeutige Transaktionen
SPENDING_CATEGORIES = {
„groceries“: [„walmart“, „costco“, „whole foods“, „kroger“],
„dining“: [„restaurant“, „starbucks“, „mcdonald“, „doordash“],
„transportation“: [„uber“, „lyft“, „shell“, „chevron“, „gas“],
# … weitere Kategorien
}
def classify_transaction(description, amount):
for category, keywords in SPENDING_CATEGORIES.items():
if any(kw in description.lower() for kw in keywords):
return category
return „income“ if amount > 0 else „other“
Dieser Ansatz funktioniert sofort ohne Trainingsdaten und ist leicht für die Benutzer zu verstehen und anzupassen.
Anomalieerkennung: Warum Isolation Forest?
Um ungewöhnliche Ausgaben zu erkennen, benötigte ich einen Algorithmus, der:
- Mit kleinen Datensätzen arbeiten kann (im Gegensatz zu tiefem Lernen)
- Keine Annahmen über die Datenverteilung trifft (im Gegensatz zu statistischen Methoden wie Z-Score allein)
- Schnelle Vorhersagen für eine interaktive Benutzeroberfläche liefert
Isolation Forest von scikit-learn erfüllte alle Anforderungen. Er isoliert Anomalien, indem er die Daten zufällig partitioniert. Anomalien sind selten und unterschiedlich, sodass sie weniger Aufteilungen benötigen, um isoliert zu werden.
from sklearn.ensemble import IsolationForest detector = IsolationForest( contamination=0.05, # Erwartung ~5% Anomalien random_state=42 ) detector.fit(features) predictions = detector.predict(features) # -1 = Anomalie
Ich kombinierte dies auch mit einfachen Z-Score-Prüfungen, um offensichtliche Ausreißer zu erfassen. Ein Z-Score beschreibt die Position eines Rohwerts in Bezug auf seine Entfernung vom Mittelwert, gemessen in Standardabweichungen:
z = (x - μ) / σ
Der kombinierte Ansatz erfasst mehr Anomalien als jede Methode für sich allein.
Wichtige Erkenntnis: Manchmal übertreffen einfache, gut gewählte Algorithmen komplexe, insbesondere wenn Sie über begrenzte Daten verfügen.
Abbildung 3: Der Anomalieerkennungsalgorithmus kennzeichnet ungewöhnliche Transaktionen, die in der Zeitachse hervorgehoben werden.
Schritt 3: Gestaltung von Visualisierungen, die Fragen beantworten
Visualisierungen sollten Fragen beantworten, nicht nur Daten anzeigen. Ich verwendete Plotly für interaktive Diagramme, da es den Benutzern ermöglicht, die Daten selbst zu erkunden. Hier sind die Designprinzipien, die ich befolgte:
- Konsistente Farbgebung: Rot für Ausgaben, Grün für Einnahmen
- Kontext durch Vergleich: Einnahmen vs. Ausgaben nebeneinander anzeigen
- Progressive Offenlegung: Zuerst eine Zusammenfassung anzeigen, dann den Benutzern die Möglichkeit geben, tiefer einzutauchen
Beispielsweise verwendet die Ausgabenaufteilung ein Donut-Diagramm mit einem Loch in der Mitte für ein saubereres Aussehen:
import plotly.express as px fig = px.pie( category_totals, values="Amount", names="Category", hole=0.4, color_discrete_map=CATEGORY_COLORS )
Streamlit erleichtert es, diese Diagramme mit st.plotly_chart() hinzuzufügen und ein responsives Dashboard zu erstellen.
Abbildung 4: Mehrere Diagrammtypen bieten den Benutzern unterschiedliche Perspektiven auf dieselben Daten.
Schritt 4: Integration eines lokalen großen Sprachmodells für Einblicke in natürlicher Sprache
Das letzte Puzzlestück war die Generierung von menschenlesbaren Einblicken. Ich entschied mich, Ollama zu integrieren, ein Tool zum Ausführen von LLMs lokal. Warum lokal, anstatt OpenAI oder Claude zu kontaktieren?
- Datenschutz: Bankdaten verlassen niemals das Gerät.
- Kosten: Unbegrenzte Abfragen, keine API-Gebühren.
- Geschwindigkeit: Keine Netzwerkverzögerung (obwohl die Generierung einige Sekunden dauert).
Streaming für ein besseres Benutzererlebnis
LLMs können mehrere Sekunden benötigen, um eine Antwort zu generieren. Streamlit zeigt Tokens an, während sie eintreffen, was die Wartezeit kürzer erscheinen lässt. Hier ist eine einfache Implementierung mit Anfragen und Streaming:
import requests
import json
def generate(self, prompt):
response = requests.post(
f"{self.base_url}/api/generate",
json={"model": "llama3.2", "prompt": prompt, "stream": True},
stream=True
)
for line in response.iter_lines():
if line:
data = json.loads(line)
yield data.get("response", "")
In Streamlit können Sie dies mit st.write_stream() anzeigen.
st.write_stream(llm.get_overall_insights(df))
Prompt-Engineering für Finanzdaten
Der Schlüssel zu nützlichen LLM-Ausgaben ist ein strukturierter Prompt, der tatsächliche Daten enthält. Zum Beispiel:
prompt = f"""Analysieren Sie diese Finanzübersicht:
- Gesamteinnahmen: ${income:,.2f}
- Gesamtausgaben: ${expenses:,.2f}
- Top-Kategorie: {top_category}
- Größte Anomalie: {anomaly_desc}
Geben Sie 2-3 umsetzbare Empfehlungen basierend auf diesen Daten."""
Dies gibt dem Modell konkrete Zahlen, mit denen es arbeiten kann, was zu relevanteren Einblicken führt.
Abbildung 5: Die Upload-Oberfläche ist einfach; wählen Sie eine CSV-Datei aus und lassen Sie die KI den Rest erledigen.
Die Anwendung ausführen
Der Einstieg ist unkompliziert. Sie benötigen Python, und dann führen Sie Folgendes aus:
pip install -r requirements.txt # Optional, für KI-Einblicke ollama pull llama3.2 streamlit run app.py
Laden Sie eine beliebige Bank-CSV hoch (die App erkennt automatisch das Format), und innerhalb von Sekunden sehen Sie ein Dashboard mit kategorisierten Transaktionen, Anomalien und KI-generierten Einblicken. Entdecken Sie, wie Menschen 2026 mit KI innovative Einkommensquellen erschließen.
Fazit
Dieses Projekt lehrte mich, dass der Aufbau von etwas Funktionalem nur der Anfang ist. Das eigentliche Lernen geschah, als ich fragte, warum jedes Teil funktioniert:
- Warum Spalten automatisch erkennen? Weil reale Daten nicht Ihrem Schema folgen. Der Aufbau einer flexiblen Pipeline spart Stunden manueller Aufbereitung.
- Warum Isolation Forest? Weil kleine Datensätze Algorithmen benötigen, die für sie entwickelt wurden. Manchmal ist tiefes Lernen nicht notwendig.
- Warum lokale LLMs? Weil Datenschutz und Kosten in der Produktion wichtig sind. Lokale Modelle zu betreiben, ist jetzt praktisch und leistungsstark.
Diese Lektionen gelten weit über persönliche Finanzen hinaus, egal ob Sie Verkaufsdaten, Serverprotokolle oder wissenschaftliche Messungen analysieren. Die gleichen Prinzipien robuster Vorverarbeitung, pragmatischer Modellierung und datenschutzbewusster KI werden Ihnen in jedem Datenprojekt von Nutzen sein.
Der vollständige Quellcode ist auf GitHub verfügbar. Forken Sie ihn, erweitern Sie ihn und machen Sie ihn zu Ihrem eigenen. Wenn Sie etwas Interessantes damit entwickeln, würde ich mich freuen, davon zu hören. Abacus AI: Eine umfassende Analyse der Funktionen und Preisgestaltung der innovativen Plattform und Effiziente Python-Skripte zur Automatisierung der explorativen Datenanalyse.
„`
Bildquelle: ai-generated-gemini
