Credit Card Fraud Detection Application

This application leverages machine learning to detect fraudulent credit card transactions.

This project contains a Fraud Detection application that includes a FastAPI server for the backend and a Gradio interface for the frontend. The application can predict if a transaction is fraudulent using either XGBoost or RandomForest models.

Dataset

Try on Gradio

Try on Huggingface Space

Overview

1. FastAPI Backend: Handles prediction requests using machine learning models.
2. Gradio Frontend: Provides a user-friendly web interface for users to input transaction details and get predictions.

Project Structure

/Creditcard-Fraud-Detection
│
├──/model
│   ├── xgboost.pkl
│   └── randomforest.pkl
├──/Encoder
│   └── WOEEncoder.pkl
│
├──/static
│   └──/images
│       ├── github.svg
│       └── api.png
│
├── app.py
├── gradio_app.py
├── docker_app.py
├── Dockerfile
├── docker-compose.yml
├── requirements.txt
├── features.py

• app.py: Defines the FastAPI application.
• gradio_app.py: Defines the Gradio interface.
• docker_app.py: Gradio interface for docker
• Dockerfile: Dockerfile for building the Docker image.
• docker-compose.yml: Docker Compose file for orchestrating the services.
• requirements.txt: List of dependencies.
• features.py: List of features.
• model/: Directory containing pre-trained machine learning models.
• Encoder/: Directory containing encoders used for data preprocessing.
• static/: Directory containing static files such as images used in the interface.

Getting Started

Prerequisites

• Docker
• Docker Compose

Installation

Clone the repository:

git clone https://github.com/Sibikrish3000/Creditcard-Fraud-Detection.git
cd Creditcard-Fraud-Detection

git install lfs
git lfs ls-files

git lfs pull

Running Locally

Using Docker Compose

1. Build and start the containers:

   docker network create AIservice

   docker-compose up --build

2. Access the Gradio interface at http://localhost:7860.

Using Docker image

docker network create AIservice

docker pull sibikrish/creditcard-fraud-detection:latest
docker run sibikrish/creditcard-fraud-detection:latest #or 
docker run -d -p 7860:7860 sibikrish/creditcard-fraud-detection:latest

Manually

To run the application locally without Docker, ensure you have Python installed and follow these steps:

1. Install the dependencies:

   pip install -r requirements.txt

2. Run the FastAPI server:

   uvicorn app:app --host 0.0.0.0 --port 8000

3. Run the Gradio interface:

   python gradio_app.py

Development

Running in a Gitpod Cloud Environment

Click the button below to start a new development environment:

Usage

1. Access the Gradio Interface:

   Open your web browser and navigate to http://localhost:7860 to access the Gradio interface.

   • Inputs: Users can input transaction details such as credit card frequency, job, age, gender, category, distance, hour, hours difference between transactions, amount, and choose a model.
   • Output: The application returns a prediction indicating whether the transaction is legitimate or fraudulent.
   • Flag Option: Users can enable a flag option to provide feedback on incorrect or suspicious predictions.

2. Access the FastAPI Documentation:

   Open your web browser and navigate to http://localhost:8000/docs to access the FastAPI documentation.

API Endpoints

• POST /predict

  Predict if a transaction is fraudulent.

  Request:

  {
    "cc_freq": int,
    "cc_freq_class": int,
    "job": str,
    "age": int,
    "gender_M": int,
    "category": str,
    "distance_km": float,
    "hour": str,
    "hours_diff_bet_trans": float,
    "amt": float
  }

  Response:

  {
    "prediction": 0 for legitimate, 1 for fraudulent
  }

License

This project is licensed under the MIT License. See the LICENSE file for details.