Update app.py

app.py

@@ -1987,7 +1987,7 @@ with gr.Blocks(css=css, title="DataSynth — Analytics Hub") as demo:
     )
 
     # Train model based on task type
-    def train_model_wrapper(task_type, model_name, dataset_choice, target_var, 
+        def train_model_wrapper(task_type, model_name, dataset_choice, target_var, 
                            scaler_type, do_rfecv, do_tuning,
                            clustering_algo, n_clusters, eps, min_samples,
                            rule_algo, trans_col, min_sup, min_conf, min_lft, max_len,
@@ -2188,121 +2188,128 @@ with gr.Blocks(css=css, title="DataSynth — Analytics Hub") as demo:
                 detailed_df = cluster_stats
                 
             else:  # Rule-Based
-                    try:
-                        if rule_algo == "Apriori (Simple)":
-                            # Prepare transaction data
-                            transactions = prepare_transaction_data(df, trans_col if trans_col else None)
-                            
-                            if not transactions:
-                                return "No valid transactions found in the data.", None, None
-                            
-                            # Run Apriori
-                            frequent_itemsets, rules = run_association_mining(
-                                transactions, 
-                                min_support=min_sup,
-                                min_confidence=min_conf,
-                                min_lift=min_lft
-                            )
-                            
-                            results_summary = f"## 🔗 Simple Apriori Association Rules\n\n"
-                            
-                        else:  # Frequency-Based Rules
-                            # Identify categorical columns
-                            cat_cols = df.select_dtypes(include=['object', 'category']).columns.tolist()
-                            if not cat_cols:
-                                # Try to use all columns as categorical
-                                cat_cols = df.columns.tolist()
-                            
-                            rules_list = run_frequency_based_rules(
-                                df, 
-                                categorical_cols=cat_cols,
-                                min_frequency=min_sup,
-                                min_cooccurrence=min_conf
-                            )
-                            
-                            # Convert to rules format similar to Apriori
-                            rules = []
-                            for rule in rules_list:
-                                rules.append({
-                                    'antecedents': {rule['antecedent']},
-                                    'consequents': {rule['consequent']},
-                                    'support': rule['support'],
-                                    'confidence': rule['confidence'],
-                                    'lift': rule['lift'],
-                                    'rule_str': rule['rule']
-                                })
-                            
-                            results_summary = f"## 🔗 Frequency-Based Association Rules\n\n"
+                try:
+                    if rule_algo == "Apriori (Simple)":
+                        # Prepare transaction data
+                        transactions = prepare_transaction_data(df, trans_col if trans_col else None)
                         
-                        if not rules:
-                            return "No association rules found with the given parameters.", None, None
+                        if not transactions:
+                            return "No valid transactions found in the data.", None, None
                         
-                        results_summary += f"- **Total rules found:** {len(rules)}\n"
-                        results_summary += f"- **Minimum support:** {min_sup}\n"
-                        results_summary += f"- **Minimum confidence:** {min_conf}\n"
-                        results_summary += f"- **Minimum lift:** {min_lft}\n\n"
+                        # Run Apriori
+                        frequent_itemsets, rules = run_association_mining(
+                            transactions, 
+                            min_support=min_sup,
+                            min_confidence=min_conf,
+                            min_lift=min_lft
+                        )
                         
-                        # Top 10 rules by confidence
-                        top_rules = rules[:10]
-                        results_summary += "### 🏆 Top 10 Rules by Confidence\n\n"
-                        for idx, rule in enumerate(top_rules):
-                            if 'rule_str' in rule:
-                                rule_text = rule['rule_str']
-                            else:
-                                antecedents = ', '.join(list(rule['antecedents']))
-                                consequents = ', '.join(list(rule['consequents']))
-                                rule_text = f"IF {antecedents} THEN {consequents}"
-                            
-                            results_summary += f"{idx+1}. **{rule_text}**  \n"
-                            results_summary += f"   Support: {rule['support']:.3f}, Confidence: {rule['confidence']:.3f}, Lift: {rule['lift']:.3f}\n\n"
+                        results_summary = f"## 🔗 Simple Apriori Association Rules\n\n"
                         
-                        # Prepare rules for visualization
-                        plot_data = []
-                        for rule in rules[:20]:  # Limit to 20 for plotting
-                            if 'rule_str' in rule:
-                                rule_name = rule['rule_str'][:50] + "..." if len(rule['rule_str']) > 50 else rule['rule_str']
-                            else:
-                                antecedents = ', '.join(list(rule['antecedents']))[:20]
-                                consequents = ', '.join(list(rule['consequents']))[:20]
-                                rule_name = f"{antecedents}→{consequents}"
-                            
-                            plot_data.append({
-                                'rule': rule_name,
+                    else:  # Frequency-Based Rules
+                        # Identify categorical columns
+                        cat_cols = df.select_dtypes(include=['object', 'category']).columns.tolist()
+                        if not cat_cols:
+                            # Try to use all columns as categorical
+                            cat_cols = df.columns.tolist()
+                        
+                        rules_list = run_frequency_based_rules(
+                            df, 
+                            categorical_cols=cat_cols,
+                            min_frequency=min_sup,
+                            min_cooccurrence=min_conf
+                        )
+                        
+                        # Convert to rules format similar to Apriori
+                        rules = []
+                        for rule in rules_list:
+                            rules.append({
+                                'antecedents': {rule['antecedent']},
+                                'consequents': {rule['consequent']},
                                 'support': rule['support'],
                                 'confidence': rule['confidence'],
-                                'lift': rule['lift']
+                                'lift': rule['lift'],
+                                'rule_str': rule['rule']
                             })
                         
-                        if plot_data:
-                            plot_df = pd.DataFrame(plot_data)
-                            fig = px.scatter(plot_df, x='support', y='confidence',
-                                           size='lift', color='lift',
-                                           hover_name='rule',
-                                           title=f'{rule_algo} Association Rules',
-                                           labels={'support': 'Support', 'confidence': 'Confidence'})
-                            plot_fig = fig
+                        results_summary = f"## 🔗 Frequency-Based Association Rules\n\n"
+                    
+                    if not rules:
+                        return "No association rules found with the given parameters.", None, None
+                    
+                    results_summary += f"- **Total rules found:** {len(rules)}\n"
+                    results_summary += f"- **Minimum support:** {min_sup}\n"
+                    results_summary += f"- **Minimum confidence:** {min_conf}\n"
+                    results_summary += f"- **Minimum lift:** {min_lft}\n\n"
+                    
+                    # Top 10 rules by confidence
+                    top_rules = rules[:10]
+                    results_summary += "### 🏆 Top 10 Rules by Confidence\n\n"
+                    for idx, rule in enumerate(top_rules):
+                        if 'rule_str' in rule:
+                            rule_text = rule['rule_str']
+                        else:
+                            antecedents = ', '.join(list(rule['antecedents']))
+                            consequents = ', '.join(list(rule['consequents']))
+                            rule_text = f"IF {antecedents} THEN {consequents}"
                         
-                        # Prepare detailed results
-                        detailed_data = []
-                        for rule in rules[:20]:
-                            if 'rule_str' in rule:
-                                rule_str = rule['rule_str']
-                            else:
-                                antecedents = ', '.join(list(rule['antecedents']))
-                                consequents = ', '.join(list(rule['consequents']))
-                                rule_str = f"{antecedents} → {consequents}"
-                            
-                            detailed_data.append({
-                                'Rule': rule_str,
-                                'Support': f"{rule['support']:.3f}",
-                                'Confidence': f"{rule['confidence']:.3f}",
-                                'Lift': f"{rule['lift']:.3f}"
-                            })
+                        results_summary += f"{idx+1}. **{rule_text}**  \n"
+                        results_summary += f"   Support: {rule['support']:.3f}, Confidence: {rule['confidence']:.3f}, Lift: {rule['lift']:.3f}\n\n"
+                    
+                    # Prepare rules for visualization
+                    plot_data = []
+                    for rule in rules[:20]:  # Limit to 20 for plotting
+                        if 'rule_str' in rule:
+                            rule_name = rule['rule_str'][:50] + "..." if len(rule['rule_str']) > 50 else rule['rule_str']
+                        else:
+                            antecedents = ', '.join(list(rule['antecedents']))[:20]
+                            consequents = ', '.join(list(rule['consequents']))[:20]
+                            rule_name = f"{antecedents}→{consequents}"
                         
-                        detailed_df = pd.DataFrame(detailed_data)
+                        plot_data.append({
+                            'rule': rule_name,
+                            'support': rule['support'],
+                            'confidence': rule['confidence'],
+                            'lift': rule['lift']
+                        })
+                    
+                    if plot_data:
+                        plot_df = pd.DataFrame(plot_data)
+                        fig = px.scatter(plot_df, x='support', y='confidence',
+                                       size='lift', color='lift',
+                                       hover_name='rule',
+                                       title=f'{rule_algo} Association Rules',
+                                       labels={'support': 'Support', 'confidence': 'Confidence'})
+                        plot_fig = fig
+                    
+                    # Prepare detailed results
+                    detailed_data = []
+                    for rule in rules[:20]:
+                        if 'rule_str' in rule:
+                            rule_str = rule['rule_str']
+                        else:
+                            antecedents = ', '.join(list(rule['antecedents']))
+                            consequents = ', '.join(list(rule['consequents']))
+                            rule_str = f"{antecedents} → {consequents}"
                         
-                    except Exception as e:
-                        return f"Error in rule-based mining: {str(e)}", None, None
+                        detailed_data.append({
+                            'Rule': rule_str,
+                            'Support': f"{rule['support']:.3f}",
+                            'Confidence': f"{rule['confidence']:.3f}",
+                            'Lift': f"{rule['lift']:.3f}"
+                        })
+                    
+                    detailed_df = pd.DataFrame(detailed_data)
+                    
+                except Exception as e:
+                    return f"Error in rule-based mining: {str(e)}", None, None
+            
+            # Return successful results
+            return results_summary, plot_fig, detailed_df
+            
+        except Exception as e:
+            traceback.print_exc()
+            return f"Error in model training: {str(e)}", None, None
 
     train_btn.click(
         fn=train_model_wrapper,