Aufbau eines Echtzeit-Systems zur Erkennung von Kreditkartenbetrug mit FastAPI und maschinellem Lernen

Einführung

Kreditkartenbetrug stellt eine erhebliche Bedrohung für die Finanzbranche dar und führt jedes Jahr zu Verlusten in Milliardenhöhe. Um dem entgegenzuwirken, wurden Modelle des maschinellen Lernens entwickelt, um betrügerische Transaktionen in Echtzeit zu erkennen und zu verhindern. In diesem Artikel gehen wir durch den Prozess des Aufbaus eines Echtzeit-Systems zur Erkennung von Kreditkartenbetrug mithilfe von FastAPI, einem modernen Web-Framework für Python und einem Random Forest-Klassifikator, der auf dem beliebten Datensatz zur Erkennung von Kreditkartenbetrug von Kaggle trainiert wurde.

Überblick über das Projekt

Ziel dieses Projekts ist die Schaffung eines Webdienstes, der die Wahrscheinlichkeit einer betrügerischen Kreditkartentransaktion vorhersagt. Der Dienst akzeptiert Transaktionsdaten, verarbeitet sie vor und gibt eine Vorhersage zusammen mit der Betrugswahrscheinlichkeit zurück. Dieses System ist so konzipiert, dass es schnell, skalierbar und einfach in bestehende Finanzsysteme zu integrieren ist.

Schlüsselkomponenten

1. Modell für maschinelles Lernen: Ein Random-Forest-Klassifikator, der darauf trainiert ist, zwischen betrügerischen und legitimen Transaktionen zu unterscheiden.
2. Datenvorverarbeitung: Standardisierung von Transaktionsfunktionen, um sicherzustellen, dass das Modell optimal funktioniert.
3. API: Eine mit FastAPI erstellte RESTful-API zur Verarbeitung von Vorhersageanfragen in Echtzeit.

Schritt 1: Vorbereiten des Datensatzes

Der in diesem Projekt verwendete Datensatz ist der Credit Card Fraud Detection Dataset von Kaggle, der 284.807 Transaktionen enthält, von denen nur 492 betrügerisch sind. Dieses Klassenungleichgewicht stellt eine Herausforderung dar, die jedoch durch eine Überabtastung der Minderheitsklasse angegangen werden kann.

Datenvorverarbeitung

Die Funktionen werden zunächst mit einem StandardScaler von scikit-learn standardisiert. Der Datensatz wird dann in Trainings- und Testsätze aufgeteilt. Angesichts des Ungleichgewichts wird die RandomOverSampler-Technik angewendet, um die Klassen auszugleichen, bevor das Modell trainiert wird.

from sklearn.preprocessing import StandardScaler
from imblearn.over_sampling import RandomOverSampler

# Standardize features
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Balance the dataset
ros = RandomOverSampler(random_state=42)
X_resampled, y_resampled = ros.fit_resample(X_scaled, y)

Schritt 2: Trainieren des Modells für maschinelles Lernen

Wir trainieren einen Random Forest-Klassifikator, der sich gut für den Umgang mit unausgeglichenen Datensätzen eignet und robuste Vorhersagen liefert. Das Modell wird anhand der überabgetasteten Daten trainiert und seine Leistung anhand von Genauigkeit, Präzision, Rückruf und der AUC-ROC-Kurve bewertet.

from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report, roc_auc_score

# Train the model
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_resampled, y_resampled)

# Evaluate the model
y_pred = model.predict(X_test_scaled)
print(classification_report(y_test, y_pred))
print("AUC-ROC:", roc_auc_score(y_test, model.predict_proba(X_test_scaled)[:, 1]))

Schritt 3: Erstellen der FastAPI-Anwendung

Nachdem das trainierte Modell und der Skalierer mit joblib gespeichert wurden, fahren wir mit der Erstellung der FastAPI-Anwendung fort. FastAPI wurde aufgrund seiner Geschwindigkeit und Benutzerfreundlichkeit ausgewählt und ist daher ideal für Echtzeitanwendungen.

Erstellen der API

Die FastAPI-Anwendung definiert einen POST-Endpunkt /predict/, der Transaktionsdaten akzeptiert, verarbeitet und die Vorhersage und Wahrscheinlichkeit des Modells zurückgibt.

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import joblib
import pandas as pd

# Load the trained model and scaler
model = joblib.load("random_forest_model.pkl")
scaler = joblib.load("scaler.pkl")

app = FastAPI()

class Transaction(BaseModel):
    V1: float
    V2: float
    # Include all other features used in your model
    Amount: float

@app.post("/predict/")
def predict(transaction: Transaction):
    try:
        data = pd.DataFrame([transaction.dict()])
        scaled_data = scaler.transform(data)
        prediction = model.predict(scaled_data)
        prediction_proba = model.predict_proba(scaled_data)
        return {"fraud_prediction": int(prediction[0]), "probability": float(prediction_proba[0][1])}
    except Exception as e:
        raise HTTPException(status_code=400, detail=str(e))

Schritt 4: Bereitstellen der Anwendung

Um die Anwendung lokal zu testen, können Sie den FastAPI-Server mit uvicorn ausführen und POST-Anfragen an den Endpunkt /predict/ senden. Der Dienst verarbeitet eingehende Anfragen, skaliert die Daten und gibt zurück, ob die Transaktion betrügerisch ist.

Lokales Ausführen der API

uvicorn main:app --reload

Sie können die API dann mit Curl oder einem Tool wie Postman testen:

curl -X POST http://127.0.0.1:8000/predict/ \
-H "Content-Type: application/json" \
-d '{"V1": -1.359807134, "V2": -0.072781173, ..., "Amount": 149.62}'

Die API gibt ein JSON-Objekt mit der Betrugsvorhersage und der zugehörigen Wahrscheinlichkeit zurück.

Abschluss

In diesem Artikel haben wir ein Echtzeit-System zur Erkennung von Kreditkartenbetrug entwickelt, das maschinelles Lernen mit einem modernen Web-Framework kombiniert. Der Github-Link ist hier. Das System ist darauf ausgelegt, Transaktionsdaten in Echtzeit zu verarbeiten und sofortige Vorhersagen zu liefern, was es zu einem wertvollen Werkzeug für Finanzinstitute macht, die Betrug bekämpfen möchten.

Durch die Bereitstellung dieses Modells mithilfe von FastAPI stellen wir sicher, dass der Dienst nicht nur schnell, sondern auch skalierbar ist und mehrere Anfragen gleichzeitig bearbeiten kann. Dieses Projekt kann durch ausgefeiltere Modelle, verbessertes Feature-Engineering oder die Integration in eine Produktionsumgebung weiter erweitert werden.

Nächste Schritte

Um das System weiter zu verbessern, berücksichtigen Sie Folgendes:

1. Modellverbesserungen: Experimentieren Sie mit fortgeschritteneren Modellen wie XGBoost oder neuronalen Netzen.
2. Feature Engineering: Entdecken Sie zusätzliche Funktionen, die die Modellgenauigkeit verbessern könnten.
3. Realweltbereitstellung: Stellen Sie die Anwendung auf Cloud-Plattformen wie AWS oder GCP für den Produktionseinsatz bereit.

Das obige ist der detaillierte Inhalt vonAufbau eines Echtzeit-Systems zur Erkennung von Kreditkartenbetrug mit FastAPI und maschinellem Lernen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!