Update app.py

app.py

@@ -5,6 +5,7 @@ import torch.nn as nn
 from transformers import BertTokenizer, BertModel
 from sklearn.preprocessing import StandardScaler, LabelEncoder
 from sklearn.ensemble import IsolationForest
+import gradio as gr
 import warnings
 warnings.filterwarnings('ignore')
 
@@ -101,8 +102,6 @@ class FraudDetectionTester:
                 IsolationForest
             ])
             
-            # Load with weights_only=False for backward compatibility
-            # This is safe if you trust the source of the model file
             checkpoint = torch.load(self.model_path, map_location=self.device, weights_only=False)
             
             # Load preprocessing objects
@@ -125,12 +124,10 @@ class FraudDetectionTester:
             raise
         except Exception as e:
             print(f"❌ Error loading model: {str(e)}")
-            print("If you're still getting errors, try updating PyTorch or ensure the model file is from a trusted source.")
             raise
     
     def tokenize_descriptions(self, descriptions, max_length=128):
         """Tokenize transaction descriptions for BERT"""
-        # Convert pandas Series to list if needed
         if hasattr(descriptions, 'tolist'):
             descriptions = descriptions.tolist()
         elif isinstance(descriptions, str):
@@ -138,7 +135,6 @@ class FraudDetectionTester:
         elif not isinstance(descriptions, list):
             descriptions = list(descriptions)
         
