Create app.py

app.py

@@ -0,0 +1,334 @@
+import os
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+import gradio as gr
+import plotly.express as px
+import plotly.graph_objects as go
+from sklearn.ensemble import IsolationForest
+from sklearn.preprocessing import StandardScaler
+import openai
+from datetime import datetime, timedelta
+import json
+
+# Set OpenAI API key from Hugging Face Spaces secrets
+openai.api_key = os.environ.get("OPENAI_API_KEY")
+
+def analyze_transaction_with_ai(transaction_data, suspicious_transactions):
+    """Use OpenAI to analyze suspicious transactions and provide insights"""
+    if not openai.api_key:
+        return "OpenAI API key not found. Please add it to the Hugging Face Spaces secrets."
+    
+    try:
+        # Prepare information for OpenAI
+        suspicious_sample = suspicious_transactions.head(5).to_dict(orient='records')
+        
+        # Get summary statistics
+        summary_stats = {
+            "total_transactions": len(transaction_data),
+            "flagged_transactions": len(suspicious_transactions),
+            "flagged_percentage": round(len(suspicious_transactions) / len(transaction_data) * 100, 2),
+            "avg_transaction_amount": round(transaction_data['amount'].mean(), 2),
+            "suspicious_avg_amount": round(suspicious_transactions['amount'].mean(), 2)
+        }
+        
+        # Create prompt for OpenAI
+        prompt = f"""
+        Analyze these potentially fraudulent transactions and identify patterns or anomalies:
+        
+        Transaction Data Summary:
+        {json.dumps(summary_stats)}
+        
+        Sample of Suspicious Transactions:
+        {json.dumps(suspicious_sample)}
+        
+        Provide a concise fraud analysis report with:
+        1. Key patterns and red flags in these transactions
+        2. Possible fraud scenarios explaining the anomalies
+        3. Recommended next steps for investigation
+        """
+        
+        # Call OpenAI API
+        response = openai.chat.completions.create(
+            model="gpt-3.5-turbo",
+            messages=[
+                {"role": "system", "content": "You are a fraud detection expert helping analyze suspicious financial transactions."},
+                {"role": "user", "content": prompt}
+            ],
+            max_tokens=800
+        )
+        
+        # Return the AI analysis
+        return response.choices[0].message.content
+    
+    except Exception as e:
+        return f"Error in AI analysis: {str(e)}"
+
+def load_and_preprocess_data(file):
+    """Load and preprocess transaction data from CSV or Excel file"""
+    if file is None:
+        return None
+    
+    # Get file extension
+    file_extension = os.path.splitext(file.name)[1].lower()
+    
+    # Read file based on extension
+    if file_extension == '.csv':
+        df = pd.read_csv(file.name)
+    elif file_extension in ['.xlsx', '.xls']:
+        df = pd.read_excel(file.name)
+    else:
+        raise ValueError("Unsupported file format. Please upload a CSV or Excel file.")
+    
+    # Check if the DataFrame is empty
+    if df.empty:
+        raise ValueError("The uploaded file is empty.")
+    
+    # Check for essential columns
+    required_columns = ['transaction_id', 'amount', 'timestamp']
+    missing_columns = [col for col in required_columns if col not in df.columns]
+    
+    if missing_columns:
+        # Try to identify columns that might contain the missing information
+        if 'transaction_id' in missing_columns and any(col.lower().endswith('id') for col in df.columns):
+            potential_id_columns = [col for col in df.columns if col.lower().endswith('id')]
+            if potential_id_columns:
+                df['transaction_id'] = df[potential_id_columns[0]]
+                missing_columns.remove('transaction_id')
+        
+        if 'amount' in missing_columns and any(col.lower() in ['value', 'sum', 'total', 'price'] for col in df.columns):
+            potential_amount_columns = [col for col in df.columns if col.lower() in ['value', 'sum', 'total', 'price']]
+            if potential_amount_columns:
+                df['amount'] = df[potential_amount_columns[0]]
+                missing_columns.remove('amount')
+        
+        if 'timestamp' in missing_columns and any(col.lower() in ['date', 'time', 'datetime'] for col in df.columns):
+            potential_time_columns = [col for col in df.columns if col.lower() in ['date', 'time', 'datetime']]
+            if potential_time_columns:
+                df['timestamp'] = df[potential_time_columns[0]]
+                missing_columns.remove('timestamp')
+    
+    # If still missing required columns, raise error
+    if missing_columns:
+        raise ValueError(f"Missing required columns: {', '.join(missing_columns)}. Please ensure your data includes columns for transaction ID, amount, and timestamp.")
+    
+    # Convert timestamp to datetime if it's not already
+    if not pd.api.types.is_datetime64_any_dtype(df['timestamp']):
+        try:
+            df['timestamp'] = pd.to_datetime(df['timestamp'])
+        except:
+            raise ValueError("Could not convert timestamp column to datetime format.")
+    
+    # Ensure amount is numeric
+    try:
+        df['amount'] = pd.to_numeric(df['amount'])
+    except:
+        raise ValueError("Could not convert amount column to numeric values.")
+    
+    return df
+
+def detect_fraud_and_anomalies(df):
+    """Detect fraud and anomalies in transaction data"""
+    # Create feature set for anomaly detection
+    features = df[['amount']].copy()
+    
+    # Add time-based features if available
+    if 'timestamp' in df.columns:
+        features['hour_of_day'] = df['timestamp'].dt.hour
+        features['day_of_week'] = df['timestamp'].dt.dayofweek
+    
+    # Add other relevant features if available
+    if 'location' in df.columns:
+        # One-hot encode location
+        location_dummies = pd.get_dummies(df['location'], prefix='location')
+        features = pd.concat([features, location_dummies], axis=1)
+    
+    # Standardize features
+    scaler = StandardScaler()
+    scaled_features = scaler.fit_transform(features)
+    
+    # Apply Isolation Forest for anomaly detection
+    clf = IsolationForest(contamination=0.05, random_state=42)
+    df['anomaly_score'] = clf.fit_predict(scaled_features)
+    
+    # Flag anomalies (anomaly_score of -1 indicates an anomaly)
+    df['is_anomaly'] = df['anomaly_score'] == -1
+    
+    # Additional heuristic rules for fraud detection
+    # 1. Unusually large transactions
+    amount_threshold = df['amount'].quantile(0.95)
+    df['high_amount'] = df['amount'] > amount_threshold
+    
+    # 2. Transactions occurring at unusual hours (if timestamp available)
+    if 'timestamp' in df.columns:
+        df['unusual_hour'] = df['timestamp'].dt.hour.isin([0, 1, 2, 3, 4])
+    else:
+        df['unusual_hour'] = False
+    
+    # 3. Calculate transaction frequency by user or account (if available)
+    if 'user_id' in df.columns or 'account_id' in df.columns:
+        id_col = 'user_id' if 'user_id' in df.columns else 'account_id'
+        transaction_counts = df.groupby(id_col).size().reset_index(name='transaction_count')
+        df = df.merge(transaction_counts, on=id_col)
+        df['high_frequency'] = df['transaction_count'] > df['transaction_count'].quantile(0.9)
+    else:
+        df['high_frequency'] = False
+    
+    # 4. Velocity check: multiple transactions in short time period
+    if 'timestamp' in df.columns and ('user_id' in df.columns or 'account_id' in df.columns):
+        id_col = 'user_id' if 'user_id' in df.columns else 'account_id'
+        df = df.sort_values([id_col, 'timestamp'])
+        df['time_diff'] = df.groupby(id_col)['timestamp'].diff().dt.total_seconds().fillna(0)
+        df['rapid_succession'] = df['time_diff'] < 300  # Less than 5 minutes
+    else:
+        df['rapid_succession'] = False
+    
+    # Combine all fraud indicators
+    df['fraud_score'] = (
+        df['is_anomaly'].astype(int) * 3 +  # Weighted more heavily
+        df['high_amount'].astype(int) * 2 +
+        df['unusual_hour'].astype(int) +
+        df['high_frequency'].astype(int) +
+        df['rapid_succession'].astype(int)
+    )
+    
+    # Flag as suspicious if fraud score is above threshold
+    df['is_suspicious'] = df['fraud_score'] >= 3
+    
+    return df
+
+def create_visualizations(df):
+    """Create visualizations for transaction data and anomalies"""
+    visualizations = {}
+    
+    # 1. Distribution of transaction amounts with anomalies highlighted
+    fig1 = px.histogram(
+        df, x='amount', color='is_suspicious',
+        color_discrete_map={True: 'red', False: 'blue'},
+        title='Distribution of Transaction Amounts',
+        labels={'amount': 'Transaction Amount', 'is_suspicious': 'Suspicious'}
+    )
+    visualizations['amount_distribution'] = fig1
+    
+    # 2. Time series of transaction amounts
+    if 'timestamp' in df.columns:
+        fig2 = px.scatter(
+            df, x='timestamp', y='amount', color='is_suspicious',
+            color_discrete_map={True: 'red', False: 'blue'},
+            title='Transaction Amounts Over Time',
+            labels={'amount': 'Transaction Amount', 'timestamp': 'Time', 'is_suspicious': 'Suspicious'}
+        )
+        visualizations['time_series'] = fig2
+    
+    # 3. Fraud score distribution
+    fig3 = px.histogram(
+        df, x='fraud_score',
+        title='Distribution of Fraud Scores',
+        labels={'fraud_score': 'Fraud Score'}
+    )
+    visualizations['fraud_score_dist'] = fig3
+    
+    # 4. Hourly transaction pattern (if timestamp available)
+    if 'timestamp' in df.columns:
+        hourly_counts = df.groupby([df['timestamp'].dt.hour, 'is_suspicious']).size().reset_index(name='count')
+        fig4 = px.line(
+            hourly_counts, x='timestamp', y='count', color='is_suspicious',
+            color_discrete_map={True: 'red', False: 'blue'},
+            title='Hourly Transaction Pattern',
+            labels={'timestamp': 'Hour of Day', 'count': 'Number of Transactions', 'is_suspicious': 'Suspicious'}
+        )
+        visualizations['hourly_pattern'] = fig4
+    
+    return visualizations
+
+def process_transactions(file):
+    """Main function to process transaction data and detect fraud"""
+    try:
+        # Load and preprocess data
+        df = load_and_preprocess_data(file)
+        if df is None:
+            return "No file uploaded", None, None, None, None, None
+        
+        # Detect fraud and anomalies
+        df_with_anomalies = detect_fraud_and_anomalies(df)
+        
+        # Get suspicious transactions
+        suspicious_transactions = df_with_anomalies[df_with_anomalies['is_suspicious']]
+        
+        # Create visualizations
+        visualizations = create_visualizations(df_with_anomalies)
+        
+        # Basic statistics
+        total_transactions = len(df_with_anomalies)
+        suspicious_count = len(suspicious_transactions)
+        suspicious_percentage = round((suspicious_count / total_transactions) * 100, 2)
+        
+        # Format statistics for display
+        stats_summary = f"""
+        ## Transaction Analysis Summary
+        
+        - **Total Transactions**: {total_transactions}
+        - **Suspicious Transactions**: {suspicious_count} ({suspicious_percentage}%)
+        - **Total Transaction Value**: ${df_with_anomalies['amount'].sum():,.2f}
+        - **Suspicious Transaction Value**: ${suspicious_transactions['amount'].sum():,.2f}
+        - **Average Transaction Amount**: ${df_with_anomalies['amount'].mean():,.2f}
+        - **Average Suspicious Amount**: ${suspicious_transactions['amount'].mean():,.2f}
+        """
+        
+        # Get AI analysis of suspicious transactions
+        ai_analysis = analyze_transaction_with_ai(df_with_anomalies, suspicious_transactions)
+        
+        # Return results and visualizations
+        return (
+            stats_summary,
+            ai_analysis,
+            suspicious_transactions.to_csv(index=False),
+            visualizations.get('amount_distribution', None),
+            visualizations.get('time_series', None),
+            visualizations.get('fraud_score_dist', None)
+        )
+    
+    except Exception as e:
+        return f"Error: {str(e)}", None, None, None, None, None
+
+def create_gradio_interface():
+    """Create Gradio interface for the application"""
+    with gr.Blocks(title="AI Fraud Detection System") as app:
+        gr.Markdown("# AI Transaction Fraud & Anomaly Detection System")
+        gr.Markdown("Upload your transaction data (CSV or Excel) to detect potential fraud and anomalies.")
+        
+        with gr.Row():
+            file_input = gr.File(label="Upload Transaction Data", file_types=[".csv", ".xlsx", ".xls"])
+        
+        with gr.Row():
+            submit_btn = gr.Button("Analyze Transactions", variant="primary")
+        
+        with gr.Tabs():
+            with gr.TabItem("Summary"):
+                stats_output = gr.Markdown(label="Statistics Summary")
+                ai_analysis_output = gr.Markdown(label="AI Analysis")
+            
+            with gr.TabItem("Visualizations"):
+                with gr.Row():
+                    amount_dist_plot = gr.Plot(label="Transaction Amount Distribution")
+                
+                with gr.Row():
+                    time_series_plot = gr.Plot(label="Transactions Over Time")
+                    fraud_score_plot = gr.Plot(label="Fraud Score Distribution")
+            
+            with gr.TabItem("Suspicious Transactions"):
+                suspicious_csv = gr.File(label="Download Suspicious Transactions (CSV)")
+        
+        submit_btn.click(
+            process_transactions,
+            inputs=[file_input],
+            outputs=[stats_output, ai_analysis_output, suspicious_csv, 
+                     amount_dist_plot, time_series_plot, fraud_score_plot]
+        )
+    
+    return app
+
+if __name__ == "__main__":
+    app = create_gradio_interface()
+    app.launch(share=True)