Update app.py

app.py

@@ -9,15 +9,23 @@ import psutil
 import optuna
 import ast
 import pandas as pd
+import numpy as np
 from sklearn.model_selection import train_test_split
 from sklearn.ensemble import RandomForestClassifier
-from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
+from sklearn.metrics import (accuracy_score, precision_score, 
+                           recall_score, f1_score, classification_report)
+from sklearn.preprocessing import LabelEncoder
 import shap
 import lime
 import lime.lime_tabular
 import matplotlib.pyplot as plt
-import numpy as np
-from optuna.visualization import plot_optimization_history, plot_param_importances
+import seaborn as sns
+from optuna.visualization import (plot_optimization_history, 
+                                 plot_param_importances,
+                                 plot_parallel_coordinate)
+from PIL import Image
+import base64
+from io import BytesIO
 
 # Authenticate Hugging Face
 hf_token = os.getenv("HF_TOKEN")
@@ -26,312 +34,326 @@ login(token=hf_token, add_to_git_credential=True)
 # Initialize Model
 model = HfApiModel("mistralai/Mixtral-8x7B-Instruct-v0.1", token=hf_token)
 
-def format_analysis_report(raw_output, visuals):
-    try:
-        if isinstance(raw_output, dict):
-            analysis_dict = raw_output
-        else:
-            try:
-                analysis_dict = ast.literal_eval(str(raw_output))
-            except (SyntaxError, ValueError) as e:
-                print(f"Error parsing CodeAgent output: {e}")
-                return str(raw_output), visuals  # Return raw output as string
-                
-        report = f"""
-        <div style="font-family: Arial, sans-serif; padding: 20px; color: #333;">
-            <h1 style="color: #2B547E; border-bottom: 2px solid #2B547E; padding-bottom: 10px;">📊 Data Analysis Report</h1>
-            <div style="margin-top: 25px; background: #f8f9fa; padding: 20px; border-radius: 8px;">
-                <h2 style="color: #2B547E;">🔍 Key Observations</h2>
-                {format_observations(analysis_dict.get('observations', {}))}
-            </div>
-            <div style="margin-top: 30px;">
-                <h2 style="color: #2B547E;">💡 Insights & Visualizations</h2>
-                {format_insights(analysis_dict.get('insights', {}), visuals)}
-            </div>
-        </div>
-        """
-        return report, visuals
-    except Exception as e:
-        print(f"Error in format_analysis_report: {e}")
-        return str(raw_output), visuals
+# Initialize W&B
+wandb.login(key=os.environ.get('WANDB_API_KEY'))
 
-def format_observations(observations):
-    return '\n'.join([
-        f"""
-        <div style="margin: 15px 0; padding: 15px; background: white; border-radius: 8px; box-shadow: 0 2px 4px rgba(0,0,0,0.05);">
-            <h3 style="margin: 0 0 10px 0; color: #4A708B;">{key.replace('_', ' ').title()}</h3>
-            <pre style="margin: 0; padding: 10px; background: #f8f9fa; border-radius: 4px;">{value}</pre>
-        </div>
-        """ for key, value in observations.items() if 'proportions' in key
-    ])
+def save_figure(fig, filename):
+    """Helper function to save matplotlib figures"""
+    os.makedirs('./figures', exist_ok=True)
+    path = f"./figures/{filename}"
+    fig.savefig(path, bbox_inches='tight')
+    plt.close(fig)
+    return path
 
