Update app.py

app.py

@@ -1,153 +1,68 @@
-
-from fastapi import FastAPI, HTTPException
-from pydantic import BaseModel, Field
+from fastapi import FastAPI
+from fastapi.responses import RedirectResponse
 import joblib
-import json
+import pandas as pd
 import numpy as np
-from datetime import datetime
-from typing import Optional
-import os
-from fastapi.responses import JSONResponse, RedirectResponse
+from pydantic import BaseModel
 
-# Initialisation
-app = FastAPI(
-    title="API Détection de Fraude",
-    docs_url="/docs",
-    redoc_url="/redoc",
-    description="API de détection de fraude dans les transactions bancaires",
-    version="1.0.0"
-)
+# 1. Configuration de l'API
+app = FastAPI(title="Fraud Detection API")
 
-# Chargement du modèle et des encodeurs
-model = joblib.load('fraud_model.pkl')
-le_category = joblib.load('le_category.pkl')
-le_gender = joblib.load('le_gender.pkl')
-le_state = joblib.load('le_state.pkl')
+# 2. Chargement du modèle (assure-toi que le nom correspond)
+model = joblib.load('ton_modele.pkl')
 
-with open('mappings.json', 'r') as f:
-    mappings = json.load(f)
+# 3. Redirection automatique vers /docs
+@app.get("/", include_in_schema=False)
+def root():
+    return RedirectResponse(url="/docs")
 
-# Modèle de données
+# 4. Schéma des données d'entrée
 class Transaction(BaseModel):
-    amt: float = Field(..., description="Montant de la transaction", example=125.50)
-    category: str = Field(..., description="Catégorie du marchand", example="personal_care")
-    merchant: str = Field(..., description="Nom du marchand", example="fraud_Kirlin and Sons")
-    trans_date_trans_time: str = Field(..., description="Date et heure", example="2020-06-21 12:14:25")
-    gender: str = Field(..., description="Genre (M/F)", example="M")
-    state: str = Field(..., description="État (code à 2 lettres)", example="SC")
-    lat: float = Field(..., description="Latitude du client", example=33.9659)
-    long: float = Field(..., description="Longitude du client", example=-80.9355)
-    city_pop: int = Field(..., description="Population de la ville", example=333497)
-    dob: str = Field(..., description="Date de naissance", example="1968-03-19")
-    merch_lat: float = Field(..., description="Latitude du marchand", example=33.986391)
-    merch_long: float = Field(..., description="Longitude du marchand", example=-81.200714)
-    cc_num: Optional[str] = Field(None, description="Numéro de carte (optionnel)")
-    avg_amt: Optional[float] = Field(50.0, description="Montant moyen historique")
-    std_amt: Optional[float] = Field(30.0, description="Écart-type historique")
-    nb_trans: Optional[int] = Field(10, description="Nombre de transactions historiques")
+    amt: float
+    trans_date_trans_time: str
+    dob: str
+    lat: float
+    long: float
+    merch_lat: float
+    merch_long: float
+    city_pop: float
+    category: str
+    gender: str
+    state: str
+    merchant: str
+    job: str
+    cc_num: int
 
-class PredictionResponse(BaseModel):
-    is_fraud: bool
-    fraud_probability: float
-    risk_level: str
-    details: dict
+# 5. Ta fonction de préparation (adaptée pour une seule ligne)
+def prepare_input(data: dict):
+    df = pd.DataFrame([data])
+    # Calculs rapides (similaires à ton make_features)
+    dt = pd.to_datetime(df["trans_date_trans_time"])
+    df["hour"], df["day_of_week"] = dt.dt.hour, dt.dt.dayofweek
+    df["day"], df["month"] = dt.dt.day, dt.dt.month
+    
+    dob = pd.to_datetime(df["dob"])
+    df["age"] = ((dt - dob).dt.days / 365.25).astype("float32")
+    
+    # Distance Haversine
+    lat1, lon1 = np.radians(df["lat"]), np.radians(df["long"])
+    lat2, lon2 = np.radians(df["merch_lat"]), np.radians(df["merch_long"])
+    d = np.sin((lat2-lat1)/2)**2 + np.cos(lat1)*np.cos(lat2)*np.sin((lon2-lon1)/2)**2
+    df["distance"] = (6371 * 2 * np.arcsin(np.sqrt(d))).astype("float32")
 
