Update app.py

Extended the changes

app.py

@@ -224,6 +224,323 @@ def predict_batch(csv_file):
         return None, f"❌ Error: {str(e)}"
 
 
+def calculate_business_impact(total_transactions, fraud_rate_percent, precision, recall, 
+                              fraud_loss_per_transaction, review_cost_per_transaction):
+    """Calculate the financial business impact of a fraud detection model"""
+    
+    try:
+        # Convert fraud rate to decimal
+        fraud_rate = fraud_rate_percent / 100
+        
+        # Calculate actual frauds in the dataset
+        total_frauds = int(total_transactions * fraud_rate)
+        total_legitimate = total_transactions - total_frauds
+        
+        # Calculate confusion matrix components
+        # Recall = TP / (TP + FN) = TP / total_frauds
+        # So: TP = recall * total_frauds
+        true_positives = int(recall * total_frauds)
+        false_negatives = total_frauds - true_positives
+        
+        # Precision = TP / (TP + FP)
+        # So: FP = TP / precision - TP = TP * (1/precision - 1)
+        false_positives = int(true_positives / precision - true_positives) if precision > 0 else 0
+        true_negatives = total_legitimate - false_positives
+        
+        # Calculate financial impact
+        # Frauds caught (prevented losses)
+        fraud_losses_prevented = true_positives * fraud_loss_per_transaction
+        
+        # Frauds missed (actual losses)
+        fraud_losses_incurred = false_negatives * fraud_loss_per_transaction
+        
+        # Review costs (for all flagged transactions)
+        total_flagged = true_positives + false_positives
+        total_review_costs = total_flagged * review_cost_per_transaction
+        
+        # Net benefit
+        net_benefit = fraud_losses_prevented - fraud_losses_incurred - total_review_costs
+        
+        # Without model (baseline - all frauds go through)
+        baseline_losses = total_frauds * fraud_loss_per_transaction
+        savings_vs_baseline = baseline_losses - fraud_losses_incurred - total_review_costs
+        
+        # Calculate percentages
+        fraud_detection_rate = (true_positives / total_frauds * 100) if total_frauds > 0 else 0
+        false_positive_rate = (false_positives / total_legitimate * 100) if total_legitimate > 0 else 0
+        
+        # Format results
+        results = f"""
+## 💰 Business Impact Analysis
+
+### 📊 Transaction Breakdown
+- **Total Transactions:** {total_transactions:,} per month
+- **Actual Frauds:** {total_frauds:,} ({fraud_rate_percent:.2f}%)
+- **Legitimate Transactions:** {total_legitimate:,} ({100-fraud_rate_percent:.2f}%)
+
+### 🎯 Model Performance
+- **Precision:** {precision*100:.1f}% (of flagged, {precision*100:.1f}% are actually fraud)
+- **Recall:** {recall*100:.1f}% (catches {recall*100:.1f}% of all frauds)
+
+### 🔍 Detection Results
+- **✅ True Positives (Frauds Caught):** {true_positives:,} ({fraud_detection_rate:.1f}% of frauds)
+- **❌ False Negatives (Frauds Missed):** {false_negatives:,} ({100-fraud_detection_rate:.1f}% of frauds)
+- **⚠️ False Positives (False Alarms):** {false_positives:,} ({false_positive_rate:.2f}% of legitimate)
+- **✅ True Negatives (Correctly Allowed):** {true_negatives:,}
+
+### 💵 Financial Impact (Monthly)
+
+**Fraud Prevention:**
+- **Losses Prevented:** ${fraud_losses_prevented:,.2f}
+  - ({true_positives:,} frauds caught × ${fraud_loss_per_transaction:,.2f})
+
+**Losses Incurred:**
+- **Missed Fraud Losses:** ${fraud_losses_incurred:,.2f}
+  - ({false_negatives:,} frauds missed × ${fraud_loss_per_transaction:,.2f})
+
+**Operational Costs:**
+- **Manual Review Costs:** ${total_review_costs:,.2f}
+  - ({total_flagged:,} flagged transactions × ${review_cost_per_transaction:,.2f})
+
+### 📈 **Net Benefit: ${net_benefit:,.2f} per month**
+
+### 🎯 **Primary Benefit:**
+**The model saves ${savings_vs_baseline:,.2f} per month compared to having no fraud detection system.**
+
+**Annual Impact:** ${net_benefit * 12:,.2f}
+
+### 📊 Key Insights:
+1. **Fraud Detection Rate:** {fraud_detection_rate:.1f}% of frauds are caught
+2. **Cost Efficiency:** Every ${total_review_costs/fraud_losses_prevented:.2f} spent on reviews prevents ${fraud_loss_per_transaction:.2f} in fraud
+3. **ROI:** {((net_benefit / total_review_costs) * 100) if total_review_costs > 0 else 0:.1f}% return on review investment
+4. **Remaining Risk:** {false_negatives:,} frauds still slip through (${fraud_losses_incurred:,.2f} in losses)
+
+### ⚠️ Recommendations:
+- **Current Recall ({recall*100:.1f}%):** Missing {false_negatives:,} frauds costs ${fraud_losses_incurred:,.2f}/month
+- Consider improving recall to reduce missed frauds
+- Balance precision to control review costs
+        """
+        
+        return results
+        
+    except Exception as e:
+        return f"❌ Error calculating business impact: {str(e)}"
+
+
+def analyze_model_drift(initial_precision, current_precision, months_deployed, 
+                        initial_recall, current_recall):
+    """Analyze model drift and provide recommendations"""
+    
+    try:
+        precision_drop = initial_precision - current_precision
+        precision_drop_pct = (precision_drop / initial_precision * 100) if initial_precision > 0 else 0
+        
+        recall_change = current_recall - initial_recall
+        recall_change_pct = (recall_change / initial_recall * 100) if initial_recall > 0 else 0
+        
+        # Determine severity
+        if precision_drop_pct > 20:
+            severity = "🔴 CRITICAL"
+            urgency = "Immediate action required"
+        elif precision_drop_pct > 10:
+            severity = "🟠 HIGH"
+            urgency = "Action needed within 1-2 weeks"
+        else:
+            severity = "🟡 MODERATE"
+            urgency = "Monitor closely, plan retraining"
+        
+        # Most likely causes (in order of probability)
+        causes = []
+        if precision_drop_pct > 15:
+            causes.append({
+                "rank": 1,
+                "cause": "**Data Drift / Distribution Shift**",
+                "description": "The statistical distribution of incoming transactions has changed. Legitimate customer behavior patterns have shifted (e.g., new spending habits, new products, seasonal changes, post-pandemic behavior changes).",
+                "probability": "Very High (80-90%)"
+            })
+        else:
+            causes.append({
+                "rank": 1,
+                "cause": "**Data Drift / Distribution Shift**",
+                "description": "Gradual changes in transaction patterns over time.",
+                "probability": "High (70-80%)"
+            })
+        
+        causes.append({
+            "rank": 2,
+            "cause": "**Concept Drift**",
+            "description": "The relationship between features and fraud has changed. Fraudsters have adapted their tactics to evade detection, or new fraud patterns have emerged that weren't in training data.",
+            "probability": "Medium-High (50-60%)"
+        })
+        
+        causes.append({
+            "rank": 3,
+            "cause": "**Feature Drift**",
+            "description": "Individual features have changed meaning or distribution. Examples: new payment methods, changes in merchant categories, updated transaction processing systems.",
+            "probability": "Medium (30-40%)"
+        })
+        
+        causes.append({
+            "rank": 4,
+            "cause": "**Label Quality Issues**",
+            "description": "Ground truth labels may have become less accurate, or fraud definition has changed. This is less common but can cause apparent precision drops.",
+            "probability": "Low (10-20%)"
+        })
+        
+        # Appropriate actions
+        actions = [
+            {
+                "priority": "🔴 IMMEDIATE",
+                "action": "**Data Distribution Analysis**",
+                "steps": [
+                    "Compare feature distributions of recent data vs training data",
+                    "Use statistical tests (KS test, PSI - Population Stability Index)",
+                    "Identify which features have drifted most significantly",
+                    "Check for missing values, outliers, or data quality issues"
+                ]
+            },
+            {
+                "priority": "🔴 IMMEDIATE",
+                "action": "**Model Retraining**",
+                "steps": [
+                    "Collect recent labeled data (last 1-3 months)",
+                    "Retrain model with updated dataset",
+                    "Use time-based train/test splits (not random)",
+                    "Consider ensemble with older model for stability",
+                    "Validate on holdout set before deployment"
+                ]
+            },
+            {
+                "priority": "🟠 HIGH",
+                "action": "**Implement Monitoring**",
+                "steps": [
+                    "Set up automated drift detection (PSI, feature drift alerts)",
+                    "Track precision/recall on rolling windows (daily/weekly)",
+                    "Monitor false positive rate trends",
+                    "Alert when metrics drop below thresholds",
+                    "Dashboard for real-time model health"
+                ]
+            },
+            {
+                "priority": "🟠 HIGH",
+                "action": "**Threshold Adjustment**",
+                "steps": [
+                    "Temporarily adjust classification threshold to maintain precision",
+                    "Use probability scores instead of binary predictions",
+                    "Implement adaptive thresholds based on recent performance",
+                    "Balance precision vs recall based on business needs"
+                ]
+            },
+            {
+                "priority": "🟡 MEDIUM",
+                "action": "**Feature Engineering Updates**",
+                "steps": [
+                    "Review and update feature engineering logic",
+                    "Add new features that capture current fraud patterns",
+                    "Remove obsolete features",
+                    "Consider interaction features or time-based features"
+                ]
+            },
+            {
+                "priority": "🟡 MEDIUM",
+                "action": "**Continuous Learning Pipeline**",
+                "steps": [
+                    "Implement periodic retraining schedule (monthly/quarterly)",
+                    "Use online learning or incremental updates if applicable",
+                    "A/B test new model versions before full deployment",
+                    "Maintain model versioning and rollback capability"
+                ]
+            }
+        ]
+        
+        # Calculate impact
+        # Assuming same parameters as before for impact calculation
+        # This is a simplified impact - in reality you'd need full business params
+        impact_note = "⚠️ Lower precision means more false positives, increasing review costs and customer friction."
+        
+        # Format results
+        results = f"""
+## 🔍 Model Drift Analysis
+
+### 📉 Performance Degradation
+- **Initial Precision:** {initial_precision*100:.1f}%
+- **Current Precision:** {current_precision*100:.1f}%
+- **Precision Drop:** {precision_drop*100:.1f} percentage points ({precision_drop_pct:.1f}% relative decrease)
+- **Deployment Duration:** {months_deployed} months
+
+- **Initial Recall:** {initial_recall*100:.1f}%
+- **Current Recall:** {current_recall*100:.1f}%
+- **Recall Change:** {recall_change*100:+.1f} percentage points ({recall_change_pct:+.1f}% relative change)
+
+### {severity} - {urgency}
+
+---
+
+## 🎯 Most Likely Cause
+
+### {causes[0]['rank']}. {causes[0]['cause']}
+**Probability:** {causes[0]['probability']}
+
+**Explanation:**
+{causes[0]['description']}
+
+**Why This Matters:**
+- Lower precision = More false positives
+- More legitimate transactions flagged for review
+- Increased operational costs and customer friction
+- Model is becoming less reliable over time
+
+---
+
+## 🔧 Appropriate Actions (Priority Order)
+
+"""
+        
+        for action in actions:
+            results += f"""
+### {action['priority']} {action['action']}
+"""
+            for i, step in enumerate(action['steps'], 1):
+                results += f"{i}. {step}\n"
+            results += "\n"
+        
+        results += f"""
+---
+
+## 📊 Additional Considerations
+
+### Why Precision Drops Are Critical:
+1. **Financial Impact:** More false positives = higher review costs
+2. **Customer Experience:** Legitimate customers face more friction
+3. **Operational Burden:** Review teams overwhelmed with false alarms
+4. **Trust Erosion:** Model loses credibility if too many false alarms
+
+### Prevention Strategy:
+- **Proactive Monitoring:** Don't wait for metrics to drop
+- **Regular Retraining:** Schedule periodic model updates (every 1-3 months)
+- **Data Quality:** Ensure incoming data matches training data characteristics
+- **Feedback Loops:** Incorporate labeled outcomes back into training data
+
+### Expected Timeline:
+- **Immediate (Week 1):** Data analysis, threshold adjustment
+- **Short-term (Weeks 2-4):** Model retraining, validation
+- **Long-term (Ongoing):** Continuous monitoring, scheduled retraining
+
+---
+
+## 💡 Key Takeaway
+
+**The most likely cause is DATA DRIFT** - your model was trained on data from 3+ months ago, and transaction patterns have changed. The model needs to be retrained on recent data to adapt to current patterns.
+
+**Action:** Implement a retraining pipeline with recent labeled data and set up continuous monitoring to catch drift early.
+        """
+        
+        return results
+        
+    except Exception as e:
+        return f"❌ Error analyzing model drift: {str(e)}"
+
+
 # Create Gradio interface
 with gr.Blocks(title="Fraud Detection System") as demo:
     
