upload files

Dockerfile

@@ -0,0 +1,12 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE 7860
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,69 @@
+---
+title: Fraud Detection API
+emoji: 🛡️
+colorFrom: red
+colorTo: blue
+sdk: docker
+pinned: false
+license: mit
+---
+
+# 🛡️ API de Détection de Fraude
+
+API de détection de fraude dans les transactions bancaires utilisant un modèle Random Forest.
+
+## 🚀 Utilisation
+
+### Endpoint principal: `/predict`
+```bash
+curl -X POST "https://votre-space.hf.space/predict" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "amt": 125.50,
+    "category": "personal_care",
+    "merchant": "fraud_Kirlin and Sons",
+    "trans_date_trans_time": "2020-06-21 12:14:25",
+    "gender": "M",
+    "state": "SC",
+    "lat": 33.9659,
+    "long": -80.9355,
+    "city_pop": 333497,
+    "dob": "1968-03-19",
+    "merch_lat": 33.986391,
+    "merch_long": -81.200714
+  }'
+```
+
+### Réponse
+```json
+{
+  "is_fraud": false,
+  "fraud_probability": 0.23,
+  "risk_level": "Faible",
+  "details": {
+    "montant": 125.50,
+    "categorie": "personal_care",
+    "heure": 12,
+    "age_client": 52,
+    "distance_km": 25.4
+  }
+}
+```
+
+## 📊 Endpoints disponibles
+
+- `GET /` - Informations sur l'API
+- `GET /health` - État de santé
+- `GET /categories` - Liste des catégories valides
+- `POST /predict` - Prédiction de fraude
+- `GET /docs` - Documentation interactive (Swagger)
+
+## 🔧 Modèle
+
+- **Algorithme**: Random Forest Classifier
+- **Features**: 16 caractéristiques (montant, heure, distance, historique client...)
+- **Performance**: AUC-ROC > 0.95
+
+## 📝 Licence
+
+MIT

app.py

@@ -0,0 +1,166 @@
+
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel, Field
+import joblib
+import json
+import numpy as np
+from datetime import datetime
+from typing import Optional
+import os
+
+# Initialisation
+app = FastAPI(
+    title="API Détection de Fraude",
+    description="API de détection de fraude dans les transactions bancaires",
+    version="1.0.0"
+)
+
+# 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')
+
+with open('mappings.json', 'r') as f:
+    mappings = json.load(f)
+
+# Modèle de données
+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")
+
+class PredictionResponse(BaseModel):
+    is_fraud: bool
+    fraud_probability: float
+    risk_level: str
+    details: dict
+
+# Routes
+@app.get("/")
+def read_root():
+    return {
+        "message": "API de Détection de Fraude",
+        "version": "1.0.0",
+        "endpoints": {
+            "/predict": "POST - Prédire une transaction",
+            "/health": "GET - Statut de l'API",
+            "/categories": "GET - Liste des catégories",
+            "/docs": "GET - Documentation interactive"
+        }
+    }
+
+@app.get("/health")
+def health_check():
+    return {
+        "status": "healthy",
+        "model_loaded": model is not None,
+        "timestamp": datetime.now().isoformat()
+    }
+
+@app.get("/categories")
+def get_categories():
+    return {
+        "categories": list(mappings['categories'].keys()),
+        "states": list(mappings['states'].keys()),
+        "genders": list(mappings['genders'].keys())
+    }
+
+@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)}")
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)

mappings.json

@@ -0,0 +1,92 @@
+{
+  "categories": {
+    "entertainment": 0,
+    "food_dining": 1,
+    "gas_transport": 2,
+    "grocery_net": 3,
+    "grocery_pos": 4,
+    "health_fitness": 5,
+    "home": 6,
+    "kids_pets": 7,
+    "misc_net": 8,
+    "misc_pos": 9,
+    "personal_care": 10,
+    "shopping_net": 11,
+    "shopping_pos": 12,
+    "travel": 13
+  },
+  "genders": {
+    "F": 0,
+    "M": 1
+  },
+  "states": {
+    "AK": 0,
+    "AL": 1,
+    "AR": 2,
+    "AZ": 3,
+    "CA": 4,
+    "CO": 5,
+    "CT": 6,
+    "DC": 7,
+    "FL": 8,
+    "GA": 9,
+    "HI": 10,
+    "IA": 11,
+    "ID": 12,
+    "IL": 13,
+    "IN": 14,
+    "KS": 15,
+    "KY": 16,
+    "LA": 17,
+    "MA": 18,
+    "MD": 19,
+    "ME": 20,
+    "MI": 21,
+    "MN": 22,
+    "MO": 23,
+    "MS": 24,
+    "MT": 25,
+    "NC": 26,
+    "ND": 27,
+    "NE": 28,
+    "NH": 29,
+    "NJ": 30,
+    "NM": 31,
+    "NV": 32,
+    "NY": 33,
+    "OH": 34,
+    "OK": 35,
+    "OR": 36,
+    "PA": 37,
+    "RI": 38,
+    "SC": 39,
+    "SD": 40,
+    "TN": 41,
+    "TX": 42,
+    "UT": 43,
+    "VA": 44,
+    "VT": 45,
+    "WA": 46,
+    "WI": 47,
+    "WV": 48,
+    "WY": 49
+  },
+  "features": [
+    "amt",
+    "hour",
+    "day_of_week",
+    "day",
+    "month",
+    "age",
+    "category_encoded",
+    "gender_encoded",
+    "state_encoded",
+    "lat",
+    "long",
+    "city_pop",
+    "distance",
+    "avg_amt",
+    "std_amt",
+    "nb_trans"
+  ]
+}

