Healthcare Fraud Detection System

Load and Clean Data

Import the DE-SynPUF dataset and handle missing values, duplicates, and inconsistencies.

Feature Engineering

Create new features that may highlight fraudulent behavior, such as:

• Claim Frequency: Number of claims per beneficiary
• Service Count: Number of different services billed
• Average Claim Amount: Average cost per claim
• Provider Behavior Metrics: Metrics indicating unusual provider activities

Normalization

Scale numerical features to ensure uniformity across the dataset.

import pandas as pd
import numpy as np
from sklearn.preprocessing import StandardScaler, LabelEncoder
from oracle.ads.dataset.factory import DatasetFactory
from oracle.ads.automl.driver import AutoML

# Initialize Oracle ADS dataset
ds = DatasetFactory.open('de_synpuf_claims.csv')

# Advanced feature engineering
def create_fraud_features(df):
    """Create sophisticated features for fraud detection"""
    
    # Beneficiary-level features
    df['claim_frequency'] = df.groupby('beneficiary_id')['claim_id'].transform('count')
    df['avg_claim_amount'] = df.groupby('beneficiary_id')['claim_amount'].transform('mean')
    df['total_claim_amount'] = df.groupby('beneficiary_id')['claim_amount'].transform('sum')
    df['claim_amount_std'] = df.groupby('beneficiary_id')['claim_amount'].transform('std')
    
    # Provider-level features
    df['provider_claim_count'] = df.groupby('provider_id')['claim_id'].transform('count')
    df['provider_avg_amount'] = df.groupby('provider_id')['claim_amount'].transform('mean')
    df['unique_services_per_provider'] = df.groupby('provider_id')['service_code'].transform('nunique')
    
    # Temporal features
    df['claim_date'] = pd.to_datetime(df['claim_date'])
    df['day_of_week'] = df['claim_date'].dt.dayofweek
    df['month'] = df['claim_date'].dt.month
    df['claims_per_day'] = df.groupby(['beneficiary_id', df['claim_date'].dt.date]).cumcount() + 1
    
    # Risk indicators
    df['amount_percentile'] = df.groupby('service_code')['claim_amount'].rank(pct=True)
    df['unusual_timing'] = (df['claims_per_day'] > 3).astype(int)
    
    return df

# Apply feature engineering
enhanced_data = create_fraud_features(ds.to_pandas_dataframe())

# Normalization with Oracle ADS
scaler = StandardScaler()
numerical_features = ['claim_amount', 'claim_frequency', 'avg_claim_amount', 
                     'provider_claim_count', 'amount_percentile']
enhanced_data[numerical_features] = scaler.fit_transform(enhanced_data[numerical_features])

Visualize Distributions

Use histograms and box plots to understand the distribution of key features using Oracle ADS visualization capabilities.

Correlation Analysis

Identify relationships between features using heatmaps and advanced statistical analysis.

Advanced Anomaly Detection

Apply multiple unsupervised anomaly detection methods:

• Isolation Forest: Tree-based anomaly detection for high-dimensional data
• One-Class SVM: Support vector machine approach for outlier detection
• Local Outlier Factor (LOF): Density-based anomaly detection
• Elliptic Envelope: Robust covariance estimation for outlier detection

Oracle ADS Model Development

Utilize Oracle Autonomous Data Science for scalable model development and training:

• AutoML Integration: Leverage Oracle ADS AutoML for optimal hyperparameter tuning
• Model Catalog: Utilize ADS model catalog for version control and model management
• Distributed Computing: Take advantage of Oracle Cloud's distributed computing resources

Ensemble Learning

Implement advanced ensemble models:

• Random Forest: For capturing complex interactions between features
• Gradient Boosting Machines (GBM): To improve predictive accuracy
• XGBoost: For handling large datasets with high performance
• Voting Classifier: Combining multiple algorithms for robust predictions

Multi-Layer Anomaly Detection Integration

Combine ensemble models with sophisticated anomaly detection:

• Supervised Anomaly Layer: Trained ensemble models for known fraud patterns
• Unsupervised Anomaly Layer: Isolation Forest and One-Class SVM for novel fraud detection
• Hybrid Scoring System: Weighted combination of supervised and unsupervised scores
• Temporal Anomaly Detection: Time-series analysis for claim pattern anomalies

Comprehensive Model Evaluation Framework

Rigorous evaluation using multiple metrics specifically tailored for fraud detection:

Cross-Validation & Robustness Testing

Feature Importance

Utilize techniques like SHAP (SHapley Additive exPlanations) to interpret model decisions.

Visualization

Create visualizations to highlight key features influencing predictions.

Model Serving

Deploy the trained model using multiple approaches:

• Flask API: RESTful API endpoint for system integration
• Streamlit App: Interactive web application for user-friendly fraud analysis

Real-Time Inference

Implement real-time prediction capabilities for new claims with interactive visualization.

Monitoring

Set up monitoring to track model performance over time and retrain as necessary.

POST /api/predict
Content-Type: application/json

{
  "beneficiary_id": "B123456",
  "provider_id": "P789012",
  "claim_amount": 1250.00,
  "service_codes": ["99213", "99214"],
  "diagnosis_codes": ["M79.3", "Z51.11"]
}

Response:
{
  "fraud_probability": 0.87,
  "risk_level": "HIGH",
  "key_factors": ["unusual_provider_pattern", "high_claim_frequency"]
}

import streamlit as st
import pandas as pd
import plotly.express as px
import shap

st.title("🛡️ Healthcare Fraud Detection System")

# Sidebar for input parameters
st.sidebar.header("Claim Information")
beneficiary_id = st.sidebar.text_input("Beneficiary ID")
provider_id = st.sidebar.text_input("Provider ID")
claim_amount = st.sidebar.number_input("Claim Amount", min_value=0.0)

# Prediction and visualization
if st.button("Analyze Claim"):
    prediction = model.predict_proba(features)[0][1]
    
    col1, col2, col3 = st.columns(3)
    with col1:
        st.metric("Fraud Probability", f"{prediction:.2%}")
    with col2:
        risk_level = "HIGH" if prediction > 0.7 else "MEDIUM" if prediction > 0.4 else "LOW"
        st.metric("Risk Level", risk_level)
    with col3:
        st.metric("Processing Time", "0.05s")
    
    # SHAP explanation
    st.subheader("Model Explanation")
    shap_values = explainer.shap_values(features)
    st.plotly_chart(create_shap_plot(shap_values))
    
    # Live Demo Available at: [URL will be added]