Update app.py

app.py

@@ -16,7 +16,116 @@ import tempfile
 # 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):
+def analyze_dataset_structure(df):
+    """Use OpenAI to analyze the dataset structure and identify relevant columns"""
+    if not openai.api_key:
+        return None, "OpenAI API key not found. Please add it to the Hugging Face Spaces secrets."
+    
+    try:
+        # Get basic dataset info
+        sample_data = df.head(3).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)
+            sample_values = df[col].dropna().sample(min(3, len(df[col].dropna()))).tolist()
+            
+            column_info.append({
+                "column_name": col,
+                "data_type": dtype,
+                "unique_values_count": unique_values,
+                "null_percentage": null_percentage,
+                "sample_values": str(sample_values)[:100]  # Limit sample length
+            })
+        
+        # Create prompt for OpenAI
+        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, 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 an OpenAI client with the API key
+        client = openai.OpenAI(api_key=openai.api_key)
+        
+        # Call OpenAI API
+        response = client.chat.completions.create(
+            model="gpt-3.5-turbo",
+            messages=[
+                {"role": "system", "content": "You are a data analysis expert specializing in financial transaction data structures."},
+                {"role": "user", "content": prompt}
+            ],
+            max_tokens=1000,
+            response_format={"type": "json_object"}
+        )
+        
+        # Parse the JSON response
+        structure_analysis = json.loads(response.choices[0].message.content)
+        
+        # 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.
+        """
+        
+        explanation_response = client.chat.completions.create(
+            model="gpt-3.5-turbo",
+            messages=[
+                {"role": "system", "content": "You are a data analysis expert specializing in financial transaction data structures."},
+                {"role": "user", "content": prompt},
+                {"role": "assistant", "content": response.choices[0].message.content},
+                {"role": "user", "content": explanation_prompt}
+            ],
+            max_tokens=500
+        )
+        
+        explanation = explanation_response.choices[0].message.content
+        
+        return structure_analysis, explanation
+    
+    except Exception as e:
+        return None, f"Error analyzing dataset structure: {str(e)}"
+
+def analyze_transaction_with_ai(transaction_data, suspicious_transactions, column_mapping):
     """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."
@@ -25,9 +134,10 @@ def analyze_transaction_with_ai(transaction_data, suspicious_transactions):
         # Prepare information for OpenAI, converting to a JSON-serializable format
         suspicious_sample = suspicious_transactions.head(5).copy()
         
-        # Convert timestamp to string format to make it JSON serializable
-        if 'timestamp' in suspicious_sample.columns:
-            suspicious_sample['timestamp'] = suspicious_sample['timestamp'].astype(str)
+        # 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 to dictionary
         suspicious_dict = suspicious_sample.to_dict(orient='records')
@@ -37,10 +147,16 @@ def analyze_transaction_with_ai(transaction_data, suspicious_transactions):
             "total_transactions": int(len(transaction_data)),
             "flagged_transactions": int(len(suspicious_transactions)),
             "flagged_percentage": float(round(len(suspicious_transactions) / len(transaction_data) * 100, 2)),