-        # Ensure all descriptions are strings
         descriptions = [str(desc) for desc in descriptions]
         
         encoded = self.tokenizer(
@@ -153,25 +149,22 @@ class FraudDetectionTester:
     
     def preprocess_single_transaction(self, transaction):
         """Preprocess a single transaction for prediction"""
-        # Create DataFrame from transaction
         if isinstance(transaction, dict):
             df = pd.DataFrame([transaction])
         else:
             df = pd.DataFrame(transaction)
         
-        # Feature engineering (same as training)
+        # Feature engineering
         df['amount_log'] = np.log1p(df['amount'])
         df['is_weekend'] = (df['day_of_week'] >= 5).astype(int)
         df['is_night'] = ((df['hour'] >= 22) | (df['hour'] <= 6)).astype(int)
         df['high_frequency'] = (df['transaction_count_1h'] > 3).astype(int)
         df['amount_deviation'] = abs(df['amount'] - df['avg_amount_1h']) / (df['avg_amount_1h'] + 1)
         
-        # Handle unknown categories for merchant_category
+        # Handle unknown categories
         try:
             df['merchant_category_encoded'] = self.label_encoder.transform(df['merchant_category'])
-        except ValueError as e:
-            print(f"⚠️  Warning: Unknown merchant category '{df['merchant_category'].iloc[0]}'. Using default value.")
-            # Use the first category as default or assign a default encoded value
+        except ValueError:
             df['merchant_category_encoded'] = 0
         
         # Prepare numerical features
@@ -182,83 +175,60 @@ class FraudDetectionTester:
         
         X_numerical = self.scaler.transform(df[numerical_features])
         
-        # Process text - ensure it's a string
+        # Process text
         df['processed_description'] = df['description'].astype(str).str.lower().str.replace(r'[^\w\s]', '', regex=True)
         
         return df, X_numerical
     
-    def predict_fraud(self, transactions):
-        """Predict fraud for one or more transactions"""
-        print("🔍 Analyzing transactions for fraud...")
-        
-        # Handle single transaction
-        if isinstance(transactions, dict):
-            transactions = [transactions]
-        
-        results = []
-        
-        for i, transaction in enumerate(transactions):
-            try:
-                # Preprocess transaction
-                df, X_numerical = self.preprocess_single_transaction(transaction)
-                
-                # Tokenize description - extract the actual string values
-                processed_descriptions = df['processed_description'].tolist()
-                input_ids, attention_masks = self.tokenize_descriptions(processed_descriptions)
+    def predict_fraud(self, transaction):
+        """Predict fraud for a single transaction"""
+        try:
+            # Preprocess transaction
+            df, X_numerical = self.preprocess_single_transaction(transaction)
+            
+            # Tokenize description
+            processed_descriptions = df['processed_description'].tolist()
+            input_ids, attention_masks = self.tokenize_descriptions(processed_descriptions)
+            
+            # Make prediction
+            with torch.no_grad():
+                batch_num = torch.tensor(X_numerical).float().to(self.device)
+                batch_ids = input_ids.to(self.device)
+                batch_masks = attention_masks.to(self.device)
                 
-                # Make prediction
-                with torch.no_grad():
-                    batch_num = torch.tensor(X_numerical).float().to(self.device)
-                    batch_ids = input_ids.to(self.device)
-                    batch_masks = attention_masks.to(self.device)
-                    
-                    fraud_prob, anomaly_score = self.model(batch_ids, batch_masks, batch_num)
-                    
-                    # Get isolation forest prediction
-                    isolation_pred = self.isolation_forest.decision_function(X_numerical)
-                    
-                    # Handle single prediction vs batch
-                    if isinstance(fraud_prob, torch.Tensor):
-                        if fraud_prob.dim() == 0:  # Single prediction
-                            fraud_prob_val = fraud_prob.item()
-                            anomaly_score_val = anomaly_score.item()
-                        else:  # Batch prediction
-                            fraud_prob_val = fraud_prob[0].item()
-                            anomaly_score_val = anomaly_score[0].item()
-                    else:
-                        fraud_prob_val = float(fraud_prob)
-                        anomaly_score_val = float(anomaly_score)
-                    
-                    # Combine predictions (ensemble approach)
-                    combined_score = (0.6 * fraud_prob_val + 
-                                    0.3 * (1 - (isolation_pred[0] + 0.5)) + 
-                                    0.1 * anomaly_score_val)
+                fraud_prob, anomaly_score = self.model(batch_ids, batch_masks, batch_num)
                 
-                # Create result
-                result = {
-                    'transaction_id': transaction.get('transaction_id', f'test_{i+1}'),
-                    'amount': transaction['amount'],
-                    'description': transaction['description'],
-                    'fraud_probability': float(combined_score),
-                    'is_fraud_predicted': bool(combined_score > 0.5),
-                    'risk_level': self.get_risk_level(combined_score),
-                    'anomaly_score': float(anomaly_score_val),
-                    'bert_score': float(fraud_prob_val),
-                    'isolation_score': float(isolation_pred[0])
-                }
+                # Get isolation forest prediction
+                isolation_pred = self.isolation_forest.decision_function(X_numerical)
                 
-                results.append(result)
+                # Handle single prediction
+                if isinstance(fraud_prob, torch.Tensor):
+                    if fraud_prob.dim() == 0:
+                        fraud_prob_val = fraud_prob.item()
+                        anomaly_score_val = anomaly_score.item()
+                    else:
+                        fraud_prob_val = fraud_prob[0].item()
+                        anomaly_score_val = anomaly_score[0].item()
+                else:
+                    fraud_prob_val = float(fraud_prob)
+                    anomaly_score_val = float(anomaly_score)
                 
-            except Exception as e:
-                print(f"❌ Error processing transaction {i+1}: {str(e)}")
-                import traceback
-                traceback.print_exc()  # Print full error traceback for debugging
-                results.append({
-                    'transaction_id': transaction.get('transaction_id', f'test_{i+1}'),
-                    'error': str(e)
-                })
-        
-        return results
+                # Combine predictions
+                combined_score = (0.6 * fraud_prob_val + 
+                                0.3 * (1 - (isolation_pred[0] + 0.5)) + 
+                                0.1 * anomaly_score_val)
+            
+            return {
+                'fraud_probability': float(combined_score),
+                'is_fraud_predicted': bool(combined_score > 0.5),
+                'risk_level': self.get_risk_level(combined_score),
+                'anomaly_score': float(anomaly_score_val),
+                'bert_score': float(fraud_prob_val),
+                'isolation_score': float(isolation_pred[0])
+            }
+            
+        except Exception as e:
+            return {'error': str(e)}
     
     def get_risk_level(self, score):
         """Determine risk level based on fraud probability"""
@@ -272,46 +242,89 @@ class FraudDetectionTester:
             return 'LOW'
         else:
             return 'MINIMAL'
+
+# Initialize the fraud detection model
+print("Initializing fraud detection model...")
+try:
+    fraud_detector = FraudDetectionTester('fraud_detection_model.pth')
+    model_loaded = True
+except Exception as e:
+    print(f"Failed to load model: {e}")
+    model_loaded = False
+
+def predict_transaction_fraud(
+    transaction_id,
+    amount,
+    merchant_category,
+    description,
+    hour,
+    day_of_week,
+    days_since_last_transaction,
+    transaction_count_1h,
+    transaction_count_24h,
+    avg_amount_1h,
+    location_risk_score,
+    account_age_days
+):
+    """Gradio interface function for fraud prediction"""
     
-    def display_results(self, results):
-        """Display prediction results in a nice format"""
-        print("\n" + "="*80)
-        print("🚨 FRAUD DETECTION RESULTS")
-        print("="*80)
-        
-        for i, result in enumerate(results):
-            if 'error' in result:
-                print(f"\n❌ Transaction {i+1}: ERROR - {result['error']}")
-                continue
-            
-            print(f"\n📋 Transaction {i+1}:")
-            print(f"   ID: {result['transaction_id']}")
-            print(f"   Amount: ${result['amount']:.2f}")
-            print(f"   Description: {result['description']}")
-            print(f"   🎯 Fraud Probability: {result['fraud_probability']:.4f} ({result['fraud_probability']*100:.2f}%)")
-            
-            # Color-coded prediction
-            if result['is_fraud_predicted']:
-                print(f"   🚨 Prediction: FRAUD DETECTED")
-            else:
-                print(f"   ✅ Prediction: LEGITIMATE")
-            
-            print(f"   📊 Risk Level: {result['risk_level']}")
-            print(f"   🔍 Anomaly Score: {result['anomaly_score']:.4f}")
-            print(f"   🤖 BERT Score: {result['bert_score']:.4f}")
-            print(f"   🏝️  Isolation Score: {result['isolation_score']:.4f}")
-            
-            # Risk indicator
-            risk_bar = "█" * int(result['fraud_probability'] * 20)
-            print(f"   📈 Risk Meter: [{risk_bar:<20}] {result['fraud_probability']*100:.1f}%")
-        
-        print("\n" + "="*80)
+    if not model_loaded:
+        return "❌ Model not loaded. Please ensure 'fraud_detection_model.pth' is available.", "", "", "", "", ""
+    
+    # Create transaction dictionary
+    transaction = {
+        'transaction_id': transaction_id,
+        'amount': amount,
+        'merchant_category': merchant_category,
+        'description': description,
+        'hour': hour,
+        'day_of_week': day_of_week,
+        'days_since_last_transaction': days_since_last_transaction,
+        'transaction_count_1h': transaction_count_1h,
+        'transaction_count_24h': transaction_count_24h,
+        'avg_amount_1h': avg_amount_1h,
+        'location_risk_score': location_risk_score,
+        'account_age_days': account_age_days
+    }
+    
+    # Get prediction
+    result = fraud_detector.predict_fraud(transaction)
+    
+    if 'error' in result:
+        return f"❌ Error: {result['error']}", "", "", "", "", ""
+    
+    # Format results
+    fraud_prob = result['fraud_probability']
+    prediction = "🚨 FRAUD DETECTED" if result['is_fraud_predicted'] else "✅ LEGITIMATE"
+    risk_level = result['risk_level']
+    
+    # Create risk meter visualization
+    risk_bar = "█" * int(fraud_prob * 20) + "░" * (20 - int(fraud_prob * 20))
+    risk_meter = f"[{risk_bar}] {fraud_prob*100:.1f}%"
+    
+    # Detailed scores
+    detailed_scores = f"""
+🤖 BERT Score: {result['bert_score']:.4f}
+🏝️ Isolation Score: {result['isolation_score']:.4f}
+🔍 Anomaly Score: {result['anomaly_score']:.4f}
+    """
+    
+    # Summary
+    summary = f"""
+💰 Amount: ${amount:.2f}
+🏪 Category: {merchant_category}
+📝 Description: {description}
+🎯 Fraud Probability: {fraud_prob:.4f} ({fraud_prob*100:.2f}%)
+📊 Risk Level: {risk_level}
+    """
+    
+    return prediction, f"{fraud_prob:.4f}", risk_level, risk_meter, detailed_scores, summary
 
-def create_sample_transactions():
-    """Create sample transactions for testing"""
-    return [
-        {
-            'transaction_id': 'TEST_001',
+def load_sample_transaction(sample_type):
+    """Load predefined sample transactions"""
+    samples = {
+        "Normal Grocery Purchase": {
+            'transaction_id': 'NORMAL_001',
             'amount': 45.67,
             'merchant_category': 'grocery',
             'description': 'WALMART SUPERCENTER CA 1234',
@@ -324,8 +337,8 @@ def create_sample_transactions():
             'location_risk_score': 0.1,
             'account_age_days': 730
         },
-        {
-            'transaction_id': 'TEST_002',
+        "Suspicious High Amount": {
+            'transaction_id': 'SUSPICIOUS_001',
             'amount': 2999.99,
             'merchant_category': 'online',
             'description': 'SUSPICIOUS ELECTRONICS STORE XX 9999',
@@ -338,9 +351,9 @@ def create_sample_transactions():
             'location_risk_score': 0.95,
             'account_age_days': 15
         },
-        {
-            'transaction_id': 'TEST_003',
-            'amount': 89.50,
+        "Coffee Shop Purchase": {
+            'transaction_id': 'COFFEE_001',
+            'amount': 8.50,
             'merchant_category': 'restaurant',
             'description': 'STARBUCKS COFFEE NY 5678',
             'hour': 8,
@@ -348,12 +361,12 @@ def create_sample_transactions():
             'days_since_last_transaction': 0.5,
             'transaction_count_1h': 1,
             'transaction_count_24h': 4,
-            'avg_amount_1h': 85.0,
+            'avg_amount_1h': 8.50,
             'location_risk_score': 0.2,
             'account_age_days': 1095
         },
-        {
-            'transaction_id': 'TEST_004',
+        "Foreign ATM Withdrawal": {
+            'transaction_id': 'ATM_001',
             'amount': 500.00,
             'merchant_category': 'atm',
             'description': 'ATM WITHDRAWAL FOREIGN COUNTRY 0000',
@@ -366,105 +379,136 @@ def create_sample_transactions():
             'location_risk_score': 0.8,
             'account_age_days': 365
         }
-    ]
-
-def create_custom_transaction():
-    """Interactive function to create custom transaction"""
-    print("\n🛠️  CREATE CUSTOM TRANSACTION")
-    print("-" * 40)
-    
-    transaction = {}
+    }
     
-    try:
-        transaction['transaction_id'] = input("Transaction ID (optional): ") or 'CUSTOM_001'
-        transaction['amount'] = float(input("Amount ($): "))
-        
-        print("Merchant categories: grocery, gas_station, restaurant, online, retail, atm")
-        transaction['merchant_category'] = input("Merchant category: ") or 'online'
-        
-        transaction['description'] = input("Transaction description: ") or 'Unknown merchant'
-        transaction['hour'] = int(input("Hour (0-23): "))
-        transaction['day_of_week'] = int(input("Day of week (0=Monday, 6=Sunday): "))
-        transaction['days_since_last_transaction'] = float(input("Days since last transaction: "))
-        transaction['transaction_count_1h'] = int(input("Transactions in last hour: "))
-        transaction['transaction_count_24h'] = int(input("Transactions in last 24 hours: "))
-        transaction['avg_amount_1h'] = float(input("Average amount in last hour ($): "))
-        transaction['location_risk_score'] = float(input("Location risk score (0-1): "))
-        transaction['account_age_days'] = float(input("Account age in days: "))
-        
-        return transaction
-        
-    except ValueError as e:
-        print(f"❌ Invalid input: {e}")
-        return None
+    if sample_type in samples:
+        sample = samples[sample_type]
+        return (
+            sample['transaction_id'],
+            sample['amount'],
+            sample['merchant_category'],
+            sample['description'],
+            sample['hour'],
+            sample['day_of_week'],
+            sample['days_since_last_transaction'],
+            sample['transaction_count_1h'],
+            sample['transaction_count_24h'],
+            sample['avg_amount_1h'],
+            sample['location_risk_score'],
+            sample['account_age_days']
+        )
+    return [""] * 12
 
-def main():
-    """Main testing function"""
-    print("🚀 FRAUD DETECTION MODEL TESTER")
-    print("="*50)
+# Create Gradio interface
+with gr.Blocks(title="🚨 Fraud Detection System", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("""
+    # 🚨 Advanced Fraud Detection System
+    ### Powered by BERT and Machine Learning
     
-    # Initialize tester
-    try:
-        tester = FraudDetectionTester('fraud_detection_model.pth')
-    except:
-        print("Make sure you have the trained model file 'fraud_detection_model.pth' in the same directory!")
-        return
+    This system analyzes financial transactions using advanced AI to detect potential fraud.
+    Enter transaction details below or use sample transactions to test the system.
+    """)
     
-    while True:
-        print("\n📋 TESTING OPTIONS:")
-        print("1. Test with sample transactions")
-        print("2. Create custom transaction")
-        print("3. Test single transaction")
-        print("4. Exit")
-        
-        choice = input("\nEnter your choice (1-4): ").strip()
-        
-        if choice == '1':
-            # Test with sample transactions
-            sample_transactions = create_sample_transactions()
-            results = tester.predict_fraud(sample_transactions)
-            tester.display_results(results)
+    with gr.Row():
+        with gr.Column(scale=2):
+            gr.Markdown("## 📋 Transaction Details")
             
-        elif choice == '2':
-            # Create custom transaction
-            custom_transaction = create_custom_transaction()
-            if custom_transaction:
-                results = tester.predict_fraud([custom_transaction])
-                tester.display_results(results)
+            # Sample transaction selector
+            with gr.Row():
+                sample_dropdown = gr.Dropdown(
+                    choices=["Normal Grocery Purchase", "Suspicious High Amount", "Coffee Shop Purchase", "Foreign ATM Withdrawal"],
+                    label="🎯 Load Sample Transaction",
+                    value="Normal Grocery Purchase"
+                )
+                load_sample_btn = gr.Button("📥 Load Sample", variant="secondary")
             
-        elif choice == '3':
-            # Quick single transaction test
-            print("\n⚡ QUICK TRANSACTION TEST")
-            print("-" * 30)
+            # Transaction inputs
+            with gr.Row():
+                transaction_id = gr.Textbox(label="Transaction ID", value="TEST_001")
+                amount = gr.Number(label="💰 Amount ($)", value=45.67, minimum=0)
             
-            try:
-                quick_transaction = {
-                    'transaction_id': 'QUICK_TEST',
-                    'amount': float(input("Amount ($): ")),
-                    'merchant_category': 'online',
-                    'description': input("Description: ") or 'Unknown transaction',
-                    'hour': int(input("Hour (0-23): ")),
-                    'day_of_week': 2,
-                    'days_since_last_transaction': 1.0,
-                    'transaction_count_1h': int(input("Transactions in last hour: ")),
-                    'transaction_count_24h': 5,
-                    'avg_amount_1h': 100.0,
-                    'location_risk_score': float(input("Risk score (0-1): ")),
-                    'account_age_days': 365
-                }
-                
-                results = tester.predict_fraud([quick_transaction])
-                tester.display_results(results)
-                
-            except ValueError as e:
-                print(f"❌ Invalid input: {e}")
+            with gr.Row():
+                merchant_category = gr.Dropdown(
+                    choices=["grocery", "restaurant", "gas_station", "retail", "online", "atm", "pharmacy", "entertainment"],
+                    label="🏪 Merchant Category",
+                    value="grocery"
+                )
+                description = gr.Textbox(label="📝 Transaction Description", value="WALMART SUPERCENTER CA 1234")
             
-        elif choice == '4':
-            print("👋 Goodbye!")
-            break
+            with gr.Row():
+                hour = gr.Slider(label="🕐 Hour of Day", minimum=0, maximum=23, value=14, step=1)
+                day_of_week = gr.Slider(label="📅 Day of Week (0=Mon, 6=Sun)", minimum=0, maximum=6, value=2, step=1)
             
-        else:
-            print("❌ Invalid choice! Please enter 1-4.")
+            with gr.Row():
+                days_since_last = gr.Number(label="📆 Days Since Last Transaction", value=1.0, minimum=0)
+                transaction_count_1h = gr.Number(label="🔢 Transactions (1h)", value=1, minimum=0)
+            
+            with gr.Row():
+                transaction_count_24h = gr.Number(label="🔢 Transactions (24h)", value=3, minimum=0)
+                avg_amount_1h = gr.Number(label="💵 Avg Amount (1h)", value=50.0, minimum=0)
+            
+            with gr.Row():
+                location_risk_score = gr.Slider(label="📍 Location Risk Score", minimum=0, maximum=1, value=0.1, step=0.01)
+                account_age_days = gr.Number(label="👤 Account Age (days)", value=730, minimum=0)
+            
+            predict_btn = gr.Button("🔍 Analyze Transaction", variant="primary", size="lg")
+        
+        with gr.Column(scale=1):
+            gr.Markdown("## 📊 Fraud Analysis Results")
+            
+            prediction_output = gr.Textbox(label="🎯 Prediction", interactive=False)
+            fraud_prob_output = gr.Textbox(label="📈 Fraud Probability", interactive=False)
+            risk_level_output = gr.Textbox(label="⚠️ Risk Level", interactive=False)
+            risk_meter_output = gr.Textbox(label="📊 Risk Meter", interactive=False, font_family="monospace")
+            detailed_scores_output = gr.Textbox(label="🔍 Detailed Scores", interactive=False, lines=4)
+            summary_output = gr.Textbox(label="📋 Summary", interactive=False, lines=6)
+    
+    # Event handlers
+    predict_btn.click(
+        fn=predict_transaction_fraud,
+        inputs=[
+            transaction_id, amount, merchant_category, description, hour, day_of_week,
+            days_since_last, transaction_count_1h, transaction_count_24h, avg_amount_1h,
+            location_risk_score, account_age_days
+        ],
+        outputs=[
+            prediction_output, fraud_prob_output, risk_level_output, 
+            risk_meter_output, detailed_scores_output, summary_output
+        ]
+    )
+    
+    load_sample_btn.click(
+        fn=load_sample_transaction,
+        inputs=[sample_dropdown],
+        outputs=[
+            transaction_id, amount, merchant_category, description, hour, day_of_week,
+            days_since_last, transaction_count_1h, transaction_count_24h, avg_amount_1h,
+            location_risk_score, account_age_days
+        ]
+    )
+    
+    gr.Markdown("""
+    ---
+    ### 📖 How to Use:
+    1. **Load Sample**: Choose a predefined sample transaction to quickly test the system
+    2. **Enter Details**: Fill in transaction information manually or modify loaded samples
+    3. **Analyze**: Click "Analyze Transaction" to get fraud detection results
+    
+    ### 🎯 Understanding Results:
+    - **Fraud Probability**: Higher values indicate higher fraud risk (0-1 scale)
+    - **Risk Levels**: MINIMAL → LOW → MEDIUM → HIGH → CRITICAL
+    - **Risk Meter**: Visual representation of fraud probability
+    - **Detailed Scores**: Individual model component scores
+    
+    ### ⚠️ Model Requirements:
+    Ensure `fraud_detection_model.pth` is available in the same directory as this script.
+    """)
 
+# Launch the interface
 if __name__ == "__main__":
-    main()
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        debug=True
+    )