Fraud Detection System

An end-to-end fraud detection system using machine learning with MLOps best practices.

Overview

This project implements a complete fraud detection system with the following components:

• Synthetic dataset generation for fraud detection
• Training multiple ML models (Logistic Regression, Decision Trees, Random Forests, XGBoost, SVM)
• MLflow for experiment tracking and model versioning
• FastAPI for real-time prediction API
• Comprehensive visualization and model evaluation
• Docker containerization for easy deployment

Project Structure

├── app.py                   # FastAPI application for predictions
├── docker-compose.yml       # Docker Compose configuration
├── Dockerfile               # Docker configuration for API
├── generate_dataset.py      # Script to generate synthetic data
├── mlflow-dockerfile        # Docker configuration for MLflow
├── README.md                # Project documentation
├── requirements.txt         # Python dependencies
├── run_pipeline.py          # Script to run the complete pipeline
├── train.py                 # Model training script
├── visualize.py             # Visualization generation script
├── data/                    # Generated datasets
├── models/                  # Saved models
├── mlruns/                  # MLflow experiment tracking
└── visualizations/          # Generated visualizations

Getting Started

Prerequisites

• Python 3.9+
• Docker and Docker Compose (for containerized deployment)

Installation

1. Clone the repository:

   git clone https://github.com/yourusername/fraud-detection.git
   cd fraud-detection
   

2. Install dependencies:

   pip install -r requirements.txt
   

3. Run the complete pipeline:

   python run_pipeline.py
   

   This will:

   • Generate the synthetic dataset
   • Train multiple ML models
   • Track experiments with MLflow
   • Generate visualizations
   • Save the best model

4. Start the API:

   python app.py
   

   The API will be available at http://localhost:8000/docs

Docker Deployment

To deploy with Docker:

1. Build and start the containers:

   docker-compose up --build
   

2. Access the services:

   • FastAPI: http://localhost:8000/docs
   • MLflow: http://localhost:5000

API Usage

Single Prediction

import requests
import json

# API endpoint
url = "http://localhost:8000/predict"

# Transaction data
data = {
    "transaction_amount": 245.50,
    "transaction_hour": 14,
    "days_since_first_transaction": 380,
    "transaction_count_7d": 5,
    "avg_transaction_value_30d": 150.75,
    "std_transaction_value_30d": 85.20,
    "merchant_category_risk": 0.65,
    "distance_from_home": 12.5,
    "international_transaction": 0,
    "transaction_method": 2
}

# Make prediction request
response = requests.post(url, json=data)
result = response.json()

print(f"Fraud Probability: {result['fraud_probability']:.4f}")
print(f"Is Fraud: {result['is_fraud']}")

Batch Prediction

import requests
import json

# API endpoint
url = "http://localhost:8000/predict_batch"

# Batch of transactions
data = {
    "transactions": [
        {
            "transaction_amount": 245.50,
            "transaction_hour": 14,
            "days_since_first_transaction": 380,
            "transaction_count_7d": 5,
            "avg_transaction_value_30d": 150.75,
            "std_transaction_value_30d": 85.20,
            "merchant_category_risk": 0.65,
            "distance_from_home": 12.5,
            "international_transaction": 0,
            "transaction_method": 2
        },
        {
            "transaction_amount": 1890.00,
            "transaction_hour": 2,
            "days_since_first_transaction": 10,
            "transaction_count_7d": 15,
            "avg_transaction_value_30d": 200.75,
            "std_transaction_value_30d": 300.20,
            "merchant_category_risk": 0.9,
            "distance_from_home": 900.5,
            "international_transaction": 1,
            "transaction_method": 3
        }
    ]
}

# Make batch prediction request
response = requests.post(url, json=data)
results = response.json()

# Process results
for i, pred in enumerate(results["predictions"]):
    print(f"Transaction {i+1}:")
    print(f"  Fraud Probability: {pred['fraud_probability']:.4f}")
    print(f"  Is Fraud: {pred['is_fraud']}")

Model Training and Evaluation

The system trains and evaluates multiple machine learning models:

1. Logistic Regression
2. Decision Tree
3. Random Forest
4. XGBoost
5. SVM (Support Vector Machine)
6. Gradient Boosting

For each model, the following metrics are calculated:

• Accuracy
• Precision
• Recall (Sensitivity)
• F1 Score
• ROC AUC
• Specificity

The best performing model (based on ROC AUC) is automatically selected for deployment.

Visualization

The system generates various visualizations to help understand the data and model performance:

1. Feature distributions
2. Correlation matrix
3. Feature importance
4. ROC curve
5. Precision-Recall curve
6. Confusion matrix

These visualizations are stored in the visualizations/ directory.

MLOps Integration

The project includes MLOps best practices:

• Experiment Tracking: All model training runs are tracked using MLflow
• Model Registry: Models are saved and versioned
• CI/CD Ready: Docker containerization for easy deployment
• Model Serving: FastAPI for real-time predictions
• Monitoring: Logging and diagnostics