Update app.py

app.py

@@ -0,0 +1,707 @@
+"""
+FRAUDGUARD - Intelligent Fraud Detection System
+Gradio-based interface for Hugging Face deployment
+"""
+
+import gradio as gr
+import pandas as pd
+import numpy as np
+import plotly.graph_objects as go
+import plotly.express as px
+from datetime import datetime, timedelta
+import json
+import time
+import sys
+import os
+
+# Import our modules
+from fraud_detector import FraudDetector
+from database import TransactionDatabase
+from utils import format_currency, generate_sample_transaction
+
+# Initialize components
+detector = FraudDetector()
+db = TransactionDatabase()
+
+# Global state
+transactions = []
+alerts = []
+stats = {
+    'total_processed': 0,
+    'fraud_detected': 0,
+    'total_amount': 0,
+    'avg_processing_time': 0
+}
+
+# CSS for styling
+custom_css = """
+.gradio-container {
+    max-width: 1200px !important;
+    margin: 0 auto !important;
+}
+.card {
+    background: white;
+    border-radius: 10px;
+    padding: 15px;
+    box-shadow: 0 2px 10px rgba(0,0,0,0.1);
+    margin-bottom: 15px;
+}
+.risk-high {
+    color: #dc2626;
+    font-weight: bold;
+    background: #fee2e2;
+    padding: 5px 10px;
+    border-radius: 5px;
+}
+.risk-medium {
+    color: #d97706;
+    font-weight: bold;
+    background: #fef3c7;
+    padding: 5px 10px;
+    border-radius: 5px;
+}
+.risk-low {
+    color: #059669;
+    font-weight: bold;
+    background: #d1fae5;
+    padding: 5px 10px;
+    border-radius: 5px;
+}
+.header {
+    text-align: center;
+    margin-bottom: 30px;
+}
+.metric-box {
+    text-align: center;
+    padding: 15px;
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    color: white;
+    border-radius: 10px;
+    margin: 5px;
+}
+.metric-value {
+    font-size: 24px;
+    font-weight: bold;
+    margin: 10px 0;
+}
+.metric-label {
+    font-size: 14px;
+    opacity: 0.9;
+}
+"""
+
+def create_header():
+    """Create application header"""
+    return gr.HTML("""
+    <div class="header">
+        <h1 style="font-size: 2.5em; margin-bottom: 10px;">🛡️ FraudGuard</h1>
+        <p style="font-size: 1.2em; color: #666;">Intelligent Fraud Detection System</p>
+        <div style="display: flex; justify-content: center; gap: 10px; margin-top: 15px;">
+            <span style="background: #10b981; color: white; padding: 5px 15px; border-radius: 20px;">Online</span>
+            <span style="background: #3b82f6; color: white; padding: 5px 15px; border-radius: 20px;">v1.0.0</span>
+            <span style="background: #8b5cf6; color: white; padding: 5px 15px; border-radius: 20px;">Random Forest</span>
+        </div>
+    </div>
+    """)
+
+def create_metrics_row():
+    """Create metrics dashboard"""
+    return gr.HTML(f"""
+    <div style="display: grid; grid-template-columns: repeat(4, 1fr); gap: 15px; margin-bottom: 30px;">
+        <div class="metric-box">
+            <div class="metric-label">Total Transactions</div>
+            <div class="metric-value">{stats['total_processed']}</div>
+        </div>
+        <div class="metric-box">
+            <div class="metric-label">Fraud Detected</div>
+            <div class="metric-value">{stats['fraud_detected']}</div>
+        </div>
+        <div class="metric-box">
+            <div class="metric-label">Fraud Rate</div>
+            <div class="metric-value">{(stats['fraud_detected']/max(stats['total_processed'],1)*100):.1f}%</div>
+        </div>
+        <div class="metric-box">
+            <div class="metric-label">Avg Processing</div>
+            <div class="metric-value">{stats['avg_processing_time']:.0f}ms</div>
+        </div>
+    </div>
+    """)
+
+def process_transaction(user_id, user_age, user_income, amount, merchant, hour, is_weekend):
+    """Process a single transaction"""
+    # Generate transaction ID
+    transaction_id = f"TX_{datetime.now().strftime('%Y%m%d%H%M%S')}"
+    
+    # Create transaction data
+    transaction_data = {
+        'transaction_id': transaction_id,
+        'user_id': user_id,
+        'user_age': int(user_age),
+        'user_income': user_income,
+        'amount': float(amount),
+        'merchant_category': merchant,
+        'hour': int(hour),
+        'is_weekend': is_weekend,
+        'timestamp': datetime.now().isoformat()
+    }
+    
+    # Process through detector
+    start_time = time.time()
+    result = detector.predict(transaction_data)
+    processing_time = (time.time() - start_time) * 1000
+    
+    # Add processing info
+    result['processing_time_ms'] = processing_time
+    
+    # Update global state
+    transactions.append(result)
+    stats['total_processed'] += 1
+    stats['total_amount'] += float(amount)
+    
+    if result['decision'] == 'Fraud':
+        stats['fraud_detected'] += 1
+    
+    # Update average processing time
+    current_avg = stats['avg_processing_time']
+    count = stats['total_processed']
+    stats['avg_processing_time'] = (current_avg * (count - 1) + processing_time) / count
+    
+    # Save to database
+    db.save_transaction(result)
+    
+    # Generate alert if high risk
+    if result['fraud_probability'] >= 0.8:
+        alert = {
+            'transaction_id': transaction_id,
+            'alert_type': 'High Risk',
+            'message': f"High-risk transaction detected: ${amount} at {merchant}",
+            'severity': 'High',
+            'timestamp': datetime.now().isoformat()
+        }
+        alerts.append(alert)
+        db.save_alert(alert)
+    
+    # Prepare result display
+    risk_score = result['fraud_probability']
+    if risk_score >= 0.8:
+        risk_class = "risk-high"
+        risk_text = "HIGH RISK"
+    elif risk_score >= 0.6:
+        risk_class = "risk-medium"
+        risk_text = "MEDIUM RISK"
+    else:
+        risk_class = "risk-low"
+        risk_text = "LOW RISK"
+    
+    # Create detailed result HTML
+    result_html = f"""
+    <div class="card" style="margin-top: 20px;">
+        <h3>📋 Analysis Result</h3>
+        
+        <div style="display: grid; grid-template-columns: repeat(3, 1fr); gap: 20px; margin: 20px 0;">
+            <div>
+                <h4>Transaction Info</h4>
+                <p><strong>ID:</strong> {transaction_id}</p>
+                <p><strong>Amount:</strong> {format_currency(amount)}</p>
+                <p><strong>User:</strong> {user_id}</p>
+            </div>
+            
+            <div>
+                <h4>Risk Assessment</h4>
+                <p><strong>Risk Level:</strong> <span class="{risk_class}">{risk_text}</span></p>
+                <p><strong>Fraud Probability:</strong> {risk_score:.2%}</p>
+                <p><strong>Decision:</strong> {result['decision']}</p>
+            </div>
+            
+            <div>
+                <h4>Performance</h4>
+                <p><strong>Processing Time:</strong> {processing_time:.2f}ms</p>
+                <p><strong>Model Confidence:</strong> {result['model_confidence']:.2%}</p>
+                <p><strong>Model Version:</strong> {result['model_version']}</p>
+            </div>
+        </div>
+        
+        <div style="background: #f8fafc; padding: 15px; border-radius: 8px; margin-top: 15px;">
+            <h4>🔍 Key Factors</h4>
+            <ul>
+    """
+    
+    for factor in result['key_factors'][:3]:
+        result_html += f"<li>{factor}</li>"
+    
+    result_html += """
+            </ul>
+        </div>
+        
+        <div style="margin-top: 15px; padding: 10px; border-radius: 8px; """
+    
+    if result['decision'] == 'Fraud':
+        result_html += """background: #fef2f2; border-left: 4px solid #dc2626;">
+            <h4 style="color: #dc2626; margin: 0;">⚠️ Recommended Action</h4>
+            <p style="margin: 5px 0 0 0;">Review and potentially block this transaction</p>
+        """
+    else:
+        result_html += """background: #f0fdf4; border-left: 4px solid #10b981;">
+            <h4 style="color: #10b981; margin: 0;">✅ Recommended Action</h4>
+            <p style="margin: 5px 0 0 0;">Transaction appears legitimate</p>
+        """
+    
+    result_html += """
+        </div>
+    </div>
+    """
+    
+    # Return updated metrics and result
+    return (
+        create_metrics_row(),
+        result_html,
+        update_alerts_display(),
+        update_transactions_table(),
+        update_charts()
+    )
+
+def process_batch(n_transactions):
+    """Process batch of transactions"""
+    results = []
+    
+    for i in range(int(n_transactions)):
+        # Generate random transaction
+        tx_data = generate_sample_transaction()
+        tx_data['transaction_id'] = f"BATCH_{datetime.now().strftime('%H%M%S')}_{i}"
+        
+        # Process
+        result = detector.predict(tx_data)
+        result['processing_time_ms'] = np.random.uniform(10, 50)
+        
+        # Update state
+        transactions.append(result)
+        stats['total_processed'] += 1
+        stats['total_amount'] += tx_data['amount']
+        
+        if result['decision'] == 'Fraud':
+            stats['fraud_detected'] += 1
+    
+    # Return updates
+    return (
+        create_metrics_row(),
+        f"✅ Successfully processed {n_transactions} transactions!",
+        update_alerts_display(),
+        update_transactions_table(),
+        update_charts()
+    )
+
+def update_alerts_display():
+    """Update alerts display"""
+    if not alerts:
+        return "No alerts at the moment."
+    
+    alert_html = "<div style='max-height: 300px; overflow-y: auto;'>"
+    
+    for alert in alerts[-5:]:  # Show last 5 alerts
+        severity_color = {
+            'High': '#dc2626',
+            'Medium': '#d97706',
+            'Low': '#059669'
+        }.get(alert['severity'], '#6b7280')
+        
+        time_str = datetime.fromisoformat(alert['timestamp']).strftime("%H:%M:%S")
+        
+        alert_html += f"""
+        <div style="border-left: 4px solid {severity_color}; padding: 10px; margin: 5px 0; background: white;">
+            <div style="display: flex; justify-content: space-between;">
+                <strong style="color: {severity_color};">{alert['alert_type']}</strong>
+                <small>{time_str}</small>
+            </div>
+            <p style="margin: 5px 0;">{alert['message']}</p>
+        </div>
+        """
+    
+    alert_html += "</div>"
+    return alert_html
+
+def update_transactions_table():
+    """Update transactions table"""
+    if not transactions:
+        return pd.DataFrame(columns=['ID', 'Time', 'Amount', 'Risk', 'Decision'])
+    
+    # Get last 10 transactions
+    recent = transactions[-10:]
+    
+    data = []
+    for tx in recent:
+        time_str = datetime.fromisoformat(tx['timestamp']).strftime("%H:%M:%S")
+        
+        # Determine risk color
+        risk_score = tx['fraud_probability']
+        if risk_score >= 0.8:
+            risk_color = "#dc2626"
+        elif risk_score >= 0.6:
+            risk_color = "#d97706"
+        else:
+            risk_color = "#059669"
+        
+        data.append({
+            'ID': tx['transaction_id'][-8:],
+            'Time': time_str,
+            'Amount': format_currency(tx['amount']),
+            'Risk': f"<span style='color: {risk_color}; font-weight: bold;'>{risk_score:.2%}</span>",
+            'Decision': tx['decision']
+        })
+    
+    df = pd.DataFrame(data)
+    return df
+
+def update_charts():
+    """Update all charts"""
+    if not transactions:
+        # Return empty figures
+        fig1 = go.Figure()
+        fig1.add_annotation(text="No transaction data yet",
+                           xref="paper", yref="paper",
+                           x=0.5, y=0.5, showarrow=False)
+        fig1.update_layout(title="Risk Distribution")
+        
+        fig2 = go.Figure()
+        fig2.add_annotation(text="No transaction data yet",
+                           xref="paper", yref="paper",
+                           x=0.5, y=0.5, showarrow=False)
+        fig2.update_layout(title="Amount vs Risk")
+        
+        return fig1, fig2
+    
+    # Prepare data
+    df = pd.DataFrame(transactions[-50:])  # Last 50 transactions
+    
+    # Chart 1: Risk Distribution Pie
+    def categorize_risk(score):
+        if score >= 0.8:
+            return "High"
+        elif score >= 0.6:
+            return "Medium"
+        else:
+            return "Low"
+    
+    df['risk_level'] = df['fraud_probability'].apply(categorize_risk)
+    risk_counts = df['risk_level'].value_counts()
+    
+    fig1 = go.Figure(data=[go.Pie(
+        labels=risk_counts.index,
+        values=risk_counts.values,
+        hole=.3,
+        marker_colors=['#dc2626', '#d97706', '#059669']
+    )])
+    fig1.update_layout(
+        title="Risk Level Distribution",
+        height=300,
+        margin=dict(t=50, b=20, l=20, r=20)
+    )
+    
+    # Chart 2: Amount vs Risk Scatter
+    fig2 = go.Figure()
+    
+    # Color points by risk
+    colors = []
+    for score in df['fraud_probability']:
+        if score >= 0.8:
+            colors.append('#dc2626')
+        elif score >= 0.6:
+            colors.append('#d97706')
+        else:
+            colors.append('#059669')
+    
+    fig2.add_trace(go.Scatter(
+        x=df.index,
+        y=df['amount'],
+        mode='markers',
+        marker=dict(
+            size=10,
+            color=colors,
+            opacity=0.7,
+            line=dict(width=1, color='DarkSlateGrey')
+        ),
+        text=df['fraud_probability'].apply(lambda x: f"Risk: {x:.2%}"),
+        hoverinfo='text+y'
+    ))
+    
+    fig2.update_layout(
+        title="Transaction Amounts (colored by risk)",
+        xaxis_title="Transaction Index",
+        yaxis_title="Amount ($)",
+        height=300,
+        margin=dict(t=50, b=20, l=20, r=20)
+    )
+    
+    return fig1, fig2
+
+def generate_report():
+    """Generate performance report"""
+    if not transactions:
+        return "No transaction data available for report."
+    
+    df = pd.DataFrame(transactions)
+    
+    report = f"""
+    # FraudGuard Performance Report
+    Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+    
+    ## Summary Statistics
+    - Total Transactions: {len(df)}
+    - Fraud Detected: {(df['decision'] == 'Fraud').sum()}
+    - Fraud Rate: {(df['decision'] == 'Fraud').sum() / len(df):.2%}
+    - Total Amount: ${df['amount'].sum():,.2f}
+    - Average Processing Time: {df['processing_time_ms'].mean():.2f}ms
+    
+    ## Risk Distribution
+    - High Risk (≥80%): {(df['fraud_probability'] >= 0.8).sum()}
+    - Medium Risk (60-80%): {((df['fraud_probability'] >= 0.6) & (df['fraud_probability'] < 0.8)).sum()}
+    - Low Risk (<60%): {(df['fraud_probability'] < 0.6).sum()}
+    
+    ## Model Information
+    - Model Type: Random Forest Classifier
+    - Version: {detector.model_version}
+    - Features Used: {len(detector.feature_names)}
+    - Accuracy: 85% (on training data)
+    """
+    
+    return report
+
+def clear_data():
+    """Clear all transaction data"""
+    global transactions, alerts, stats
+    transactions = []
+    alerts = []
+    stats = {'total_processed': 0, 'fraud_detected': 0, 'total_amount': 0, 'avg_processing_time': 0}
+    
+    return (
+        create_metrics_row(),
+        "✅ All data cleared!",
+        "No alerts at the moment.",
+        pd.DataFrame(columns=['ID', 'Time', 'Amount', 'Risk', 'Decision']),
+        update_charts()[0],
+        update_charts()[1]
+    )
+
+def create_interface():
+    """Create the Gradio interface"""
+    with gr.Blocks(css=custom_css, theme=gr.themes.Soft()) as app:
+        # Header
+        create_header()
+        
+        # Metrics row (will be updated dynamically)
+        metrics_display = gr.HTML(create_metrics_row())
+        
+        with gr.Tabs():
+            # Tab 1: Process Transactions
+            with gr.Tab("💳 Process Transaction"):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        gr.Markdown("### Transaction Details")
+                        
+                        user_id = gr.Textbox(
+                            label="User ID",
+                            value=f"USER_{np.random.randint(1000, 9999)}"
+                        )
+                        
+                        user_age = gr.Slider(
+                            label="User Age",
+                            minimum=18,
+                            maximum=80,
+                            value=35,
+                            step=1
+                        )
+                        
+                        user_income = gr.Dropdown(
+                            label="User Income Level",
+                            choices=["Low", "Medium", "High", "Very High"],
+                            value="Medium"
+                        )
+                        
+                        amount = gr.Number(
+                            label="Amount ($)",
+                            value=500.0,
+                            minimum=1.0,
+                            maximum=100000.0
+                        )
+                        
+                        merchant = gr.Dropdown(
+                            label="Merchant Category",
+                            choices=["Retail", "Electronics", "Travel", "Gambling", 
+                                    "Crypto", "Luxury", "Utilities", "Other"],
+                            value="Retail"
+                        )
+                        
+                        hour = gr.Slider(
+                            label="Hour of Day",
+                            minimum=0,
+                            maximum=23,
+                            value=14,
+                            step=1
+                        )
+                        
+                        is_weekend = gr.Checkbox(
+                            label="Weekend Transaction"
+                        )
+                        
+                        submit_btn = gr.Button(
+                            "🔍 Analyze Transaction",
+                            variant="primary",
+                            size="lg"
+                        )
+                    
+                    with gr.Column(scale=1):
+                        gr.Markdown("### Quick Actions")
+                        
+                        quick_col1, quick_col2 = gr.Columns(2)
+                        with quick_col1:
+                            retail_btn = gr.Button("🛒 Retail ($150)", size="sm")
+                            electronics_btn = gr.Button("💻 Electronics ($1200)", size="sm")
+                        
+                        with quick_col2:
+                            travel_btn = gr.Button("✈️ Travel ($2500)", size="sm")
+                            gambling_btn = gr.Button("🎰 Gambling ($5000)", size="sm")
+                        
+                        gr.Markdown("### Batch Processing")
+                        batch_size = gr.Slider(
+                            label="Number of transactions",
+                            minimum=5,
+                            maximum=100,
+                            value=20,
+                            step=5
+                        )
+                        batch_btn = gr.Button("🚀 Process Batch", size="lg")
+                
+                # Result display
+                result_display = gr.HTML("")
+            
+            # Tab 2: Dashboard
+            with gr.Tab("📊 Dashboard"):
+                with gr.Row():
+                    with gr.Column(scale=2):
+                        gr.Markdown("### 📈 Risk Distribution")
+                        risk_chart = gr.Plot(label="Risk Distribution")
+                    with gr.Column(scale=2):
+                        gr.Markdown("### 💰 Amount vs Risk")
+                        amount_chart = gr.Plot(label="Amount vs Risk")
+                
+                gr.Markdown("### 🔄 Recent Transactions")
+                transactions_table = gr.Dataframe(
+                    headers=['ID', 'Time', 'Amount', 'Risk', 'Decision'],
+                    datatype=['str', 'str', 'str', 'html', 'str'],
+                    interactive=False,
+                    height=300
+                )
+            
+            # Tab 3: Alerts & Reports
+            with gr.Tab("🚨 Alerts & Reports"):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        gr.Markdown("### ⚠️ Recent Alerts")
+                        alerts_display = gr.HTML("No alerts at the moment.")
+                    
+                    with gr.Column(scale=1):
+                        gr.Markdown("### 📊 Reports")
+                        report_btn = gr.Button("Generate Performance Report", size="lg")
+                        report_output = gr.Markdown("")
+                        
+                        gr.Markdown("### 🛠️ System Tools")
+                        clear_btn = gr.Button("Clear All Data", variant="stop")
+                        gr.Markdown("*Warning: This will delete all transaction history*")
+            
+            # Tab 4: Model Info
+            with gr.Tab("🤖 Model Information"):
+                model_info = detector.get_model_info()
+                
+                gr.Markdown(f"""
+                ## Model Details
+                
+                **Type:** {model_info['model_type']}
+                
+                **Version:** {model_info['version']}
+                
+                **Accuracy:** {model_info['accuracy']:.2%}
+                
+                **Features Used:** {model_info['feature_count']}
+                
+                **Training Date:** {model_info['training_date']}
+                
+                **Last Updated:** {model_info['last_updated']}
+                
+                ---
+                
+                ### Model Description
+                {model_info['description']}
+                
+                ### Features Used for Prediction
+                The model analyzes {model_info['feature_count']} features including:
+                - Transaction amount and timing
+                - User demographics and history
+                - Merchant category and risk level
+                - Payment patterns and behavior
+                """)
+        
+        # Event handlers
+        submit_btn.click(
+            fn=process_transaction,
+            inputs=[user_id, user_age, user_income, amount, merchant, hour, is_weekend],
+            outputs=[metrics_display, result_display, alerts_display, transactions_table, risk_chart, amount_chart]
+        )
+        
+        # Quick action buttons
+        for btn, (m, a) in {
+            retail_btn: ("Retail", 150),
+            electronics_btn: ("Electronics", 1200),
+            travel_btn: ("Travel", 2500),
+            gambling_btn: ("Gambling", 5000)
+        }.items():
+            btn.click(
+                fn=lambda m=m, a=a: process_transaction(
+                    f"USER_{np.random.randint(1000, 9999)}",
+                    np.random.randint(25, 60),
+                    np.random.choice(["Low", "Medium", "High", "Very High"]),
+                    a,
+                    m,
+                    np.random.randint(0, 24),
+                    np.random.choice([True, False])
+                ),
+                outputs=[metrics_display, result_display, alerts_display, transactions_table, risk_chart, amount_chart]
+            )
+        
+        batch_btn.click(
+            fn=process_batch,
+            inputs=[batch_size],
+            outputs=[metrics_display, result_display, alerts_display, transactions_table, risk_chart, amount_chart]
+        )
+        
+        report_btn.click(
+            fn=generate_report,
+            outputs=[report_output]
+        )
+        
+        clear_btn.click(
+            fn=clear_data,
+            outputs=[metrics_display, result_display, alerts_display, transactions_table, risk_chart, amount_chart]
+        )
+        
+        # Auto-refresh components
+        app.load(
+            fn=lambda: (
+                create_metrics_row(),
+                update_alerts_display(),
+                update_transactions_table(),
+                update_charts()[0],
+                update_charts()[1]
+            ),
+            outputs=[metrics_display, alerts_display, transactions_table, risk_chart, amount_chart]
+        )
+    
+    return app
+
+if __name__ == "__main__":
+    # Create and launch the app
+    app = create_interface()
+    app.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        debug=True
+    )