pylord/API-BFSI
0
1from fastapi import FastAPI, Depends, HTTPException2from fastapi.middleware.cors import CORSMiddleware3from sqlalchemy.orm import Session4from sqlalchemy import func, extract5from database import Base, engine, SessionLocal6from models import User, Prediction7from schemas import (8 UserCreate,9 UserLogin,10 PredictRequest,11 PredictResponse,12 TransactionHistoryResponse,13 AnalyticsResponse,14 MetricsResponse,15 BulkPredictRequest,16 BulkPredictResult,17 BulkPredictResponse18)19 20from utils.features import derive_features_auto21from utils.auth import hash_password, verify_password22from utils.hf_model import generate_explanation23from datetime import datetime, timedelta24from catboost import CatBoostClassifier25import pandas as pd26import numpy as np27from typing import List28from collections import defaultdict29import time30from typing import Dict, List, Any31# ------------------ FASTAPI APP ------------------32app = FastAPI(33 title="RiskShield Fraud Detection API",34 description="AI-powered fraud detection system with hybrid rule-based and ML approach",35 version="1.0.0"36)37 38# CORS Configuration39origins = [40 "http://127.0.0.1:5500",41 "http://localhost:5500",42 "http://localhost:3000",43 "http://127.0.0.1:3000"44]45 46app.add_middleware(47 CORSMiddleware,48 allow_origins=origins,49 allow_credentials=True,50 allow_methods=["*"],51 allow_headers=["*"],52)53 54# Create tables if not existing55Base.metadata.create_all(bind=engine)56 57# ------------------ LOAD MODEL ------------------58model_path = "model/catboost_fraud_model_balanced_tuned.cbm"59cat_model = CatBoostClassifier()60try:61 cat_model.load_model(model_path)62 print("✅ Model loaded successfully")63except Exception as e:64 print(f"⚠️ Warning: Could not load model - {e}")65 cat_model = None66 67 68# ------------------ DB SESSION DEPENDENCY ------------------69def get_db():70 db = SessionLocal()71 try:72 yield db73 finally:74 db.close()75 76 77# ------------------ HEALTH CHECK ------------------78@app.get("/api/health")79def health_check():80 """Health check endpoint"""81 return {82 "status": "healthy",83 "timestamp": datetime.utcnow().isoformat(),84 "model_loaded": cat_model is not None85 }86 87 88# ------------------ REGISTER ------------------89@app.post("/api/register")90def register_user(user: UserCreate, db: Session = Depends(get_db)):91 """92 Register a new user93 """94 try:95 existing_user = db.query(User).filter(User.email == user.email).first()96 if existing_user:97 raise HTTPException(status_code=400, detail="Email already registered")98 99 hashed_password = hash_password(user.password)100 new_user = User(101 email=user.email,102 full_name=user.full_name,103 password=hashed_password104 )105 db.add(new_user)106 db.commit()107 db.refresh(new_user)108 109 return {110 "status": "success",111 "message": "User registered successfully",112 "data": {113 "email": new_user.email,114 "full_name": new_user.full_name115 }116 }117 except HTTPException:118 raise119 except Exception as e:120 db.rollback()121 raise HTTPException(status_code=500, detail=f"Registration failed: {str(e)}")122 123 124# ------------------ LOGIN ------------------125@app.post("/api/login")126def login_user(user: UserLogin, db: Session = Depends(get_db)):127 """128 Authenticate user login129 """130 try:131 db_user = db.query(User).filter(User.email == user.email).first()132 if not db_user or not verify_password(user.password, db_user.password):133 raise HTTPException(status_code=401, detail="Invalid email or password")134 135 return {136 "status": "success",137 "message": "Login successful",138 "data": {139 "email": db_user.email,140 "full_name": db_user.full_name141 }142 }143 except HTTPException:144 raise145 except Exception as e:146 raise HTTPException(status_code=500, detail=f"Login failed: {str(e)}")147 148 149# ------------------ PREDICT FRAUD ------------------150@app.post("/api/predict", response_model=PredictResponse)151def predict_transaction(data: PredictRequest, db: Session = Depends(get_db)):152 """153 Predict fraud for a transaction using hybrid approach (ML model + rule-based system)154 """155 try:156 # Validate model is loaded157 if cat_model is None:158 raise HTTPException(status_code=503, detail="Model not available")159 160 # Validate user161 user = db.query(User).filter(User.email == data.email).first()162 if not user:163 raise HTTPException(status_code=401, detail="User not registered")164 165 # Convert to dict166 data_dict = data.dict()167 168 # Derive auto features169 features_df = derive_features_auto(data_dict)170 features = features_df.to_dict(orient="records")[0]171 172 # Model prediction173 model_proba = float(cat_model.predict_proba(features_df)[0, 1])174 175 # -----------------------------176 # RULE-BASED CHECKS177 # -----------------------------178 rule_flags = []179 rule_score = 0.0180 181 # Rule 1: High amount transaction182 if features["transaction_amount"] > 100000:183 rule_flags.append("High amount transaction (>₹100K)")184 rule_score += 0.2185 186 # Rule 2: Large night-time transaction187 if features["is_night_txn"] == 1 and features["transaction_amount"] > 50000:188 rule_flags.append("Large night-time transaction")189 rule_score += 0.2190 191 # Rule 3: New unverified account192 if features["account_age_days"] < 10 and features["kyc_verified"] == 0:193 rule_flags.append("New unverified account")194 rule_score += 0.25195 196 # Rule 4: Weekend high-value transaction197 if features["is_weekend_txn"] == 1 and features["transaction_amount"] > 80000:198 rule_flags.append("Weekend high-value transaction")199 rule_score += 0.15200 201 # Rule 5: Holiday transaction risk202 if features.get("is_holiday_txn", 0) == 1 and features["transaction_amount"] > 70000:203 rule_flags.append("High-value holiday transaction")204 rule_score += 0.1205 206 # Rule 6: Historical pattern - repeated high-risk transactions207 one_hour_ago = datetime.utcnow() - timedelta(hours=1)208 recent_txns = db.query(Prediction).filter(209 Prediction.customer_id == data_dict["customer_id"],210 Prediction.timestamp >= one_hour_ago211 ).all()212 213 high_value_txns = sum(1 for txn in recent_txns if txn.risk_score > 0.7)214 if high_value_txns >= 3:215 rule_flags.append("Multiple high-risk transactions in last hour")216 rule_score += 0.3217 218 # -----------------------------219 # HYBRID DECISION220 # -----------------------------221 combined_score = round(min(1.0, model_proba + rule_score), 4)222 final_is_fraud = int(combined_score >= 0.6)223 224 # Generate explanation225 explanation = generate_explanation(226 data_dict, 227 features, 228 combined_score, 229 rule_score, 230 rule_flags231 )232 233 # Store in database234 new_pred = Prediction(235 customer_id=data_dict["customer_id"],236 transaction_id=data_dict["transaction_id"],237 email=data_dict["email"],238 risk_score=combined_score,239 is_fraud=final_is_fraud,240 derived_features={**features, "rule_flags": rule_flags},241 explanation=explanation242 )243 db.add(new_pred)244 db.commit()245 db.refresh(new_pred)246 247 return PredictResponse(248 status="success",249 message="Prediction completed successfully",250 data={251 "prediction_id": new_pred.id,252 "user": user.full_name,253 "model_risk_score": round(model_proba, 4),254 "rule_score": round(rule_score, 2),255 "combined_score": combined_score,256 "is_fraud": final_is_fraud,257 "rules_triggered": rule_flags,258 "derived_features": features,259 "explanation": explanation,260 "timestamp": new_pred.timestamp.isoformat()261 }262 )263 264 except HTTPException:265 raise266 except Exception as e:267 db.rollback()268 raise HTTPException(status_code=500, detail=f"Prediction failed: {str(e)}")269 270 271# ------------------ TRANSACTION HISTORY ------------------272@app.get("/api/transactions/{email}", response_model=TransactionHistoryResponse)273def get_transaction_history(email: str, db: Session = Depends(get_db)):274 """275 Get complete transaction history for a specific user276 """277 try:278 # Verify user exists279 user = db.query(User).filter(User.email == email).first()280 if not user:281 raise HTTPException(status_code=404, detail="User not found")282 283 # Fetch all predictions for this user284 predictions = db.query(Prediction).filter(285 Prediction.email == email286 ).order_by(Prediction.timestamp.desc()).all()287 288 transactions = []289 for pred in predictions:290 transactions.append({291 "id": pred.id,292 "customer_id": pred.customer_id,293 "transaction_id": pred.transaction_id,294 "risk_score": pred.risk_score,295 "is_fraud": pred.is_fraud,296 "derived_features": pred.derived_features,297 "explanation": pred.explanation,298 "timestamp": pred.timestamp.isoformat()299 })300 301 return TransactionHistoryResponse(302 status="success",303 message=f"Found {len(transactions)} transactions",304 data={305 "user_email": email,306 "user_name": user.full_name,307 "total_transactions": len(transactions),308 "transactions": transactions309 }310 )311 312 except HTTPException:313 raise314 except Exception as e:315 raise HTTPException(status_code=500, detail=f"Failed to fetch transactions: {str(e)}")316 317 318# ------------------ ANALYTICS DASHBOARD ------------------319@app.get("/api/analytics", response_model=AnalyticsResponse)320def get_analytics(db: Session = Depends(get_db)):321 """322 Get comprehensive analytics for dashboard visualization323 """324 try:325 # Fetch all predictions326 all_predictions = db.query(Prediction).all()327 328 if not all_predictions:329 return AnalyticsResponse(330 status="success",331 message="No data available yet",332 data={333 "kpis": {334 "total_transactions": 0,335 "fraud_detected": 0,336 "accuracy_rate": 0.0,337 "amount_protected": 0.0338 },339 "graphs": {340 "fraud_vs_legitimate": {"fraud": 0, "legitimate": 0},341 "fraud_rate_trend": [],342 "fraud_by_channel": {},343 "amount_vs_risk_scatter": []344 }345 }346 )347 348 # Calculate KPIs349 total_txns = len(all_predictions)350 fraud_count = sum(1 for p in all_predictions if p.is_fraud == 1)351 legitimate_count = total_txns - fraud_count352 353 # Estimate amount protected (fraud transactions)354 amount_protected = sum(355 p.derived_features.get("transaction_amount", 0) 356 for p in all_predictions if p.is_fraud == 1357 )358 359 # Simulated accuracy (you should calculate this based on actual labels if available)360 accuracy_rate = 93.3 # Placeholder - replace with actual calculation361 362 # Graph 1: Fraud vs Legitimate363 fraud_vs_legit = {364 "fraud": fraud_count,365 "legitimate": legitimate_count366 }367 368 # Graph 2: Fraud Rate Trend (Monthly)369 monthly_data = defaultdict(lambda: {"total": 0, "fraud": 0})370 for pred in all_predictions:371 month_key = pred.timestamp.strftime("%Y-%m")372 monthly_data[month_key]["total"] += 1373 if pred.is_fraud == 1:374 monthly_data[month_key]["fraud"] += 1375 376 fraud_rate_trend = []377 for month in sorted(monthly_data.keys()):378 total = monthly_data[month]["total"]379 fraud = monthly_data[month]["fraud"]380 fraud_rate = round((fraud / total * 100) if total > 0 else 0, 2)381 fraud_rate_trend.append({382 "month": month,383 "fraud_rate": fraud_rate,384 "total_transactions": total,385 "fraud_count": fraud386 })387 388 # Graph 3: Fraud Distribution by Channel389 channel_mapping = {0: "Online", 1: "ATM", 2: "POS", 3: "Mobile"}390 channel_fraud = defaultdict(int)391 392 for pred in all_predictions:393 if pred.is_fraud == 1:394 channel_code = pred.derived_features.get("channel_encoded", 0)395 channel_name = channel_mapping.get(channel_code, "Unknown")396 channel_fraud[channel_name] += 1397 398 # Graph 4: Transaction Amount vs Risk Score (Scatter Plot)399 scatter_data = []400 for pred in all_predictions:401 scatter_data.append({402 "transaction_amount": pred.derived_features.get("transaction_amount", 0),403 "risk_score": pred.risk_score,404 "is_fraud": pred.is_fraud405 })406 407 return AnalyticsResponse(408 status="success",409 message="Analytics generated successfully",410 data={411 "kpis": {412 "total_transactions": total_txns,413 "fraud_detected": fraud_count,414 "accuracy_rate": accuracy_rate,415 "amount_protected": round(amount_protected, 2)416 },417 "graphs": {418 "fraud_vs_legitimate": fraud_vs_legit,419 "fraud_rate_trend": fraud_rate_trend,420 "fraud_by_channel": dict(channel_fraud),421 "amount_vs_risk_scatter": scatter_data422 }423 }424 )425 426 except Exception as e:427 raise HTTPException(status_code=500, detail=f"Analytics generation failed: {str(e)}")428 429# ------------------ MODEL METRICS ------------------430@app.get("/api/metrics", response_model=MetricsResponse)431def get_model_metrics():432 """433 Get model performance metrics (based on actual training results)434 """435 return MetricsResponse(436 status="success",437 message="Model metrics retrieved successfully",438 data={439 "model_name": "CatBoost Fraud Detection Model (Recall-Optimized)",440 "version": "1.0.0",441 "training_date": "2025-01-15",442 "metrics": {443 "accuracy": 0.76,444 "precision": 0.24,445 "recall": 0.83, # This is the important part - FRAUD DETECTION RECALL446 "f1_score": 0.37,447 "auc_roc": 0.80,448 "confusion_matrix": {449 "true_positive": 71,450 "false_positive": 224,451 "true_negative": 690,452 "false_negative": 15453 }454 },455 # Keep these unless you want to regenerate actual importance values456 "feature_importance": [457 {"feature": "transaction_amount", "importance": 0.234},458 {"feature": "account_age_days", "importance": 0.189},459 {"feature": "kyc_verified", "importance": 0.156},460 {"feature": "is_night_txn", "importance": 0.123},461 {"feature": "hour_of_day", "importance": 0.098},462 {"feature": "channel_encoded", "importance": 0.087},463 {"feature": "is_high_amount_transaction", "importance": 0.073},464 {"feature": "day_of_week", "importance": 0.040}465 ],466 "performance_summary": {467 "total_predictions": 1000,468 "fraud_detected": 71,469 "false_positives": 224,470 "false_negatives": 15,471 "detection_rate": 0.83,472 "false_positive_rate": round(224 / (224 + 690), 3)473 }474 }475 )476 477 478# ------------------ BULK PREDICT ------------------479@app.post("/api/bulk-predict", response_model=BulkPredictResponse)480def bulk_predict_transactions(data: BulkPredictRequest, db: Session = Depends(get_db)):481 """482 Bulk fraud prediction for multiple transactions483 Accepts up to 1000 transactions at once484 """485 start_time = time.time()486 487 try:488 # Validate model is loaded489 if cat_model is None:490 raise HTTPException(status_code=503, detail="Model not available")491 492 # Validate user493 user = db.query(User).filter(User.email == data.email).first()494 if not user:495 raise HTTPException(status_code=401, detail="User not registered")496 497 results = []498 successful = 0499 failed = 0500 fraud_detected = 0501 502 # Process each transaction503 for txn_data in data.transactions:504 try:505 # Add email to transaction data506 txn_data["email"] = data.email507 508 # Derive features509 features_df = derive_features_auto(txn_data)510 features = features_df.to_dict(orient="records")[0]511 512 # Model prediction513 model_proba = float(cat_model.predict_proba(features_df)[0, 1])514 515 # Rule-based checks516 rule_flags = []517 rule_score = 0.0518 519 # Rule 1: High amount520 if features["transaction_amount"] > 100000:521 rule_flags.append("High amount transaction (>₹100K)")522 rule_score += 0.2523 524 # Rule 2: Night transaction525 if features["is_night_txn"] == 1 and features["transaction_amount"] > 50000:526 rule_flags.append("Large night-time transaction")527 rule_score += 0.2528 529 # Rule 3: New unverified account530 if features["account_age_days"] < 10 and features["kyc_verified"] == 0:531 rule_flags.append("New unverified account")532 rule_score += 0.25533 534 # Rule 4: Weekend high-value535 if features["is_weekend_txn"] == 1 and features["transaction_amount"] > 80000:536 rule_flags.append("Weekend high-value transaction")537 rule_score += 0.15538 539 # Rule 5: Holiday risk540 if features.get("is_holiday_txn", 0) == 1 and features["transaction_amount"] > 70000:541 rule_flags.append("High-value holiday transaction")542 rule_score += 0.1543 544 # Combined score545 combined_score = round(min(1.0, model_proba + rule_score), 4)546 final_is_fraud = int(combined_score >= 0.6)547 548 if final_is_fraud:549 fraud_detected += 1550 551 # Generate explanation552 explanation = generate_explanation(553 txn_data, features, combined_score, rule_score, rule_flags554 )555 556 # Store in database557 new_pred = Prediction(558 customer_id=txn_data["customer_id"],559 transaction_id=txn_data["transaction_id"],560 email=data.email,561 risk_score=combined_score,562 is_fraud=final_is_fraud,563 derived_features={**features, "rule_flags": rule_flags},564 explanation=explanation565 )566 db.add(new_pred)567 568 # Add to results569 results.append({570 "transaction_id": txn_data["transaction_id"],571 "customer_id": txn_data["customer_id"],572 "risk_score": combined_score,573 "is_fraud": final_is_fraud,574 "model_risk_score": round(model_proba, 4),575 "rule_score": round(rule_score, 2),576 "rules_triggered": rule_flags,577 "status": "success",578 "error_message": None579 })580 581 successful += 1582 583 except Exception as e:584 failed += 1585 results.append({586 "transaction_id": txn_data.get("transaction_id", "unknown"),587 "customer_id": txn_data.get("customer_id", "unknown"),588 "risk_score": 0.0,589 "is_fraud": 0,590 "model_risk_score": 0.0,591 "rule_score": 0.0,592 "rules_triggered": [],593 "status": "error",594 "error_message": str(e)595 })596 597 # Commit all successful predictions598 db.commit()599 600 # Calculate processing time601 processing_time = round(time.time() - start_time, 2)602 603 return BulkPredictResponse(604 status="success",605 message=f"Bulk prediction completed: {successful} successful, {failed} failed",606 data={607 "user": user.full_name,608 "total_processed": len(data.transactions),609 "successful": successful,610 "failed": failed,611 "fraud_detected": fraud_detected,612 "fraud_rate": round((fraud_detected / successful * 100) if successful > 0 else 0, 2),613 "processing_time_seconds": processing_time,614 "avg_time_per_transaction_ms": round((processing_time / len(data.transactions)) * 1000, 2),615 "results": results616 }617 )618 619 except HTTPException:620 raise621 except Exception as e:622 db.rollback()623 raise HTTPException(status_code=500, detail=f"Bulk prediction failed: {str(e)}")624# ------------------ ROOT ENDPOINT ------------------625@app.get("/")626def root():627 """Root endpoint with API information"""628 return {629 "message": "Welcome to RiskShield Fraud Detection API",630 "version": "1.0.0",631 "endpoints": {632 "health": "/api/health",633 "register": "/api/register",634 "login": "/api/login",635 "predict": "/api/predict",636 "transactions": "/api/transactions/{email}",637 "analytics": "/api/analytics",638 "metrics": "/api/metrics"639 },640 "documentation": "/docs"641 }642 643 644 645if __name__ == "__main__":646 import uvicorn647 uvicorn.run(app, host="0.0.0.0", port=8000, reload=True)648 649