-            "avg_transaction_amount": float(round(transaction_data['amount'].mean(), 2)),
-            "suspicious_avg_amount": float(round(suspicious_transactions['amount'].mean(), 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 OpenAI
         prompt = f"""
         Analyze these potentially fraudulent transactions and identify patterns or anomalies:
@@ -48,6 +164,9 @@ def analyze_transaction_with_ai(transaction_data, suspicious_transactions):
         Transaction Data Summary:
         {json.dumps(summary_stats)}
         
+        Column Mapping:
+        {json.dumps(column_mapping)}
+        
         Sample of Suspicious Transactions:
         {json.dumps(suspicious_dict)}
         
@@ -79,7 +198,7 @@ def analyze_transaction_with_ai(transaction_data, suspicious_transactions):
 def load_and_preprocess_data(file):
     """Load and preprocess transaction data from CSV or Excel file"""
     if file is None:
-        return None
+        return None, None
     
     # Get file extension
     file_extension = os.path.splitext(file.name)[1].lower()
@@ -96,155 +215,197 @@ def load_and_preprocess_data(file):
     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']):
+    # 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
+    
+    # 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:
-            df['timestamp'] = pd.to_datetime(df['timestamp'])
+            processed_df[timestamp_col] = pd.to_datetime(df[timestamp_col])
         except:
-            raise ValueError("Could not convert timestamp column to datetime format.")
+            print(f"Warning: Could not convert {timestamp_col} 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.")
+    # 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 df
+    return processed_df, dataset_explanation, column_mapping
 
-def detect_fraud_and_anomalies(df):
-    """Detect fraud and anomalies in transaction data"""
+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 = df[['amount']].copy()
+    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
-    if 'timestamp' in df.columns:
-        # Extract hour and day of week without using .dt.to_pydatetime()
-        features['hour_of_day'] = pd.to_numeric(df['timestamp'].dt.hour)
-        features['day_of_week'] = pd.to_numeric(df['timestamp'].dt.dayofweek)
+    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 other relevant features if available
-    if 'location' in df.columns:
+    # 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'], prefix='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)
-    df['anomaly_score'] = clf.fit_predict(scaled_features)
+    anomaly_scores = clf.fit_predict(scaled_features)
+    
+    # Create a result DataFrame with original data and anomaly scores
+    result_df = df.copy()
     
-    # Flag anomalies (anomaly_score of -1 indicates an anomaly)
-    df['is_anomaly'] = df['anomaly_score'] == -1
+    # Add anomaly flags
+    result_df['anomaly_score'] = anomaly_scores
+    result_df['is_anomaly'] = result_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
+    # 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' in df.columns:
-        # Fix for datetime warning
-        hours = np.array(df['timestamp'].dt.hour)
-        df['unusual_hour'] = np.isin(hours, [0, 1, 2, 3, 4])
-    else:
-        df['unusual_hour'] = False
+    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)
-    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
+    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' 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'])
-        
-        # Fix for datetime warning by using numpy arrays
-        time_diffs = df.groupby(id_col)['timestamp'].diff()
-        # Convert to seconds and handle NaN values
-        seconds = np.array([td.total_seconds() if pd.notnull(td) else 0 for td in time_diffs])
-        df['time_diff'] = seconds
-        df['rapid_succession'] = df['time_diff'] < 300  # Less than 5 minutes
-    else:
-        df['rapid_succession'] = False
+    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
+    }
     
-    # 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)
-    )
+    # 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
-    df['is_suspicious'] = df['fraud_score'] >= 3
+    # 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 df
+    return result_df
 
-def create_visualizations(df):
-    """Create visualizations for transaction data and anomalies"""
+def create_visualizations(df, column_mapping):
+    """Create visualizations for transaction data and anomalies based on LLM-identified columns"""
     visualizations = {}
     
     try:
-        # Convert timestamp to string for plotly to avoid datetime warning
+        # Prepare a copy for plotting
         plot_df = df.copy()
-        if 'timestamp' in plot_df.columns:
-            plot_df['timestamp_str'] = plot_df['timestamp'].dt.strftime('%Y-%m-%d %H:%M:%S')
-        
-        # 1. Distribution of transaction amounts with anomalies highlighted
-        fig1 = px.histogram(
-            plot_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'}
-        )
-        # Ensure the figure is fully rendered
-        fig1.update_layout(height=500, width=700)
-        visualizations['amount_distribution'] = fig1
         
-        # 2. Time series of transaction amounts
-        if 'timestamp' in plot_df.columns:
+        # 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', color='is_suspicious',
+                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': 'Transaction Amount', 'timestamp_str': 'Time', 'is_suspicious': 'Suspicious'}
+                labels={amount_col: 'Transaction Amount', 'timestamp_str': 'Time', 'is_suspicious': 'Suspicious'}
             )
             fig2.update_layout(height=500, width=700)
             visualizations['time_series'] = fig2
@@ -258,21 +419,38 @@ def create_visualizations(df):
         fig3.update_layout(height=500, width=700)
         visualizations['fraud_score_dist'] = fig3
         
-        # 4. Hourly transaction pattern (if timestamp available)
-        if 'timestamp' in plot_df.columns:
-            # Fixed approach to get hourly data
-            hourly_counts = plot_df.groupby([plot_df['timestamp'].dt.hour, 'is_suspicious']).size()
-            hourly_df = hourly_counts.reset_index()
-            hourly_df.columns = ['hour', 'is_suspicious', 'count']
+        # 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.line(
-                hourly_df, x='hour', y='count', color='is_suspicious',
+            fig4 = px.bar(
+                user_counts_filtered, x=user_col, 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'}
+                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['hourly_pattern'] = fig4
+            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)}")
@@ -282,19 +460,24 @@ def create_visualizations(df):
 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
+        # 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
-        df_with_anomalies = detect_fraud_and_anomalies(df)
+        # 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
-        visualizations = create_visualizations(df_with_anomalies)
+        # Create visualizations using the identified columns
+        visualizations = create_visualizations(df_with_anomalies, column_mapping)
         
         # Basic statistics
         total_transactions = len(df_with_anomalies)
@@ -307,14 +490,37 @@ def process_transactions(file):
         
         - **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}
         """
         
+        # 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)
+        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')
@@ -340,7 +546,7 @@ 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.")
+        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"])