Heim > Artikel > Backend-Entwicklung > Aufbau eines Echtzeit-Systems zur Erkennung von Kreditkartenbetrug mit FastAPI und maschinellem Lernen
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.
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.
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.
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)
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]))
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.
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))
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.
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.
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.
Um das System weiter zu verbessern, berücksichtigen Sie Folgendes:
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!