-def format_insights(insights, visuals):
-    return '\n'.join([
-        f"""
-        <div style="margin: 20px 0; padding: 20px; background: white; border-radius: 8px; box-shadow: 0 2px 4px rgba(0,0,0,0.05);">
-            <div style="display: flex; align-items: center; gap: 10px;">
-                <div style="background: #2B547E; color: white; width: 30px; height: 30px; border-radius: 50%; display: flex; align-items: center; justify-content: center;">{idx+1}</div>
-                <p style="margin: 0; font-size: 16px;">{insight}</p>
-            </div>
-            {f'<img src="/file={visuals[idx]}" style="max-width: 100%; height: auto; margin-top: 10px; border-radius: 6px; box-shadow: 0 2px 4px rgba(0,0,0,0.1);">' if idx < len(visuals) else ''}
-        </div>
-        """ for idx, (key, insight) in enumerate(insights.items())
-    ])
+def encode_categorical_data(df):
+    """Encode categorical columns and return encoded df and encoders"""
+    encoders = {}
+    for col in df.select_dtypes(include=['object', 'category']).columns:
+        le = LabelEncoder()
+        df[col] = le.fit_transform(df[col].astype(str))
+        encoders[col] = le
+    return df, encoders
 
-def analyze_data(csv_file, additional_notes=""):
-    start_time = time.time()
-    process = psutil.Process(os.getpid())
-    initial_memory = process.memory_info().rss / 1024 ** 2
-    
-    if os.path.exists('./figures'):
-        shutil.rmtree('./figures')
-    os.makedirs('./figures', exist_ok=True)
-    
-    wandb.login(key=os.environ.get('WANDB_API_KEY'))
-    run = wandb.init(project="huggingface-data-analysis", config={
-        "model": "mistralai/Mixtral-8x7B-Instruct-v0.1",
-        "additional_notes": additional_notes,
-        "source_file": csv_file.name if csv_file else None
-    })
+def generate_data_insights(df):
+    """Generate insights using smolagent"""
+    agent = CodeAgent(
+        tools=[], 
+        model=model,
+        additional_authorized_imports=["numpy", "pandas", "matplotlib.pyplot", "seaborn"]
+    )
     
-    agent = CodeAgent(tools=[], model=model, additional_authorized_imports=["numpy", "pandas", "matplotlib.pyplot", "seaborn", "sklearn"])
-    analysis_result = agent.run("""
-        You are an expert data analyst. Perform comprehensive analysis including:
-        1. Basic statistics and data quality checks
-        2. 3 insightful analytical questions about relationships in the data
-        3. Visualization of key patterns and correlations
-        4. Actionable real-world insights derived from findings.
-        Generate publication-quality visualizations and save to './figures/'.
-        Return the analysis results as a python dictionary that can be parsed by ast.literal_eval().
-        The dictionary should have the following structure:
-        {
-            'observations': {
-                'observation_1_key': 'observation_1_value',
-                'observation_2_key': 'observation_2_value',
-                ...
-            },
-            'insights': {
-                'insight_1_key': 'insight_1_value',
-                'insight_2_key': 'insight_2_value',
-                ...
-            }
-        }
-    """, additional_args={"additional_notes": additional_notes, "source_file": csv_file})
+    prompt = """
+    Analyze this dataset and provide:
+    1. 5 key statistical insights about the data
+    2. 5 suggested visualizations with explanations
+    3. Data quality assessment
+    4. Recommendations for preprocessing
     
-    execution_time = time.time() - start_time
-    final_memory = process.memory_info().rss / 1024 ** 2
-    memory_usage = final_memory - initial_memory
-    wandb.log({"execution_time_sec": execution_time, "memory_usage_mb": memory_usage})
+    For each insight:
+    - Explain its significance
+    - Provide the Python code to verify it
+    - Suggest potential actions
     
-    visuals = [os.path.join('./figures', f) for f in os.listdir('./figures') if f.endswith(('.png', '.jpg', '.jpeg'))]
-    for viz in visuals:
-        wandb.log({os.path.basename(viz): wandb.Image(viz)})
+    Return the results as a dictionary with:
+    - 'insights': List of 5 key insights
+    - 'visualizations': List of 5 visualization descriptions with code
+    - 'quality': Data quality assessment
+    - 'recommendations': Preprocessing recommendations
+    """
     
