Kreditgenehmigungsvorhersage mit Python: Ein umfassendes Tutorial für INT303 Big Data Analysis

Kreditgenehmigungsvorhersage mit Python: Ein umfassendes Tutorial für INT303 Big Data Analysis

Stell dir vor, du arbeitest als Data Scientist bei einem FinTech-Startup. Dein Team entwickelt eine KI, die blitzschnell entscheidet, ob ein Kredit bewilligt wird – ähnlich wie TikTok-Algorithmen entscheiden, welcher Video-Clip viral geht. Genau das ist die Aufgabe in deinem INT303 Coding Project 2: Loan Approval Prediction. In diesem Tutorial zeige ich dir Schritt für Schritt, wie du mit Python und Machine Learning eine zuverlässige Kreditgenehmigungsvorhersage baust. Wir nutzen aktuelle Tools wie Pandas, Scikit-learn und XGBoost – und alles ist auf Deutsch erklärt.

Warum ist Kreditgenehmigungsvorhersage wichtig?

Jede Sekunde werden weltweit tausende Kreditanfragen gestellt – fürs Studium, ein neues Smartphone oder ein Eigenheim. Banken und FinTechs wie Klarna oder N26 müssen schnell und fair entscheiden. Eine gute Vorhersage spart Geld und schützt vor Ausfällen. Gleichzeitig muss das Modell transparent sein – schließlich darf die KI niemanden diskriminieren. In deinem Projekt lernst du genau diese Balance zwischen Genauigkeit und Fairness.

1. Exploratory Data Analysis (EDA) – Daten verstehen

Bevor wir Modelle bauen, müssen wir den Datensatz verstehen. Der Datensatz loan_approval_dataset_copy.csv enthält typische Merkmale wie Einkommen, Kredithöhe, CIBIL-Score und Vermögenswerte. Lade die Daten mit Pandas:

import pandas as pd
df = pd.read_csv('loan_approval_dataset_copy.csv')
df.head()

Überprüfe Datentypen und fehlende Werte mit df.info(). Fehlen Daten? Kein Problem – wir lernen später, damit umzugehen.

Univariate Analyse: Verteilungen checken

Erstelle Histogramme für numerische Merkmale wie income_annum und loan_amount. Nutze matplotlib oder seaborn. Achte auf Schiefe oder Ausreißer – zum Beispiel wenn jemand ein Jahreseinkommen von 10 Millionen hat, könnte das ein Fehler sein. Für kategoriale Merkmale wie education oder self_employed helfen Balkendiagramme.

import matplotlib.pyplot as plt
import seaborn as sns

plt.figure(figsize=(10,4))
sns.histplot(df['income_annum'], bins=30, kde=True)
plt.title('Verteilung des Jahreseinkommens')
plt.show()

Bivariate Analyse: Zusammenhänge entdecken

Jetzt wird es spannend: Wie hängen die Merkmale mit der Zielvariable loan_status zusammen? Ein CIBIL-Score über 750 führt meist zur Genehmigung – ähnlich wie ein hoher Karma-Wert auf Reddit Vertrauen schafft. Erstelle Boxplots für numerische Merkmale nach Status:

sns.boxplot(x='loan_status', y='cibil_score', data=df)
plt.title('CIBIL-Score nach Kreditstatus')
plt.show()

Für kategoriale Merkmale nutze gestapelte Balken. Ein Heatmap der Korrelationen zeigt, welche Features stark zusammenhängen – zum Beispiel income_annum und loan_amount.

2. Datenbereinigung und Feature Engineering

Fehlende Werte können wir mit dem Median oder Mittelwert füllen – oder mit einem KI-gestützten Imputer. Ausreißer erkennst du mit der IQR-Methode oder Z-Scores. Aber Vorsicht: Nicht jeder Ausreißer ist ein Fehler – ein hohes Einkommen kann echt sein.

Feature Engineering: Neue Merkmale erschaffen

Kreiere mindestens zwei neue Features, die die Vorhersage verbessern. Zum Beispiel:

• Schuldenquote (Debt-to-Income Ratio): loan_amount / income_annum – hohe Quote = höheres Risiko.
• Gesamtvermögen: Summe aller Assets (residential_assets_value + commercial_assets_value + luxury_assets_value + bank_asset_value). Vermögende Kunden sind oft kreditwürdiger.