@@ -334,6 +651,109 @@ with gr.Blocks(title="Fraud Detection System") as demo:
             outputs=[download_file, batch_output]
         )
     
+    with gr.Tab("💰 Business Impact Calculator"):
+        gr.Markdown("### Calculate Financial Impact of Your Fraud Detection Model")
+        gr.Markdown("Enter your model's performance metrics and business parameters to see the financial impact")
+        
+        with gr.Row():
+            with gr.Column():
+                gr.Markdown("#### 📊 Model Performance Metrics")
+                precision_input = gr.Slider(0, 1, step=0.01, value=0.85, label="Precision (0-1)", info="Of flagged transactions, what % are actually fraud?")
+                recall_input = gr.Slider(0, 1, step=0.01, value=0.90, label="Recall (0-1)", info="Of all frauds, what % does the model catch?")
+                
+                gr.Markdown("#### 🏦 Business Parameters")
+                total_transactions = gr.Number(label="Total Transactions per Month", value=1000000, precision=0)
+                fraud_rate = gr.Slider(0, 10, step=0.01, value=1.0, label="Fraud Rate (%)", info="Percentage of transactions that are fraudulent")
+                
+                gr.Markdown("#### 💵 Cost Parameters")
+                fraud_loss = gr.Number(label="Average Fraud Loss per Transaction ($)", value=500, precision=2)
+                review_cost = gr.Number(label="Manual Review Cost per Flagged Transaction ($)", value=2.00, precision=2)
+                
+                calc_button = gr.Button("💰 Calculate Business Impact", variant="primary", size="lg")
+            
+            with gr.Column():
+                impact_output = gr.Markdown(label="Business Impact Analysis")
+        
+        calc_button.click(
+            fn=calculate_business_impact,
+            inputs=[total_transactions, fraud_rate, precision_input, recall_input, fraud_loss, review_cost],
+            outputs=[impact_output]
+        )
+        
+        gr.Markdown("---")
+        gr.Markdown("""
+        ### 📚 How to Use This Calculator
+        
+        **Example Scenario:**
+        - Bank processes 1 million transactions/month
+        - Model has 85% precision and 90% recall
+        - 1% of transactions are fraudulent
+        - Average fraud loss: $500 per transaction
+        - Manual review cost: $2 per flagged transaction
+        
+        **What This Calculates:**
+        1. **True Positives:** Frauds caught by the model
+        2. **False Negatives:** Frauds missed (costly!)
+        3. **False Positives:** Legitimate transactions flagged (review costs)
+        4. **Net Benefit:** Total financial impact of using the model
+        
+        **Key Insight:** The primary benefit is the **net savings** compared to having no fraud detection system.
+        """)
+    
+    with gr.Tab("📉 Model Drift Analysis"):
+        gr.Markdown("### Analyze Model Performance Degradation")
+        gr.Markdown("If your model's precision or recall has dropped over time, use this tool to identify likely causes and appropriate actions")
+        
+        with gr.Row():
+            with gr.Column():
+                gr.Markdown("#### 📊 Initial Performance (At Deployment)")
+                initial_precision = gr.Slider(0, 1, step=0.01, value=0.85, label="Initial Precision", info="Model precision when first deployed")
+                initial_recall = gr.Slider(0, 1, step=0.01, value=0.90, label="Initial Recall", info="Model recall when first deployed")
+                
+                gr.Markdown("#### 📉 Current Performance (Now)")
+                current_precision = gr.Slider(0, 1, step=0.01, value=0.70, label="Current Precision", info="Model precision after deployment period")
+                current_recall = gr.Slider(0, 1, step=0.01, value=0.90, label="Current Recall", info="Model recall now (may have changed)")
+                
+                gr.Markdown("#### ⏱️ Deployment Information")
+                months_deployed = gr.Number(label="Months Since Deployment", value=3, precision=1, info="How long has the model been in production?")
+                
+                analyze_button = gr.Button("🔍 Analyze Model Drift", variant="primary", size="lg")
+            
+            with gr.Column():
+                drift_output = gr.Markdown(label="Drift Analysis & Recommendations")
+        
+        analyze_button.click(
+            fn=analyze_model_drift,
+            inputs=[initial_precision, current_precision, months_deployed, initial_recall, current_recall],
+            outputs=[drift_output]
+        )
+        
+        gr.Markdown("---")
+        gr.Markdown("""
+        ### 📚 Understanding Model Drift
+        
+        **What is Model Drift?**
+        Model drift occurs when a machine learning model's performance degrades over time because the data it encounters in production differs from the data it was trained on.
+        
+        **Common Scenarios:**
+        - **Precision drops from 85% to 70%** → More false positives (legitimate transactions flagged)
+        - **Recall drops** → More frauds missed (false negatives)
+        - **Both drop** → Model is becoming unreliable
+        
+        **Why It Happens:**
+        1. Customer behavior changes (new spending patterns, seasonal trends)
+        2. Fraudsters adapt their tactics
+        3. New products/services introduced
+        4. Changes in transaction processing systems
+        5. External factors (economic changes, regulations)
+        
+        **Example:**
+        After 3 months, precision drops from 85% to 70%. This means:
+        - Previously: 85 out of 100 flagged transactions were fraud
+        - Now: Only 70 out of 100 flagged transactions are fraud
+        - **30% increase in false positives** = Higher review costs, customer friction
+        """)
+    
     with gr.Tab("ℹ️ About"):
         gr.Markdown("""
         ## About This Demo