-    run.finish()
-    return format_analysis_report(analysis_result, visuals)
+    return agent.run(prompt, additional_args={"df": df})
 
-def objective(trial, X_train, y_train, X_test, y_test):
-    # Enhanced hyperparameter space
-    n_estimators = trial.suggest_int("n_estimators", 50, 500, step=50)
-    max_depth = trial.suggest_int("max_depth", 3, 15)
-    min_samples_split = trial.suggest_int("min_samples_split", 2, 10)
-    min_samples_leaf = trial.suggest_int("min_samples_leaf", 1, 5)
-    max_features = trial.suggest_categorical("max_features", ["sqrt", "log2", None])
-    bootstrap = trial.suggest_categorical("bootstrap", [True, False])
-    criterion = trial.suggest_categorical("criterion", ["gini", "entropy"])
-    
-    model = RandomForestClassifier(
-        n_estimators=n_estimators,
-        max_depth=max_depth,
-        min_samples_split=min_samples_split,
-        min_samples_leaf=min_samples_leaf,
-        max_features=max_features,
-        bootstrap=bootstrap,
-        criterion=criterion,
-        random_state=42,
-        n_jobs=-1
-    )
-    
-    model.fit(X_train, y_train)
-    predictions = model.predict(X_test)
+def create_visualizations(df, insights):
+    """Create visualizations based on insights"""
+    visuals = []
+    try:
+        # Visualization 1: Missing values heatmap
+        if df.isnull().any().any():
+            fig, ax = plt.subplots(figsize=(10, 6))
+            sns.heatmap(df.isnull(), cbar=False, ax=ax)
+            plt.title("Missing Values Heatmap")
+            visuals.append(save_figure(fig, "missing_values.png"))
+        
+        # Visualization 2: Correlation heatmap
+        numeric_cols = df.select_dtypes(include=np.number).columns
+        if len(numeric_cols) > 1:
+            fig, ax = plt.subplots(figsize=(10, 8))
+            sns.heatmap(df[numeric_cols].corr(), annot=True, cmap='coolwarm', ax=ax)
+            plt.title("Correlation Heatmap")
+            visuals.append(save_figure(fig, "correlation_heatmap.png"))
+        
+        # Visualization 3: Feature distributions
+        for col in numeric_cols[:3]:  # First 3 numeric columns
+            fig, ax = plt.subplots(figsize=(10, 6))
+            sns.histplot(df[col], kde=True, ax=ax)
+            plt.title(f"Distribution of {col}")
+            visuals.append(save_figure(fig, f"distribution_{col}.png"))
+        
+        # Visualization 4: Pairplot (sample if large)
+        if len(numeric_cols) > 1:
+            fig = sns.pairplot(df[numeric_cols].sample(min(100, len(df))))
+            visuals.append(save_figure(fig, "pairplot.png"))
+        
+        # Visualization 5: Categorical counts
+        cat_cols = df.select_dtypes(include=['object', 'category']).columns
+        for col in cat_cols[:2]:  # First 2 categorical columns
+            fig, ax = plt.subplots(figsize=(10, 6))
+            df[col].value_counts().plot(kind='bar', ax=ax)
+            plt.title(f"Count of {col}")
+            visuals.append(save_figure(fig, f"count_{col}.png"))
+            
+    except Exception as e:
+        print(f"Visualization error: {e}")
     
-    # Track multiple metrics
-    accuracy = accuracy_score(y_test, predictions)
-    precision = precision_score(y_test, predictions, average='weighted', zero_division=0)
-    recall = recall_score(y_test, predictions, average='weighted', zero_division=0)
-    f1 = f1_score(y_test, predictions, average='weighted', zero_division=0)
+    return visuals
+
+def analyze_data(csv_file, additional_notes=""):
+    """Main data analysis function"""
+    start_time = time.time()
     