-# Routes
-@app.get("/")
-def root():
-    return RedirectResponse(url="/docs")
+    # Valeurs par défaut pour les agrégats (car une API reçoit souvent 1 seule transaction)
+    df["avg_amt"] = df["amt"] 
+    df["std_amt"] = 0.0
+    df["nb_trans"] = 1.0
 
-    
-@app.get("/categories")
-def get_categories():
-    return {
-        "categories": list(mappings['categories'].keys()),
-        "states": list(mappings['states'].keys()),
-        "genders": list(mappings['genders'].keys())
-    }
+    cols = ['amt', 'hour', 'day_of_week', 'day', 'month', 'age', 'lat', 'long', 
+            'city_pop', 'distance', 'avg_amt', 'std_amt', 'nb_trans', 
+            'category', 'gender', 'state', 'merchant', 'job']
+    return df[cols]
 
-@app.post("/predict", response_model=PredictionResponse)
-def predict_fraud(transaction: Transaction):
-    try:
-        # Parsing des dates
-        trans_dt = datetime.strptime(transaction.trans_date_trans_time, "%Y-%m-%d %H:%M:%S")
-        dob_dt = datetime.strptime(transaction.dob, "%Y-%m-%d")
-        
-        # Features temporelles
-        hour = trans_dt.hour
-        day_of_week = trans_dt.weekday()
-        day = trans_dt.day
-        month = trans_dt.month
-        age = (trans_dt - dob_dt).days // 365
-        
-        # Distance
-        distance = np.sqrt(
-            (transaction.lat - transaction.merch_lat)**2 + 
-            (transaction.long - transaction.merch_long)**2
-        ) * 111
-        
-        # Encodage
-        if transaction.category not in mappings['categories']:
-            raise HTTPException(400, f"Catégorie inconnue: {transaction.category}")
-        if transaction.gender not in mappings['genders']:
-            raise HTTPException(400, f"Genre inconnu: {transaction.gender}")
-        if transaction.state not in mappings['states']:
-            raise HTTPException(400, f"État inconnu: {transaction.state}")
-        
-        category_encoded = mappings['categories'][transaction.category]
-        gender_encoded = mappings['genders'][transaction.gender]
-        state_encoded = mappings['states'][transaction.state]
-        
-        # Construction du vecteur de features
-        features = np.array([[
-            transaction.amt,
-            hour,
-            day_of_week,
-            day,
-            month,
-            age,
-            category_encoded,
-            gender_encoded,
-            state_encoded,
-            transaction.lat,
-            transaction.long,
-            transaction.city_pop,
-            distance,
-            transaction.avg_amt,
-            transaction.std_amt,
-            transaction.nb_trans
-        ]])
-        
-        # Prédiction
-        fraud_proba = model.predict_proba(features)[0][1]
-        is_fraud = fraud_proba > 0.5
-        
-        # Niveau de risque
-        if fraud_proba < 0.3:
-            risk_level = "Faible"
-        elif fraud_proba < 0.7:
-            risk_level = "Moyen"
-        else:
-            risk_level = "Élevé"
-        
-        return PredictionResponse(
-            is_fraud=bool(is_fraud),
-            fraud_probability=float(fraud_proba),
-            risk_level=risk_level,
-            details={
-                "montant": transaction.amt,
-                "categorie": transaction.category,
-                "heure": hour,
-                "age_client": age,
-                "distance_km": round(distance, 2)
-            }
-        )
-        
-    except ValueError as e:
-        raise HTTPException(status_code=400, detail=f"Erreur de format: {str(e)}")
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Erreur interne: {str(e)}")
+@app.post("/predict")
+def predict(data: Transaction):
+    X = prepare_input(data.dict())
+    prediction = model.predict(X)
+    return {"is_fraud": int(prediction[0])}
 
-if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)