Create app.py

app.py

@@ -0,0 +1,605 @@
+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 google.generativeai as genai
+from datetime import datetime, timedelta
+import json
+import tempfile
+
+# Set Google Generative AI API key from Hugging Face Spaces secrets
+genai.configure(api_key=os.environ.get("GEMINI_API_KEY"))
+
+def analyze_dataset_structure(df):
+    """Use Google Gemini to analyze the dataset structure and identify relevant columns"""
+    gemini_api_key = os.environ.get("GEMINI_API_KEY")
+    if not gemini_api_key:
+        return None, "Gemini API key not found. Please add it to the Hugging Face Spaces secrets."
+    
+    try:
+        # Get basic dataset info
+        sample_data = df.head(3).copy()
+        
+        # Convert any non-serializable data types to strings
+        for col in sample_data.columns:
+            if pd.api.types.is_datetime64_any_dtype(sample_data[col]):
+                sample_data[col] = sample_data[col].astype(str)
+            elif isinstance(sample_data[col].iloc[0], (np.int64, np.float64)):
+                sample_data[col] = sample_data[col].astype(float)
+        
+        # Now convert to dict
+        sample_data_dict = sample_data.to_dict(orient='records')
+        
+        column_info = []
+        
+        for col in df.columns:
+            dtype = str(df[col].dtype)
+            unique_values = len(df[col].unique())
+            null_percentage = round((df[col].isna().sum() / len(df)) * 100, 2)
+            
+            # Handle sample values more carefully
+            try:
+                sample_values = df[col].dropna().sample(min(3, len(df[col].dropna()))).tolist()
+                # Convert numpy types to native Python types
+                if isinstance(sample_values, list):
+                    sample_values = [item.item() if hasattr(item, 'item') else str(item) for item in sample_values]
+                sample_values_str = str(sample_values)[:100]  # Limit sample length
+            except:
+                sample_values_str = "Error getting sample values"
+            
+            column_info.append({
+                "column_name": col,
+                "data_type": dtype,
+                "unique_values_count": unique_values,
+                "null_percentage": null_percentage,
+                "sample_values": sample_values_str
+            })
+        
+        # Create prompt for Gemini
+        prompt = f"""
+        Analyze this transaction dataset structure to identify the purpose of each column.
+        
+        Dataset Information:
+        - Number of rows: {len(df)}
+        - Number of columns: {len(df.columns)}
+        
+        Column Information:
+        {json.dumps(column_info, indent=2)}
+        
+        Sample Data:
+        {json.dumps(sample_data_dict, indent=2)}
+        
+        For each column in the dataset, identify its likely purpose in a transaction dataset. 
+        Specifically identify:
+        
+        1. Which column is likely the transaction ID or reference number
+        2. Which column represents the transaction amount or value
+        3. Which column represents the timestamp or date of the transaction
+        4. Which column represents the user ID, account ID, or customer identifier
+        5. Which column might represent location information
+        6. Which columns might be useful for fraud detection (e.g., IP address, device info, transaction status)
+        
+        Return your analysis as a JSON object with this structure:
+        {{
+            "id_column": "column_name",
+            "amount_column": "column_name",
+            "timestamp_column": "column_name",
+            "user_column": "column_name",
+            "location_column": "column_name",
+            "fraud_indicator_columns": ["column1", "column2"],
+            "column_descriptions": {{
+                "column_name": "description of purpose"
+            }}
+        }}
+        
+        Include only columns that you're reasonably confident about, and use null for any category where you can't identify a matching column.
+        """
+        
+        # Create Gemini model
+        model = genai.GenerativeModel('gemini-pro')
+        
+        # Call Gemini API
+        response = model.generate_content(prompt)
+        
+        # Extract JSON from response text
+        response_text = response.text
+        # Find JSON content within the response
+        json_start = response_text.find('{')
+        json_end = response_text.rfind('}') + 1
+        if json_start != -1 and json_end != -1:
+            json_content = response_text[json_start:json_end]
+            structure_analysis = json.loads(json_content)
+        else:
+            raise ValueError("No valid JSON found in response")
+        
+        # Also get a natural language explanation
+        explanation_prompt = f"""
+        Based on your analysis of the dataset structure, provide a brief natural language explanation of:
+        1. What kind of transactions this dataset appears to contain
+        2. What the key columns are and what they represent
+        3. What approach would be best for detecting anomalies or fraud in this specific dataset
+        
+        Keep your explanation concise and focused on the unique characteristics of this dataset.
+        
+        Previous analysis: {json.dumps(structure_analysis)}
+        """
+        
+        explanation_response = model.generate_content(explanation_prompt)
+        explanation = explanation_response.text
+        
+        return structure_analysis, explanation
+    
+    except Exception as e:
+        import traceback
+        error_trace = traceback.format_exc()
+        return None, f"Error analyzing dataset structure: {str(e)}\n\nTrace: {error_trace}"
+
+def load_and_preprocess_data(file):
+    """Load and preprocess transaction data from CSV or Excel file"""
+    if file is None:
+        return None, None, None  # Return three values instead of two
+    
+    # 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.")
+    
+    # Analyze dataset structure with LLM
+    column_mapping, dataset_explanation = analyze_dataset_structure(df)
+    
+    # If LLM analysis failed, perform basic preprocessing
+    if column_mapping is None:
+        return df, dataset_explanation, None  # Return three values with column_mapping as None
+    
+    # Process the data based on identified columns
+    processed_df = df.copy()
+    
+    # Convert timestamp to datetime if identified
+    timestamp_col = column_mapping.get("timestamp_column")
+    if timestamp_col and timestamp_col in df.columns:
+        try:
+            processed_df[timestamp_col] = pd.to_datetime(df[timestamp_col])
+        except:
+            print(f"Warning: Could not convert {timestamp_col} to datetime format.")
+    
+    # Ensure amount column is numeric if identified
+    amount_col = column_mapping.get("amount_column")
+    if amount_col and amount_col in df.columns:
+        try:
+            processed_df[amount_col] = pd.to_numeric(df[amount_col])
+        except:
+            print(f"Warning: Could not convert {amount_col} to numeric values.")
+    
+    return processed_df, dataset_explanation, column_mapping
+
+def detect_fraud_and_anomalies(df, column_mapping):
+    """Detect fraud and anomalies in transaction data based on LLM-identified columns"""
+    # Create feature set for anomaly detection
+    features = pd.DataFrame()
+    
+    # Add amount feature if available
+    amount_col = column_mapping.get("amount_column")
+    if amount_col and amount_col in df.columns:
+        features['amount'] = df[amount_col]
+    
+    # Add time-based features if available
+    timestamp_col = column_mapping.get("timestamp_column")
+    if timestamp_col and timestamp_col in df.columns and pd.api.types.is_datetime64_any_dtype(df[timestamp_col]):
+        # Extract hour and day of week
+        features['hour_of_day'] = pd.to_numeric(df[timestamp_col].dt.hour)
+        features['day_of_week'] = pd.to_numeric(df[timestamp_col].dt.dayofweek)
+    
+    # Add location feature if available
+    location_col = column_mapping.get("location_column")
+    if location_col and location_col in df.columns:
+        # One-hot encode location
+        location_dummies = pd.get_dummies(df[location_col], prefix='location')
+        features = pd.concat([features, location_dummies], axis=1)
+    
+    # Add fraud indicator columns if identified
+    fraud_indicators = column_mapping.get("fraud_indicator_columns", [])
+    for col in fraud_indicators:
+        if col in df.columns:
+            if pd.api.types.is_numeric_dtype(df[col]):
+                features[col] = df[col]
+            else:
+                # One-hot encode categorical indicators
+                indicator_dummies = pd.get_dummies(df[col], prefix=col)
+                features = pd.concat([features, indicator_dummies], axis=1)
+    
+    # If still no features available, use all numeric columns
+    if features.empty or features.shape[1] < 2:
+        numeric_cols = df.select_dtypes(include=['number']).columns.tolist()
+        if numeric_cols:
+            for col in numeric_cols:
+                if col not in features.columns:
+                    features[col] = df[col]
+    
+    # If still not enough features, add dummy feature
+    if features.empty or features.shape[1] < 2:
+        features['dummy1'] = np.random.random(len(df))
+        features['dummy2'] = np.random.random(len(df))
+    
+    # Standardize features
+    scaler = StandardScaler()
+    scaled_features = scaler.fit_transform(features)
+    
+    # Apply Isolation Forest for anomaly detection
+    clf = IsolationForest(contamination=0.05, random_state=42)
+    anomaly_scores = clf.fit_predict(scaled_features)
+    
+    # Create a result DataFrame with original data and anomaly scores
+    result_df = df.copy()
+    
+    # Add anomaly flags
+    result_df['anomaly_score'] = anomaly_scores
+    result_df['is_anomaly'] = result_df['anomaly_score'] == -1
+    
+    # Initialize fraud indicators
+    result_df['high_amount'] = False
+    result_df['unusual_hour'] = False
+    result_df['high_frequency'] = False
+    result_df['rapid_succession'] = False
+    
+    # 1. Unusually large transactions (if amount column is available)
+    if amount_col and amount_col in df.columns:
+        amount_threshold = df[amount_col].quantile(0.95)
+        result_df['high_amount'] = df[amount_col] > amount_threshold
+    
+    # 2. Transactions occurring at unusual hours (if timestamp available)
+    if timestamp_col and timestamp_col in df.columns and pd.api.types.is_datetime64_any_dtype(df[timestamp_col]):
+        hours = np.array(df[timestamp_col].dt.hour)
+        result_df['unusual_hour'] = np.isin(hours, [0, 1, 2, 3, 4])
+    
+    # 3. Calculate transaction frequency by user or account (if available)
+    user_col = column_mapping.get("user_column")
+    if user_col and user_col in df.columns:
+        transaction_counts = df.groupby(user_col).size().reset_index(name='transaction_count')
+        result_df = result_df.merge(transaction_counts, on=user_col, how='left')
+        result_df['high_frequency'] = result_df['transaction_count'] > result_df['transaction_count'].quantile(0.9)
+    
+    # 4. Velocity check: multiple transactions in short time period
+    if timestamp_col and user_col and timestamp_col in df.columns and user_col in df.columns:
+        if pd.api.types.is_datetime64_any_dtype(df[timestamp_col]):
+            velocity_df = df[[timestamp_col, user_col]].copy().sort_values([user_col, timestamp_col])
+            velocity_df['time_diff'] = velocity_df.groupby(user_col)[timestamp_col].diff()
+            
+            # Handle potential NaT values
+            velocity_df['time_diff_seconds'] = velocity_df['time_diff'].dt.total_seconds().fillna(0)
+            velocity_df['rapid_succession'] = velocity_df['time_diff_seconds'] < 300  # Less than 5 minutes
+            
+            # Map back to the original DataFrame
+            result_df = result_df.merge(
+                velocity_df[['rapid_succession']], 
+                left_index=True, 
+                right_index=True,
+                how='left'
+            )
+            result_df['rapid_succession'] = result_df['rapid_succession'].fillna(False)
+    
+    # Combine all fraud indicators with adaptive weighting
+    weights = {
+        'is_anomaly': 3,  # Base weight for anomaly detection
+        'high_amount': 2,
+        'unusual_hour': 1,
+        'high_frequency': 1,
+        'rapid_succession': 1
+    }
+    
+    # Calculate fraud score based on available indicators
+    result_df['fraud_score'] = 0
+    for indicator, weight in weights.items():
+        if indicator in result_df.columns:
+            result_df['fraud_score'] += result_df[indicator].astype(int) * weight
+    
+    # Flag as suspicious if fraud score is above threshold (adapt based on available indicators)
+    available_weights = sum([weight for indicator, weight in weights.items() if indicator in result_df.columns])
+    threshold = max(3, available_weights * 0.3)  # At least 3 or 30% of max possible score
+    result_df['is_suspicious'] = result_df['fraud_score'] >= threshold
+    
+    return result_df
+
+def create_visualizations(df, column_mapping):
+    """Create visualizations for transaction data and anomalies based on LLM-identified columns"""
+    visualizations = {}
+    
+    try:
+        # Prepare a copy for plotting
+        plot_df = df.copy()
+        
+        # Get important columns
+        timestamp_col = column_mapping.get("timestamp_column")
+        amount_col = column_mapping.get("amount_column")
+        user_col = column_mapping.get("user_column")
+        
+        # Convert timestamp to string for plotly if it exists
+        if timestamp_col and timestamp_col in plot_df.columns:
+            if pd.api.types.is_datetime64_any_dtype(plot_df[timestamp_col]):
+                plot_df['timestamp_str'] = plot_df[timestamp_col].dt.strftime('%Y-%m-%d %H:%M:%S')
+        
+        # 1. Distribution of transaction amounts with anomalies highlighted (if amount column exists)
+        if amount_col and amount_col in plot_df.columns:
+            fig1 = px.histogram(
+                plot_df, x=amount_col, color='is_suspicious',
+                color_discrete_map={True: 'red', False: 'blue'},
+                title='Distribution of Transaction Amounts',
+                labels={amount_col: 'Transaction Amount', 'is_suspicious': 'Suspicious'}
+            )
+            fig1.update_layout(height=500, width=700)
+            visualizations['amount_distribution'] = fig1
+        
+        # 2. Time series of transaction amounts (if both timestamp and amount columns exist)
+        if timestamp_col and amount_col and 'timestamp_str' in plot_df.columns:
+            fig2 = px.scatter(
+                plot_df, x='timestamp_str', y=amount_col, color='is_suspicious',
+                color_discrete_map={True: 'red', False: 'blue'},
+                title='Transaction Amounts Over Time',
+                labels={amount_col: 'Transaction Amount', 'timestamp_str': 'Time', 'is_suspicious': 'Suspicious'}
+            )
+            fig2.update_layout(height=500, width=700)
+            visualizations['time_series'] = fig2
+        
+        # 3. Fraud score distribution
+        fig3 = px.histogram(
+            plot_df, x='fraud_score',
+            title='Distribution of Fraud Scores',
+            labels={'fraud_score': 'Fraud Score'}
+        )
+        fig3.update_layout(height=500, width=700)
+        visualizations['fraud_score_dist'] = fig3
+        
+        # 4. User transaction frequency (if user column exists)
+        if user_col and user_col in plot_df.columns:
+            user_counts = plot_df.groupby([user_col, 'is_suspicious']).size().reset_index(name='count')
+            # Limit to top 20 users by transaction count
+            top_users = plot_df.groupby(user_col).size().sort_values(ascending=False).head(20).index
+            user_counts_filtered = user_counts[user_counts[user_col].isin(top_users)]
+            
+            fig4 = px.bar(
+                user_counts_filtered, x=user_col, y='count', color='is_suspicious',
+                color_discrete_map={True: 'red', False: 'blue'},
+                title='Transaction Frequency by User (Top 20)',
+                labels={user_col: 'User', 'count': 'Number of Transactions', 'is_suspicious': 'Suspicious'}
+            )
+            fig4.update_layout(height=500, width=700)
+            visualizations['user_frequency'] = fig4
+        
+        # 5. Hourly transaction pattern (if timestamp available)
+        if timestamp_col and timestamp_col in plot_df.columns:
+            if pd.api.types.is_datetime64_any_dtype(plot_df[timestamp_col]):
+                # Get hourly data
+                hourly_counts = plot_df.groupby([plot_df[timestamp_col].dt.hour, 'is_suspicious']).size()
+                hourly_df = hourly_counts.reset_index()
+                hourly_df.columns = ['hour', 'is_suspicious', 'count']
+                
+                fig5 = px.line(
+                    hourly_df, x='hour', y='count', color='is_suspicious',
+                    color_discrete_map={True: 'red', False: 'blue'},
+                    title='Hourly Transaction Pattern',
+                    labels={'hour': 'Hour of Day', 'count': 'Number of Transactions', 'is_suspicious': 'Suspicious'}
+                )
+                fig5.update_layout(height=500, width=700)
+                visualizations['hourly_pattern'] = fig5
+    
+    except Exception as e:
+        print(f"Error in visualization creation: {str(e)}")
+    
+    return visualizations
+
+def analyze_transaction_with_ai(transaction_data, suspicious_transactions, column_mapping):
+    """Use Google Gemini to analyze suspicious transactions and provide insights"""
+    gemini_api_key = os.environ.get("GEMINI_API_KEY")
+    if not gemini_api_key:
+        return "Gemini API key not found. Please add it to the Hugging Face Spaces secrets."
+    
+    try:
+        # Prepare information for Gemini, converting to a JSON-serializable format
+        suspicious_sample = suspicious_transactions.head(5).copy()
+        
+        # Convert any datetime columns to string format to make it JSON serializable
+        for col in suspicious_sample.columns:
+            if pd.api.types.is_datetime64_any_dtype(suspicious_sample[col]):
+                suspicious_sample[col] = suspicious_sample[col].astype(str)
+            # Convert NumPy types to Python native types
+            elif suspicious_sample[col].dtype in (np.int64, np.float64):
+                suspicious_sample[col] = suspicious_sample[col].astype(float)
+            # Handle boolean columns
+            elif suspicious_sample[col].dtype == bool:
+                suspicious_sample[col] = suspicious_sample[col].astype(str)
+        
+        # Convert to dictionary
+        suspicious_dict = suspicious_sample.to_dict(orient='records')
+        
+        # Get summary statistics
+        summary_stats = {
+            "total_transactions": int(len(transaction_data)),
+            "flagged_transactions": int(len(suspicious_transactions)),
+            "flagged_percentage": float(round(len(suspicious_transactions) / len(transaction_data) * 100, 2)),
+        }
+        
+        # Add amount-related statistics if available
+        amount_col = column_mapping.get("amount_column")
+        if amount_col and amount_col in transaction_data.columns:
+            summary_stats.update({
+                "avg_transaction_amount": float(round(transaction_data[amount_col].mean(), 2)),
+                "suspicious_avg_amount": float(round(suspicious_transactions[amount_col].mean(), 2))
+            })
+        
+        # Create prompt for Gemini
+        prompt = f"""
+        Analyze these potentially fraudulent transactions and identify patterns or anomalies:
+        
+        Transaction Data Summary:
+        {json.dumps(summary_stats)}
+        
+        Column Mapping:
+        {json.dumps(column_mapping)}
+        
+        Sample of Suspicious Transactions:
+        {json.dumps(suspicious_dict)}
+        
+        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
+        """
+        
+        # Create Gemini model
+        model = genai.GenerativeModel('gemini-pro')
+        
+        # Call Gemini API
+        response = model.generate_content(prompt)
+        
+        # Return the AI analysis
+        return response.text
+    
+    except Exception as e:
+        import traceback
+        error_trace = traceback.format_exc()
+        return f"Error in AI analysis: {str(e)}\n\nTrace: {error_trace}"    
+
+def process_transactions(file):
+    """Main function to process transaction data and detect fraud"""
+    try:
+        # Load and preprocess data with LLM-based analysis
+        processed_df, dataset_explanation, column_mapping = load_and_preprocess_data(file)
+        
+        if processed_df is None:
+            return "No file uploaded or error in processing", None, None, None, None, None
+        
+        # If column_mapping is None, only dataset_explanation was returned (containing error message)
+        if column_mapping is None:
+            return f"Error analyzing dataset: {dataset_explanation}", None, None, None, None, None
+        
+        # Detect fraud and anomalies using the LLM-identified column mapping
+        df_with_anomalies = detect_fraud_and_anomalies(processed_df, column_mapping)
+        
+        # Get suspicious transactions
+        suspicious_transactions = df_with_anomalies[df_with_anomalies['is_suspicious']]
+        
+        # Create visualizations using the identified columns
+        visualizations = create_visualizations(df_with_anomalies, column_mapping)
+        
+        # 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}%)
+        """
+        
+        # Add amount-related statistics if available
+        amount_col = column_mapping.get("amount_column")
+        if amount_col and amount_col in df_with_anomalies.columns:
+            stats_summary += f"""
+        - **Total Transaction Value**: ${df_with_anomalies[amount_col].sum():,.2f}
+        - **Suspicious Transaction Value**: ${suspicious_transactions[amount_col].sum():,.2f}
+        - **Average Transaction Amount**: ${df_with_anomalies[amount_col].mean():,.2f}
+        - **Average Suspicious Amount**: ${suspicious_transactions[amount_col].mean():,.2f}
+            """
+        
+        # Add dataset explanation from LLM
+        stats_summary += f"""
+        ## Dataset Analysis
+        
+        {dataset_explanation}
+        
+        ## Detected Columns
+        """
+        for purpose, col_name in column_mapping.items():
+            if col_name and purpose not in ["column_descriptions", "fraud_indicator_columns"]:
+                stats_summary += f"- **{purpose.replace('_column', '')}**: {col_name}\n"
+        
+        if column_mapping.get("fraud_indicator_columns"):
+            stats_summary += "\n**Potential Fraud Indicator Columns**:\n"
+            for col in column_mapping.get("fraud_indicator_columns", []):
+                stats_summary += f"- {col}\n"
+        
+        # Get AI analysis of suspicious transactions
+        ai_analysis = analyze_transaction_with_ai(df_with_anomalies, suspicious_transactions, column_mapping)
+        
+        # Save suspicious transactions to a temporary file
+        temp_csv = tempfile.NamedTemporaryFile(delete=False, suffix='.csv')
+        suspicious_transactions.to_csv(temp_csv.name, index=False)
+        temp_csv.close()
+        
+        # Return results and visualizations
+        return (
+            stats_summary,
+            ai_analysis,
+            temp_csv.name,  # Return the path to the temporary file
+            visualizations.get('amount_distribution', None),
+            visualizations.get('time_series', None),
+            visualizations.get('fraud_score_dist', None)
+        )
+    
+    except Exception as e:
+        import traceback
+        error_trace = traceback.format_exc()
+        return f"Error: {str(e)}\n\nTrace: {error_trace}", 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. The system will use AI to analyze your dataset structure and identify relevant columns.")
+        
+        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__":
+    # Enable debug mode to get detailed error messages
+    import logging
+    logging.basicConfig(level=logging.DEBUG)
+    
+    app = create_gradio_interface()
+    app.launch(share=True)