df['debt_to_income'] = df['loan_amount'] / df['income_annum']
df['total_assets'] = df['residential_assets_value'] + df['commercial_assets_value'] + df['luxury_assets_value'] + df['bank_asset_value']

Kodierung und Skalierung

Kategoriale Merkmale wie education und self_employed müssen in Zahlen umgewandelt werden. Nutze One-Hot-Encoding oder Label-Encoding. Numerische Merkmale skaliere mit StandardScaler, damit alle Features die gleiche Wichtigkeit haben – sonst dominiert das Einkommen den CIBIL-Score.

from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.compose import ColumnTransformer

preprocessor = ColumnTransformer(
    transformers=[
        ('num', StandardScaler(), numerical_cols),
        ('cat', OneHotEncoder(), categorical_cols)
    ])

3. Modellentwicklung und Evaluierung

Jetzt kommt der Herzschlag des Projekts: Wir trainieren drei Modelle und vergleichen ihre Leistung. Typische Kandidaten sind Logistische Regression, Random Forest und XGBoost. Teile die Daten in 70% Training und 30% Test.

Hyperparameter-Tuning

Mit GridSearchCV finden wir die besten Einstellungen – zum Beispiel die Tiefe eines Entscheidungsbaums. Das ist wie beim Gaming: Du stellst die Grafikoptionen ein, bis das Spiel flüssig läuft. Ohne Tuning läuft das Modell suboptimal.

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import GridSearchCV

param_grid = {'n_estimators': [100, 200], 'max_depth': [10, 20]}
grid = GridSearchCV(RandomForestClassifier(), param_grid, cv=5)
grid.fit(X_train, y_train)

Evaluierungsmetriken

Die Genauigkeit (Accuracy) allein reicht nicht – besonders wenn die Klassen unbalanciert sind. Schau auf Precision, Recall, F1-Score und die ROC-AUC. Eine Confusion-Matrix zeigt, wie viele Kredite fälschlich abgelehnt oder bewilligt wurden. Denk an die Geschäftskosten: Eine falsche Genehmigung kostet Geld, eine falsche Ablehnung verärgert Kunden.

from sklearn.metrics import classification_report, confusion_matrix, roc_auc_score

y_pred = grid.predict(X_test)
print(classification_report(y_test, y_pred))
print('ROC-AUC:', roc_auc_score(y_test, grid.predict_proba(X_test)[:,1]))

Modellvergleich

Vergleiche die Modelle in einer Tabelle. Oft gewinnt XGBoost, aber Logistische Regression ist einfacher zu interpretieren – was für den Geschäftsbericht wichtig ist. Random Forest liegt dazwischen. Wähle das Modell, das die beste Balance aus Genauigkeit und Interpretierbarkeit bietet.

4. Ergebnisse interpretieren und Bericht schreiben

Dein Jupyter Notebook ist fertig, aber der Professor will auch einen Executive Summary Report. Erkläre, welche Features den größten Einfluss hatten – oft der CIBIL-Score und die Schuldenquote. Visualisiere die Feature-Wichtigkeit aus dem Random Forest. Zeige, dass dein Modell fair ist: Überprüfe, ob die Vorhersage unabhängig von Bildung oder Selbstständigkeit ist.

Trends und reale Anwendungen

FinTechs wie Klarna oder Affirm nutzen ähnliche Modelle für „Buy now, pay later“-Entscheidungen. Auch im Gaming-Bereich: Wenn du dir Ingame-Währung leihen willst, checkt die KI deine Spielhistorie. Dein Projekt bereitet dich auf solche Jobs vor – und auf die nächste Bitcoin-Rallye, bei der Kredite schnell bewilligt werden müssen.

Fazit

In diesem Tutorial hast du gelernt, wie man mit Python eine Kreditgenehmigungsvorhersage von der Datenbereinigung bis zur Modellinterpretation umsetzt. Du kennst jetzt die wichtigsten Schritte für dein INT303 Coding Project 2: EDA, Feature Engineering, Modellauswahl und Evaluierung. Viel Erfolg bei deiner Abgabe – und denk dran: Eine gute KI entscheidet fair und transparent.

„Big Data ist wie Teenager-Sex: Jeder redet darüber, keiner weiß genau, wie es geht, aber alle denken, alle anderen machen es.“ – Dan Ariely. Mit deinem Projekt gehörst du zu denen, die es wirklich können.