model_pkl/fraud_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:42d2fa79a92b4b2268e5b4c8816df246c5ff7e9310bc36ad09780ddad495f420
+size 3633545

model_pkl/le_category.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:109f0b498d8a270af6195f17d6e9116fe3bfe8fe7af72497162807f4dfa01f94
+size 660

model_pkl/le_gender.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1b8403e7d7f991dc10fe2aa945dfaad26b29d26bd103f081f1c6086deb036368
+size 481

model_pkl/le_state.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c7f746d39c9ad90215b3ac088e59c6b4a04e58ef602131ab6fb45216e64a1245
+size 723

requirements.txt

@@ -0,0 +1,7 @@
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+pydantic==2.5.0
+scikit-learn==1.3.2
+joblib==1.3.2
+numpy==1.24.3
+pandas==2.1.3

train_and_save_model.py

@@ -0,0 +1,115 @@
+import pandas as pd
+import numpy as np
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler, LabelEncoder
+from sklearn.ensemble import RandomForestClassifier
+import joblib
+import json
+
+print("Chargement et préparation des données...")
+
+# Chargement des données
+df = pd.read_csv('/mnt/c/Users/david/Desktop/AIA 2025/BLOC_3_AUTOMATIC_FRAUD_DETECTION/fraudTest.csv', index_col=0)
+
+# Feature Engineering
+data = df.copy()
+data['trans_date_trans_time'] = pd.to_datetime(data['trans_date_trans_time'])
+data['hour'] = data['trans_date_trans_time'].dt.hour
+data['day_of_week'] = data['trans_date_trans_time'].dt.dayofweek
+data['day'] = data['trans_date_trans_time'].dt.day
+data['month'] = data['trans_date_trans_time'].dt.month
+
+data['dob'] = pd.to_datetime(data['dob'])
+data['age'] = (data['trans_date_trans_time'] - data['dob']).dt.days // 365
+
+data['distance'] = np.sqrt(
+    (data['lat'] - data['merch_lat'])**2 + 
+    (data['long'] - data['merch_long'])**2
+) * 111
+
+# Encodage
+le_category = LabelEncoder()
+le_gender = LabelEncoder()
+le_state = LabelEncoder()
+
+data['category_encoded'] = le_category.fit_transform(data['category'])
+data['gender_encoded'] = le_gender.fit_transform(data['gender'])
+data['state_encoded'] = le_state.fit_transform(data['state'])
+
+# Statistiques par client
+client_stats = data.groupby('cc_num').agg({
+    'amt': ['mean', 'std', 'count'],
+    'is_fraud': 'sum'
+}).reset_index()
+client_stats.columns = ['cc_num', 'avg_amt', 'std_amt', 'nb_trans', 'nb_fraud']
+client_stats['std_amt'] = client_stats['std_amt'].fillna(0)
+data = data.merge(client_stats, on='cc_num', how='left')
+
+# Préparation des features
+features = [
+    'amt', 'hour', 'day_of_week', 'day', 'month', 'age',
+    'category_encoded', 'gender_encoded', 'state_encoded',
+    'lat', 'long', 'city_pop', 'distance',
+    'avg_amt', 'std_amt', 'nb_trans'
+]
+
+X = data[features].fillna(0)
+y = data['is_fraud']
+
+# Split et entraînement
+X_train, X_test, y_train, y_test = train_test_split(
+    X, y, test_size=0.3, random_state=42, stratify=y
+)
+
+print("Entraînement du Random Forest...")
+model = RandomForestClassifier(
+    n_estimators=100, 
+    max_depth=10, 
+    random_state=42, 
+    n_jobs=-1
+)
+model.fit(X_train, y_train)
+
+# Évaluation
+from sklearn.metrics import roc_auc_score, classification_report
+y_pred_proba = model.predict_proba(X_test)[:, 1]
+auc = roc_auc_score(y_test, y_pred_proba)
+print(f"\nAUC-ROC: {auc:.4f}")
+
+# Sauvegarde du modèle et des encodeurs
+print("\nSauvegarde du modèle et des encodeurs...")
+joblib.dump(model, 'fraud_model.pkl')
+joblib.dump(le_category, 'le_category.pkl')
+joblib.dump(le_gender, 'le_gender.pkl')
+joblib.dump(le_state, 'le_state.pkl')
+
+# Sauvegarde des mappings pour l'API
+category_mapping = dict(zip(le_category.classes_, le_category.transform(le_category.classes_)))
+gender_mapping = dict(zip(le_gender.classes_, le_gender.transform(le_gender.classes_)))
+state_mapping = dict(zip(le_state.classes_, le_state.transform(le_state.classes_)))
+
+mappings = {
+    'categories': category_mapping,
+    'genders': gender_mapping,
+    'states': state_mapping,
+    'features': features
+}
+
+def convert(o):
+    if isinstance(o, np.integer):
+        return int(o)
+    elif isinstance(o, np.floating):
+        return float(o)
+    elif isinstance(o, np.ndarray):
+        return o.tolist()
+    else:
+        return o
+
+with open('mappings.json', 'w') as f:
+    json.dump(mappings, f, indent=2, default=convert)
+
+print("\n✅ Modèle sauvegardé avec succès!")
+print("Fichiers créés:")
+print("  - fraud_model.pkl")
+print("  - le_category.pkl, le_gender.pkl, le_state.pkl")
+print("  - mappings.json")