Create app.py

app.py

@@ -0,0 +1,238 @@
+import pandas as pd
+import numpy as np
+import gradio as gr
+import matplotlib.pyplot as plt
+import seaborn as sns
+from datetime import datetime
+from sklearn.metrics import confusion_matrix, precision_score, recall_score
+
+# Sample data preparation (in a real scenario, you would load your data)
+# Converting your sample data to a DataFrame
+data = {
+    'transaction_amount': [2500, 799, 9338, 11749, 8999, 1500, 3000, 4000, 300, 5000, 24990],
+    'transaction_date': ['01-11-2024 16:08', '01-11-2024 16:15', '02-11-2024 14:43', '03-11-2024 11:14', 
+                         '04-11-2024 12:54', '06-11-2024 08:36', '06-11-2024 08:56', '06-11-2024 09:08', 
+                         '06-11-2024 09:29', '06-11-2024 13:05', '06-11-2024 15:12'],
+    'transaction_channel': ['mobile', 'mobile', 'mobile', 'mobile', 'mobile', 'W', 'W', 'W', 'W', 'W', 'mobile'],
+    'is_fraud': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+    'transaction_payment_mode_anonymous': [10, 10, 2, 6, 2, 10, 10, 10, 10, 10, 2],
+    'payment_gateway_bank_anonymous': [6, 6, 6, 58, 6, 6, 6, 6, 6, 6, 6],
+    'payer_browser_anonymous': [1833, 1833, 2766, 3378, 2766, 3212, 3212, 3212, 3212, 3212, 2721],
+    'transaction_id_anonymous': ['ANON_9629', 'ANON_9764', 'ANON_27514', 'ANON_41176', 'ANON_66597', 
+                                'ANON_134329', 'ANON_134618', 'ANON_134815', 'ANON_135218', 
+                                'ANON_147464', 'ANON_155578'],
+    'payee_id_anonymous': ['ANON_47', 'ANON_47', 'ANON_265', 'ANON_8', 'ANON_265', 'ANON_12', 
+                          'ANON_12', 'ANON_12', 'ANON_12', 'ANON_12', 'ANON_265']
+}
+
+df = pd.DataFrame(data)
+
+# Convert date strings to datetime objects
+df['transaction_date'] = pd.to_datetime(df['transaction_date'], format='%d-%m-%Y %H:%M')
+
+# Add simulated predicted fraud and reported fraud columns
+# In a real scenario, these would come from your model and reports
+np.random.seed(42)
+df['is_fraud_predicted'] = np.random.choice([0, 1], size=len(df), p=[0.3, 0.7])
+df['is_fraud_reported'] = np.random.choice([0, 1], size=len(df), p=[0.4, 0.6])
+
+def filter_data(start_date, end_date, payer_id, payee_id, transaction_id):
+    filtered_df = df.copy()
+    
+    # Convert string dates to datetime for comparison
+    start_date = pd.to_datetime(start_date)
+    end_date = pd.to_datetime(end_date)
+    
+    # Apply filters
+    filtered_df = filtered_df[(filtered_df['transaction_date'] >= start_date) & 
+                             (filtered_df['transaction_date'] <= end_date)]
+    
+    if payer_id:
+        filtered_df = filtered_df[filtered_df['transaction_id_anonymous'] == payer_id]
+    
+    if payee_id:
+        filtered_df = filtered_df[filtered_df['payee_id_anonymous'] == payee_id]
+    
+    if transaction_id:
+        filtered_df = filtered_df[filtered_df['transaction_id_anonymous'] == transaction_id]
+    
+    return filtered_df
+
+def create_comparison_chart(dimension, filtered_df):
+    if filtered_df.empty:
+        return plt.figure()
+    
+    plt.figure(figsize=(10, 6))
+    
+    if dimension == 'Transaction Channel':
+        group_col = 'transaction_channel'
+    elif dimension == 'Transaction Payment Mode':
+        group_col = 'transaction_payment_mode_anonymous'
+    elif dimension == 'Payment Gateway Bank':
+        group_col = 'payment_gateway_bank_anonymous'
+    elif dimension == 'Payer ID':
+        group_col = 'transaction_id_anonymous'
+    elif dimension == 'Payee ID':
+        group_col = 'payee_id_anonymous'
+    else:
+        return plt.figure()
+    
+    # Group by the selected dimension and count predicted and reported frauds
+    predicted = filtered_df.groupby(group_col)['is_fraud_predicted'].sum()
+    reported = filtered_df.groupby(group_col)['is_fraud_reported'].sum()
+    
+    # Create a DataFrame for plotting
+    plot_df = pd.DataFrame({
+        'Predicted Fraud': predicted,
+        'Reported Fraud': reported
+    })
+    
+    # Plot
+    plot_df.plot(kind='bar', figsize=(10, 6))
+    plt.title(f'Fraud Comparison by {dimension}')
+    plt.ylabel('Count')
+    plt.xlabel(dimension)
+    plt.tight_layout()
+    
+    return plt
+
+def create_time_series(filtered_df, granularity):
+    if filtered_df.empty:
+        return plt.figure()
+    
+    plt.figure(figsize=(12, 6))
+    
+    # Set the time grouping based on granularity
+    if granularity == 'Day':
+        time_group = filtered_df['transaction_date'].dt.date
+    elif granularity == 'Hour':
+        time_group = filtered_df['transaction_date'].dt.strftime('%Y-%m-%d %H')
+    elif granularity == 'Minute':
+        time_group = filtered_df['transaction_date'].dt.strftime('%Y-%m-%d %H:%M')
+    else:
+        return plt.figure()
+    
+    # Group by time and count predicted and reported frauds
+    predicted = filtered_df.groupby(time_group)['is_fraud_predicted'].sum()
+    reported = filtered_df.groupby(time_group)['is_fraud_reported'].sum()
+    
+    # Plot
+    plt.plot(predicted.index, predicted.values, 'b-', label='Predicted Fraud')
+    plt.plot(reported.index, reported.values, 'r-', label='Reported Fraud')
+    plt.title('Fraud Trend Over Time')
+    plt.ylabel('Count')
+    plt.xlabel('Time')
+    plt.legend()
+    plt.xticks(rotation=45)
+    plt.tight_layout()
+    
+    return plt
+
+def calculate_metrics(filtered_df):
+    if filtered_df.empty:
+        return None, 0, 0
+    
+    # Calculate confusion matrix
+    cm = confusion_matrix(filtered_df['is_fraud'], filtered_df['is_fraud_predicted'])
+    
+    # Calculate precision and recall
+    precision = precision_score(filtered_df['is_fraud'], filtered_df['is_fraud_predicted'], zero_division=0)
+    recall = recall_score(filtered_df['is_fraud'], filtered_df['is_fraud_predicted'], zero_division=0)
+    
+    # Create confusion matrix plot
+    plt.figure(figsize=(6, 5))
+    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', 
+                xticklabels=['Not Fraud', 'Fraud'],
+                yticklabels=['Not Fraud', 'Fraud'])
+    plt.ylabel('Actual')
+    plt.xlabel('Predicted')
+    plt.title('Confusion Matrix')
+    
+    return plt, precision, recall
+
+def update_interface(start_date, end_date, payer_id, payee_id, transaction_id, dimension, time_granularity):
+    # Filter data based on inputs
+    filtered_df = filter_data(start_date, end_date, payer_id, payee_id, transaction_id)
+    
+    # Create comparison chart
+    comparison_chart = create_comparison_chart(dimension, filtered_df)
+    
+    # Create time series chart
+    time_series = create_time_series(filtered_df, time_granularity)
+    
+    # Calculate evaluation metrics
+    confusion_matrix_plot, precision, recall = calculate_metrics(filtered_df)
+    
+    # Format the filtered dataframe for display
+    display_df = filtered_df.copy()
+    display_df['transaction_date'] = display_df['transaction_date'].dt.strftime('%Y-%m-%d %H:%M')
+    
+    return (display_df.to_dict('records'), 
+            comparison_chart, 
+            time_series, 
+            confusion_matrix_plot, 
+            f"Precision: {precision:.4f}", 
+            f"Recall: {recall:.4f}")
+
+# Define the Gradio interface
+with gr.Blocks() as demo:
+    gr.Markdown("# Fraud Transaction Analysis Dashboard")
+    
+    with gr.Row():
+        with gr.Column():
+            start_date = gr.Textbox(label="Start Date (YYYY-MM-DD)", value="2024-11-01")
+            end_date = gr.Textbox(label="End Date (YYYY-MM-DD)", value="2024-11-06")
+        
+        with gr.Column():
+            payer_id = gr.Textbox(label="Payer ID")
+            payee_id = gr.Textbox(label="Payee ID")
+            transaction_id = gr.Textbox(label="Transaction ID")
+    
+    with gr.Row():
+        dimension = gr.Dropdown(
+            ["Transaction Channel", "Transaction Payment Mode", "Payment Gateway Bank", "Payer ID", "Payee ID"],
+            label="Comparison Dimension",
+            value="Transaction Channel"
+        )
+        time_granularity = gr.Dropdown(
+            ["Day", "Hour", "Minute"],
+            label="Time Granularity",
+            value="Day"
+        )
+    
+    update_button = gr.Button("Update Dashboard")
+    
+    with gr.Row():
+        gr.Markdown("## Transaction Data")
+    
+    data_table = gr.DataFrame()
+    
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("## Fraud Comparison by Dimension")
+            comparison_plot = gr.Plot()
+        
+        with gr.Column():
+            gr.Markdown("## Fraud Trend Over Time")
+            time_series_plot = gr.Plot()
+    
+    with gr.Row():
+        gr.Markdown("## Model Evaluation")
+    
+    with gr.Row():
+        with gr.Column():
+            confusion_matrix_plot = gr.Plot()
+        
+        with gr.Column():
+            precision_text = gr.Textbox(label="Precision")
+            recall_text = gr.Textbox(label="Recall")
+    
+    update_button.click(
+        update_interface,
+        inputs=[start_date, end_date, payer_id, payee_id, transaction_id, dimension, time_granularity],
+        outputs=[data_table, comparison_plot, time_series_plot, confusion_matrix_plot, precision_text, recall_text]
+    )
+
+# Launch the app
+if __name__ == "__main__":
+    demo.launch()