Création d'un système de détection de fraude par carte de crédit en temps réel avec FastAPI et Machine Learning

Introduction

La fraude par carte de crédit constitue une menace importante pour le secteur financier, entraînant des milliards de dollars de pertes chaque année. Pour lutter contre cela, des modèles d’apprentissage automatique ont été développés pour détecter et prévenir les transactions frauduleuses en temps réel. Dans cet article, nous expliquerons le processus de création d'un système de détection de fraude par carte de crédit en temps réel à l'aide de FastAPI, un framework Web moderne pour Python et un classificateur Random Forest formé sur le populaire ensemble de données de détection de fraude par carte de crédit de Kaggle. 🎜>

Aperçu du projet

Le but de ce projet est de créer un service Web qui prédit la probabilité qu'une transaction par carte de crédit soit frauduleuse. Le service accepte les données de transaction, les prétraite et renvoie une prédiction ainsi que la probabilité de fraude. Ce système est conçu pour être rapide, évolutif et facile à intégrer dans les systèmes financiers existants.

Composants clés

1. Modèle d'apprentissage automatique : un classificateur de forêt aléatoire formé pour faire la distinction entre les transactions frauduleuses et légitimes.
2. Prétraitement des données : standardisation des fonctionnalités de transaction pour garantir un fonctionnement optimal du modèle.
3. API : une API RESTful construite avec FastAPI pour gérer les demandes de prédiction en temps réel.

Étape 1 : préparation de l'ensemble de données

L'ensemble de données utilisé dans ce projet est l'ensemble de données de détection de fraude par carte de crédit de Kaggle, qui contient 284 807 transactions, dont seulement 492 sont frauduleuses. Ce déséquilibre de classe présente un défi, mais il est résolu en suréchantillonnant la classe minoritaire.

Prétraitement des données

Les fonctionnalités sont d'abord standardisées à l'aide d'un StandardScaler de scikit-learn. L'ensemble de données est ensuite divisé en ensembles de formation et de test. Compte tenu du déséquilibre, la technique RandomOverSampler est appliquée pour équilibrer les classes avant d'entraîner le modèle.

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)

Étape 2 : formation du modèle d'apprentissage automatique

Nous formons un classificateur Random Forest, qui est bien adapté à la gestion d'ensembles de données déséquilibrés et fournit des prédictions robustes. Le modèle est entraîné sur les données suréchantillonnées et ses performances sont évaluées à l'aide de l'exactitude, de la précision, du rappel et de la courbe AUC-ROC.

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]))

Étape 3 : Création de l'application FastAPI

Avec le modèle entraîné et le scaler enregistrés à l'aide de joblib, nous passons à la création de l'application FastAPI. FastAPI est choisi pour sa rapidité et sa facilité d'utilisation, ce qui le rend idéal pour les applications en temps réel.

Création de l'API

L'application FastAPI définit un point de terminaison POST /predict/ qui accepte les données de transaction, les traite et renvoie la prédiction et la probabilité du modèle.

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))

Étape 4 : Déployer l'application

Pour tester l'application localement, vous pouvez exécuter le serveur FastAPI à l'aide d'uvicorn et envoyer des requêtes POST au point de terminaison /predict/. Le service traitera les demandes entrantes, mettra à l'échelle les données et indiquera si la transaction est frauduleuse.

Exécuter l'API localement

uvicorn main:app --reload

Vous pouvez ensuite tester l'API en utilisant curl ou un outil comme Postman :

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}'

L'API renverra un objet JSON avec la prédiction de fraude et la probabilité associée.

Conclusion

Dans cet article, nous avons construit un système de détection de fraude par carte de crédit en temps réel qui combine l'apprentissage automatique avec un framework Web moderne. Le lien github est ici. Le système est conçu pour traiter les données de transaction en temps réel et fournir des prévisions instantanées, ce qui en fait un outil précieux pour les institutions financières cherchant à lutter contre la fraude.

En déployant ce modèle à l'aide de FastAPI, nous garantissons que le service est non seulement rapide mais également évolutif, capable de traiter plusieurs requêtes simultanément. Ce projet peut être étendu avec des modèles plus sophistiqués, une ingénierie de fonctionnalités améliorée ou une intégration avec un environnement de production.

Prochaines étapes

Pour améliorer davantage le système, considérez les éléments suivants :

1. Améliorations du modèle : Expérimentez avec des modèles plus avancés comme XGBoost ou les réseaux de neurones.
2. Ingénierie des fonctionnalités : explorez des fonctionnalités supplémentaires susceptibles d'améliorer la précision du modèle.
3. Déploiement dans le monde réel : déployez l'application sur des plateformes cloud comme AWS ou GCP pour une utilisation en production.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!