-    # Log metrics to W&B
-    wandb.log({
-        "trial_accuracy": accuracy,
-        "trial_precision": precision,
-        "trial_recall": recall,
-        "trial_f1": f1,
-        "n_estimators": n_estimators,
-        "max_depth": max_depth,
-        "min_samples_split": min_samples_split,
-        "min_samples_leaf": min_samples_leaf,
-        "max_features": str(max_features),
-        "bootstrap": bootstrap,
-        "criterion": criterion
+    # Initialize W&B run
+    run = wandb.init(project="data-analysis", config={
+        "model": "Mixtral-8x7B",
+        "notes": additional_notes,
+        "file": csv_file.name if csv_file else None
     })
     
-    return accuracy
+    try:
+        # Load data
+        df = pd.read_csv(csv_file)
+        
+        # Generate insights with smolagent
+        insights = generate_data_insights(df)
+        
+        # Create visualizations
+        visuals = create_visualizations(df, insights)
+        
+        # Log to W&B
+        for viz in visuals:
+            wandb.log({"visualizations": wandb.Image(viz)})
+        
+        # Format report
+        report = format_analysis_report(insights, visuals)
+        
+        # Track performance
+        execution_time = time.time() - start_time
+        wandb.log({"execution_time": execution_time})
+        
+        return report, visuals
+        
+    except Exception as e:
+        return f"Error: {str(e)}", []
+    finally:
+        run.finish()
 
-def tune_hyperparameters(csv_file, n_trials: int):
-    # Initialize W&B run
-    wandb.login(key=os.environ.get('WANDB_API_KEY'))
-    run = wandb.init(project="hyperparameter-optimization", 
-                    config={"n_trials": n_trials, "model_type": "RandomForest"})
+def objective(trial, X, y):
+    """Optuna objective function for hyperparameter tuning"""
+    params = {
+        'n_estimators': trial.suggest_int('n_estimators', 50, 500),
+        'max_depth': trial.suggest_int('max_depth', 3, 15),
+        'min_samples_split': trial.suggest_int('min_samples_split', 2, 10),
+        'min_samples_leaf': trial.suggest_int('min_samples_leaf', 1, 5),
+        'max_features': trial.suggest_categorical('max_features', ['sqrt', 'log2', None]),
+        'bootstrap': trial.suggest_categorical('bootstrap', [True, False]),
+        'criterion': trial.suggest_categorical('criterion', ['gini', 'entropy'])
+    }
     
-    df = pd.read_csv(csv_file)
-    y = df.iloc[:, -1]
-    X = df.iloc[:, :-1]
     X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
     
-    # Create study with enhanced settings
-    study = optuna.create_study(
-        direction="maximize",
-        sampler=optuna.samplers.TPESampler(),
-        pruner=optuna.pruners.MedianPruner(n_warmup_steps=5)
-    )
-    
-    # Run optimization
-    study.optimize(lambda trial: objective(trial, X_train, y_train, X_test, y_test), 
-                  n_trials=n_trials,
-                  callbacks=[wandb_callback])
-    
-    # Get best trial results
-    best_params = study.best_params
-    best_value = study.best_value
-    
-    # Train final model with best parameters
-    final_model = RandomForestClassifier(**best_params, random_state=42, n_jobs=-1)
-    final_model.fit(X_train, y_train)
-    final_predictions = final_model.predict(X_test)
-    
-    # Calculate final metrics
-    accuracy = accuracy_score(y_test, final_predictions)
-    precision = precision_score(y_test, final_predictions, average='weighted', zero_division=0)
-    recall = recall_score(y_test, final_predictions, average='weighted', zero_division=0)
-    f1 = f1_score(y_test, final_predictions, average='weighted', zero_division=0)
-    
-    # Generate optimization visualizations
-    optimization_history = plot_optimization_history(study)
-    param_importance = plot_param_importances(study)
-    
-    # Save visualizations
-    os.makedirs('./figures', exist_ok=True)
-    history_path = "./figures/optimization_history.png"
-    importance_path = "./figures/param_importance.png"
+    model = RandomForestClassifier(**params, random_state=42, n_jobs=-1)
+    model.fit(X_train, y_train)
     
-    optimization_history.figure.savefig(history_path)
-    param_importance.figure.savefig(importance_path)
+    y_pred = model.predict(X_test)
     
-    # Generate SHAP and LIME explanations
-    shap_explainer = shap.TreeExplainer(final_model)
-    shap_values = shap_explainer.shap_values(X_test)
-    shap.summary_plot(shap_values, X_test, show=False)
-    shap_fig_path = "./figures/shap_summary.png"
-    plt.savefig(shap_fig_path)
-    plt.clf()
+    # Track multiple metrics
+    metrics = {
+        'accuracy': accuracy_score(y_test, y_pred),
+        'precision': precision_score(y_test, y_pred, average='weighted'),
+        'recall': recall_score(y_test, y_pred, average='weighted'),
+        'f1': f1_score(y_test, y_pred, average='weighted')
+    }
     
-    lime_explainer = lime.lime_tabular.LimeTabularExplainer(
-        X_train.values, 
-        feature_names=X_train.columns, 
-        class_names=['target'], 
-        mode='classification'
-    )
-    lime_explanation = lime_explainer.explain_instance(
-        X_test.iloc[0].values, 
-        final_model.predict_proba
-    )
-    lime_fig = lime_explanation.as_pyplot_figure()
-    lime_fig_path = "./figures/lime_explanation.png"
-    lime_fig.savefig(lime_fig_path)
-    plt.clf()
+    # Log to W&B
+    wandb.log({**params, **metrics})
     
-    # Log everything to W&B
-    wandb.log({
-        "best_params": best_params,
-        "best_accuracy": best_value,
-        "final_accuracy": accuracy,
-        "final_precision": precision,
-        "final_recall": recall,
-        "final_f1": f1,
-        "optimization_history": wandb.Image(history_path),
-        "parameter_importance": wandb.Image(importance_path),
-        "shap_summary": wandb.Image(shap_fig_path),
-        "lime_explanation": wandb.Image(lime_fig_path)
+    return metrics['accuracy']
+
+def tune_hyperparameters(csv_file, n_trials=50):
+    """Hyperparameter tuning with Optuna and W&B"""
+    run = wandb.init(project="hyperparameter-tuning", config={
+        "n_trials": n_trials,
+        "model": "RandomForest"
     })
     
-    # Generate HTML report
+    try:
+        # Load and prepare data
+        df = pd.read_csv(csv_file)
+        df, _ = encode_categorical_data(df)
+        
+        y = df.iloc[:, -1]  # Assume last column is target
+        X = df.iloc[:, :-1]
+        
+        # Optuna study
+        study = optuna.create_study(
+            direction='maximize',
+            sampler=optuna.samplers.TPESampler(),
+            pruner=optuna.pruners.MedianPruner()
+        )
+        
+        study.optimize(lambda trial: objective(trial, X, y), n_trials=n_trials)
+        
+        # Generate visualizations
+        visuals = []
+        fig = plot_optimization_history(study)
+        visuals.append(save_figure(fig, "optimization_history.png"))
+        
+        fig = plot_param_importances(study)
+        visuals.append(save_figure(fig, "param_importance.png"))
+        
+        fig = plot_parallel_coordinate(study)
+        visuals.append(save_figure(fig, "parallel_coordinate.png"))
+        
+        # Train best model
+        best_model = RandomForestClassifier(**study.best_params, random_state=42)
+        best_model.fit(X, y)
+        
+        # SHAP explainability
+        explainer = shap.TreeExplainer(best_model)
+        shap_values = explainer.shap_values(X)
+        
+        fig, ax = plt.subplots(figsize=(10, 8))
+        shap.summary_plot(shap_values, X, show=False)
+        visuals.append(save_figure(fig, "shap_summary.png"))
+        
+        # LIME explainability
+        explainer = lime.lime_tabular.LimeTabularExplainer(
+            X.values,
+            feature_names=X.columns,
+            class_names=['class_0', 'class_1'],  # Modify as needed
+            mode='classification'
+        )
+        exp = explainer.explain_instance(X.iloc[0].values, best_model.predict_proba)
+        fig = exp.as_pyplot_figure()
+        visuals.append(save_figure(fig, "lime_explanation.png"))
+        
+        # Format results
+        report = format_tuning_results(study, best_model, X, y)
+        
+        return report, visuals
+        
+    except Exception as e:
+        return f"Error: {str(e)}", []
+    finally:
+        run.finish()
+
+def format_analysis_report(insights, visuals):
+    """Format the analysis report with insights and visuals"""
     report = f"""
-    <div style="font-family: Arial, sans-serif; padding: 20px; color: #333;">
-        <h1 style="color: #2B547E; border-bottom: 2px solid #2B547E; padding-bottom: 10px;">🎯 Hyperparameter Optimization Results</h1>
+    <div style="font-family: Arial; max-width: 1000px; margin: 0 auto;">
+        <h1 style="color: #2B547E;">📊 Data Analysis Report</h1>
         
-        <div style="margin-top: 20px; background: #f8f9fa; padding: 15px; border-radius: 8px;">
-            <h2 style="color: #2B547E;">📈 Performance Metrics</h2>
-            <p><strong>Best Accuracy:</strong> {best_value:.4f}</p>
-            <p><strong>Final Model Accuracy:</strong> {accuracy:.4f}</p>
-            <p><strong>Precision:</strong> {precision:.4f}</p>
-            <p><strong>Recall:</strong> {recall:.4f}</p>
-            <p><strong>F1 Score:</strong> {f1:.4f}</p>
+        <div style="margin-top: 20px; background: #f8f9fa; padding: 20px; border-radius: 8px;">
+            <h2 style="color: #2B547E;">🔍 Key Insights</h2>
+            {format_insights_section(insights.get('insights', []))}
         </div>
         
-        <div style="margin-top: 25px; background: #f8f9fa; padding: 15px; border-radius: 8px;">
-            <h2 style="color: #2B547E;">⚙️ Best Parameters</h2>
-            <pre style="background: white; padding: 10px; border-radius: 4px;">{best_params}</pre>
+        <div style="margin-top: 30px;">
+            <h2 style="color: #2B547E;">📈 Visualizations</h2>
+            {format_visualizations(visuals)}
         </div>
+    </div>
+    """
+    return report
+
+def format_tuning_results(study, model, X, y):
+    """Format hyperparameter tuning results"""
+    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+    y_pred = model.predict(X_test)
+    
+    report = f"""
+    <div style="font-family: Arial; max-width: 1000px; margin: 0 auto;">
+        <h1 style="color: #2B547E;">⚙️ Hyperparameter Tuning Results</h1>
         
-        <div style="margin-top: 25px;">
-            <h2 style="color: #2B547E;">📊 Optimization Process</h2>
-            <img src="/file={history_path}" style="max-width: 100%; border-radius: 6px; margin-bottom: 15px;">
-            <img src="/file={importance_path}" style="max-width: 100%; border-radius: 6px;">
+        <div style="display: grid; grid-template-columns: 1fr 1fr; gap: 20px; margin-top: 20px;">
+            <div style="background: #f8f9fa; padding: 20px; border-radius: 8px;">
+                <h2 style="color: #2B547E;">📊 Best Parameters</h2>
+                <pre>{study.best_params}</pre>
+            </div>
+            
+            <div style="background: #f8f9fa; padding: 20px; border-radius: 8px;">
+                <h2 style="color: #2B547E;">📈 Performance Metrics</h2>
+                <p>Accuracy: {accuracy_score(y_test, y_pred):.4f}</p>
+                <p>Precision: {precision_score(y_test, y_pred, average='weighted'):.4f}</p>
+                <p>Recall: {recall_score(y_test, y_pred, average='weighted'):.4f}</p>
+                <p>F1 Score: {f1_score(y_test, y_pred, average='weighted'):.4f}</p>
+            </div>
+        </div>
+        
+        <div style="margin-top: 30px;">
+            <h2 style="color: #2B547E;">🔍 Classification Report</h2>
+            <pre>{classification_report(y_test, y_pred)}</pre>
         </div>
     </div>
     """
-    
-    # Get visualization paths for gallery
-    visuals = [
-        history_path,
-        importance_path,
-        shap_fig_path,
-        lime_fig_path
-    ]
-    
-    run.finish()
-    return report, visuals
-
-def wandb_callback(study, trial):
-    """Callback to log study information to W&B after each trial"""
-    wandb.log({
-        "best_accuracy": study.best_value,
-        "current_trial": trial.number,
-        "current_accuracy": trial.value
-    })
+    return report
 
+# Create Gradio interface
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("## 📊 AI Data Analysis Agent with Enhanced Hyperparameter Optimization")
-    with gr.Row():
-        with gr.Column():
-            file_input = gr.File(label="Upload CSV Dataset", type="filepath")
-            notes_input = gr.Textbox(label="Dataset Notes (Optional)", lines=3)
-            analyze_btn = gr.Button("Analyze", variant="primary")
-            optuna_trials = gr.Number(
-                label="Number of Hyperparameter Tuning Trials", 
-                value=50,
-                minimum=10,
-                maximum=200,
-                step=5
-            )
-            tune_btn = gr.Button("Optimize Hyperparameters", variant="secondary")
-        with gr.Column():
-            analysis_output = gr.Markdown("### Analysis results will appear here...")
-            optuna_output = gr.HTML(label="Hyperparameter Tuning Results")
-            gallery = gr.Gallery(label="Optimization Visualizations", columns=2)
+    gr.Markdown("# 🧠 Advanced Data Analysis with AI")
     
-    analyze_btn.click(fn=analyze_data, inputs=[file_input, notes_input], outputs=[analysis_output, gallery])
-    tune_btn.click(fn=tune_hyperparameters, inputs=[file_input, optuna_trials], outputs=[optuna_output, gallery])
+    with gr.Tab("Data Analysis"):
+        with gr.Row():
+            with gr.Column():
+                data_file = gr.File(label="Upload CSV", file_types=[".csv"])
+                notes = gr.Textbox(label="Analysis Notes (Optional)", lines=3)
+                analyze_btn = gr.Button("Analyze Data", variant="primary")
+            
+            with gr.Column():
+                analysis_report = gr.HTML(label="Analysis Report")
+                viz_gallery = gr.Gallery(label="Visualizations")
+    
+    with gr.Tab("Model Tuning"):
+        with gr.Row():
+            with gr.Column():
+                tune_file = gr.File(label="Upload CSV for Tuning", file_types=[".csv"])
+                trials = gr.Slider(10, 200, value=50, label="Number of Trials")
+                tune_btn = gr.Button("Tune Hyperparameters", variant="primary")
+            
+            with gr.Column():
+                tuning_report = gr.HTML(label="Tuning Results")
+                tuning_viz = gr.Gallery(label="Tuning Visualizations")
+    
+    # Event handlers
+    analyze_btn.click(
+        fn=analyze_data,
+        inputs=[data_file, notes],
+        outputs=[analysis_report, viz_gallery]
+    )
+    
+    tune_btn.click(
+        fn=tune_hyperparameters,
+        inputs=[tune_file, trials],
+        outputs=[tuning_report, tuning_viz]
+    )
 
-demo.launch(debug=True)
+demo.launch()