Delete app.py

app.py

@@ -1,766 +0,0 @@
-"""
-Multi-AI Analytics Platform — app.py
-Author: Ayush
-Run: streamlit run app.py
-"""
-
-import streamlit as st
-import pandas as pd
-import numpy as np
-from PIL import Image
-import os
-import sys
-import json
-from pathlib import Path
-
-ROOT = Path(__file__).parent
-sys.path.insert(0, str(ROOT))
-
-from config import Config, OUTPUT_DIR
-from data.data_loader import DataLoader
-from data.powerbi_export import PowerBIExporter
-from models.ml_models import MLPipeline, XGBoostPipeline, EnsemblePipeline
-from models.generative_ai import GenerativeAI
-from utils.helpers import (
-    create_feature_importance_chart,
-    create_metrics_dashboard,
-    create_confusion_matrix,
-    create_correlation_heatmap,
-    create_class_distribution,
-    create_actual_vs_predicted,
-    create_scatter_plot,
-    ChartGenerator,
-)
-
-try:
-    from models.deep_learning import DeepLearningPipeline, ImageClassifier, NLPClassifier
-    DL_IMPORT_OK = True
-except Exception as _dl_err:
-    DeepLearningPipeline = None
-    ImageClassifier = None
-    NLPClassifier = None
-    DL_IMPORT_OK = False
-
-try:
-    from models.ml_models import LightGBMPipeline
-    LGB_OK = True
-except Exception:
-    LightGBMPipeline = None
-    LGB_OK = False
-
-st.set_page_config(
-    page_title="Multi-AI Analytics Platform",
-    page_icon="🤖",
-    layout="wide",
-    initial_sidebar_state="expanded",
-)
-
-st.markdown("""
-<style>
-@import url('https://fonts.googleapis.com/css2?family=Space+Grotesk:wght@300;400;500;600;700&family=JetBrains+Mono:wght@400;600&display=swap');
-
-html, body, [class*="css"] { font-family: 'Space Grotesk', sans-serif; }
-
-.main { background: #0d0d1a; }
-
-.main-header {
-    font-size: 2.6rem; font-weight: 700;
-    background: linear-gradient(135deg, #6C63FF 0%, #00D9FF 100%);
-    -webkit-background-clip: text; -webkit-text-fill-color: transparent;
-    text-align: center; margin-bottom: 0.3rem;
-}
-.sub-header {
-    font-size: 1.05rem; color: #8888aa;
-    text-align: center; margin-bottom: 1.5rem; letter-spacing: 0.05em;
-}
-
-section[data-testid="stSidebar"] { background: #0f0f1e !important; }
-
-.stTabs [data-baseweb="tab-list"] { gap: 1rem; background: transparent; }
-.stTabs [data-baseweb="tab"] {
-    padding: 0.6rem 1.4rem; border-radius: 8px;
-    font-weight: 600; color: #8888aa;
-}
-.stTabs [aria-selected="true"] {
-    background: linear-gradient(135deg, #6C63FF22, #00D9FF22) !important;
-    color: #6C63FF !important; border-bottom: 2px solid #6C63FF;
-}
-
-.stButton > button {
-    background: linear-gradient(135deg, #6C63FF, #00D9FF);
-    color: white; border: none; border-radius: 8px;
-    font-weight: 600; transition: opacity 0.2s;
-}
-.stButton > button:hover { opacity: 0.85; }
-
-[data-testid="stMetricValue"] { color: #6C63FF !important; font-weight: 700; }
-
-.footer-text { text-align: center; color: #555577; font-size: 13px; }
-.brand { color: #6C63FF; font-weight: 700; font-family: 'JetBrains Mono', monospace; }
-</style>
-""", unsafe_allow_html=True)
-
-st.markdown('<h1 class="main-header">🤖 Multi-AI Analytics Platform</h1>', unsafe_allow_html=True)
-st.markdown(
-    '<p class="sub-header">Machine Learning &nbsp;•&nbsp; Deep Learning &nbsp;•&nbsp; Generative AI &nbsp;•&nbsp; Power BI Export</p>',
-    unsafe_allow_html=True,
-)
-
-with st.sidebar:
-    st.markdown("## ⚙️ Settings")
-    st.divider()
-
-    st.markdown("### 🔑 Generative AI")
-    provider_choice = st.selectbox(
-        "Provider",
-        ["openai", "google", "anthropic"],
-        format_func=lambda x: {"openai": "OpenAI GPT-4", "google": "Google Gemini", "anthropic": "Anthropic Claude"}[x],
-    )
-    api_key_input = st.text_input("API Key", type="password", placeholder="Paste your key here…")
-
-    st.divider()
-    st.markdown("### ℹ️ Status")
-    st.markdown(f"🐍 Python: `{sys.version.split()[0]}`")
-    try:
-        import torch
-        st.markdown(f"🔥 PyTorch: `{torch.__version__}`")
-    except ImportError:
-        st.markdown("🔥 PyTorch: ❌ not installed")
-    try:
-        import sklearn
-        st.markdown(f"🤖 sklearn: `{sklearn.__version__}`")
-    except ImportError:
-        st.markdown("🤖 sklearn: ❌")
-    try:
-        import xgboost
-        st.markdown(f"⚡ XGBoost: `{xgboost.__version__}`")
-    except ImportError:
-        st.markdown("⚡ XGBoost: ❌")
-
-    st.divider()
-    if st.button("🔄 Reset All", width="stretch"):
-        for k in list(st.session_state.keys()):
-            del st.session_state[k]
-        st.rerun()
-
-def _init_session():
-    defaults = {
-        "data_loader": DataLoader(),
-        "powerbi_exporter": PowerBIExporter(OUTPUT_DIR),
-        "df": None,
-        "data_summary": None,
-        "ml_pipeline": None,
-        "ml_results": None,
-        "ml_metrics": None,
-        "dl_pipeline": None,
-        "gen_ai": GenerativeAI(),
-        "dl_results": None,
-        "uploaded_image": None,
-        "target_column": None,
-    }
-    for k, v in defaults.items():
-        if k not in st.session_state:
-            st.session_state[k] = v
-
-    if st.session_state.dl_pipeline is None and DL_IMPORT_OK:
-        try:
-            st.session_state.dl_pipeline = DeepLearningPipeline()
-        except Exception:
-            st.session_state.dl_pipeline = None
-
-_init_session()
-
-if api_key_input:
-    st.session_state.gen_ai = GenerativeAI(api_key=api_key_input, provider=provider_choice)
-
-def render_metrics_row(metrics: dict):
-    numeric = {k: v for k, v in metrics.items() if isinstance(v, (int, float)) and not isinstance(v, bool)}
-    if not numeric:
-        return
-    cols = st.columns(min(len(numeric), 4))
-    for idx, (k, v) in enumerate(list(numeric.items())[:4]):
-        cols[idx % 4].metric(
-            k.replace("_", " ").title(),
-            f"{v:.4f}" if isinstance(v, float) else str(v),
-        )
-
-def section_header(icon: str, title: str):
-    st.markdown(f"### {icon} {title}")
-
-tab1, tab2, tab3, tab4, tab5 = st.tabs([
-    "📊 Data", "🧠 ML Pipeline", "🔮 Deep Learning", "💡 Generative AI", "📤 Power BI"
-])
-
-with tab1:
-    section_header("📊", "Data Loading & Exploration")
-
-    col_up, col_sum = st.columns([2, 1])
-
-    with col_up:
-        uploaded_file = st.file_uploader(
-            "Upload CSV, Excel, JSON, or Image",
-            type=["csv", "xlsx", "xls", "json", "png", "jpg", "jpeg", "bmp", "webp"],
-            help="Supports tabular data and images.",
-        )
-
-        if uploaded_file:
-            try:
-                if uploaded_file.type.startswith("image"):
-                    img = Image.open(uploaded_file).convert("RGB")
-                    st.image(img, caption=uploaded_file.name, use_column_width=False, width=400)
-                    st.session_state.uploaded_image = img
-                    st.success(f"✅ Image loaded: **{uploaded_file.name}**  ({img.size[0]}×{img.size[1]} px)")
-                else:
-                    name = uploaded_file.name.lower()
-                    if name.endswith(".csv"):
-                        df = pd.read_csv(uploaded_file)
-                    elif name.endswith((".xlsx", ".xls")):
-                        df = pd.read_excel(uploaded_file)
-                    elif name.endswith(".json"):
-                        df = pd.read_json(uploaded_file)
-                    else:
-                        txt = uploaded_file.read().decode("utf-8")
-                        st.text_area("📄 Text Content", txt, height=200)
-                        df = None
-
-                    if df is not None:
-                        st.session_state.df = df
-                        st.session_state.data_summary = st.session_state.data_loader.get_data_summary(df)
-                        st.success(f"✅ **{uploaded_file.name}** — {df.shape[0]:,} rows × {df.shape[1]} columns")
-
-            except Exception as e:
-                st.error(f"❌ Load error: {e}")
-
-    with col_sum:
-        section_header("📋", "Summary")
-        if st.session_state.data_summary:
-            s = st.session_state.data_summary
-            st.metric("Rows", f"{s['row_count']:,}")
-            st.metric("Columns", s["features"])
-            st.metric("Missing Values", sum(v for v in s["missing_values"].values() if isinstance(v, (int, float))))
-            st.metric("Duplicate Rows", s.get("duplicate_rows", 0))
-
-    if st.session_state.df is not None:
-        df = st.session_state.df
-        st.divider()
-
-        t_prev, t_info, t_stats, t_corr, t_dist = st.tabs(
-            ["🔍 Preview", "📋 Column Info", "📊 Statistics", "🔗 Correlation", "📈 Distributions"]
-        )
-
-        with t_prev:
-            n = st.slider("Rows to preview", 5, min(100, len(df)), 10, key="prev_n")
-            st.dataframe(df.head(n), width="stretch")
-
-        with t_info:
-            info_df = pd.DataFrame({
-                "Column": df.columns,
-                "Type": df.dtypes.astype(str).values,
-                "Non-Null": df.count().values,
-                "Null": df.isnull().sum().values,
-                "Null %": (df.isnull().sum() / len(df) * 100).round(1).values,
-                "Unique": df.nunique().values,
-            })
-            st.dataframe(info_df, width="stretch")
-
-        with t_stats:
-            numeric_df = df.select_dtypes(include=[np.number])
-            if not numeric_df.empty:
-                st.dataframe(numeric_df.describe().round(4), width="stretch")
-            else:
-                st.info("No numeric columns to describe.")
-
-        with t_corr:
-            numeric_df = df.select_dtypes(include=[np.number])
-            if numeric_df.shape[1] >= 2:
-                fig_corr = create_correlation_heatmap(df)
-                st.plotly_chart(fig_corr, width="stretch")
-            else:
-                st.info("Need at least 2 numeric columns for correlation.")
-
-        with t_dist:
-            num_cols = df.select_dtypes(include=[np.number]).columns.tolist()
-            cat_cols = df.select_dtypes(include=["object", "category"]).columns.tolist()
-            if num_cols:
-                sel_col = st.selectbox("Select column", num_cols + cat_cols, key="dist_col")
-                if df[sel_col].dtype == "object" or df[sel_col].nunique() <= 20:
-                    fig_d = create_class_distribution(df[sel_col], title=f"Distribution: {sel_col}")
-                else:
-                    import plotly.express as px
-                    fig_d = px.histogram(df, x=sel_col, title=f"Distribution: {sel_col}",
-                                        template="plotly_dark", color_discrete_sequence=["#6C63FF"])
-                st.plotly_chart(fig_d, width="stretch")
-            else:
-                st.info("No columns available for distribution plot.")
-
-with tab2:
-    section_header("🧠", "Machine Learning Pipeline")
-
-    if st.session_state.df is None:
-        st.info("👆 Load a dataset in the **Data** tab first.")
-    else:
-        df = st.session_state.df
-
-        c1, c2, c3 = st.columns(3)
-        with c1:
-            target_col = st.selectbox("🎯 Target Column", df.columns, key="ml_target")
-            st.session_state.target_column = target_col
-            unique_count = df[target_col].nunique()
-            auto_task = st.session_state.data_loader.detect_task_type(df[target_col])
-            st.caption(f"Unique values: **{unique_count}** — Suggested: **{auto_task}**")
-
-        with c2:
-            task_type = st.selectbox(
-                "📊 Task Type", ["classification", "regression"],
-                index=0 if auto_task == "classification" else 1,
-            )
-
-        with c3:
-            model_options = ["Random Forest", "Gradient Boosting", "Logistic Regression", "SVM", "Ensemble"]
-            if "xgboost" in sys.modules or True:
-                try:
-                    import xgboost
-                    model_options.insert(2, "XGBoost")
-                except ImportError:
-                    pass
-            if LGB_OK:
-                model_options.insert(3, "LightGBM")
-
-            model_choice = st.selectbox("🤖 Model", model_options)
-
-        c4, c5 = st.columns(2)
-        with c4:
-            test_size = st.slider("Test Split", 0.1, 0.4, 0.2, 0.05)
-        with c5:
-            show_importance = st.checkbox("Show Feature Importance", value=True)
-
-        with st.expander("📊 Target Distribution", expanded=False):
-            fig_target = create_class_distribution(df[target_col], title=f"Target: {target_col}")
-            st.plotly_chart(fig_target, width="stretch")
-
-        if st.button("🚀 Train Model", type="primary", width="stretch"):
-            with st.spinner(f"Training **{model_choice}** ({task_type})…"):
-                try:
-                    X_raw = df.drop(columns=[target_col])
-                    y_raw = df[target_col]
-
-                    if model_choice == "XGBoost":
-                        pipeline = XGBoostPipeline(task_type=task_type)
-                    elif model_choice == "LightGBM" and LGB_OK:
-                        pipeline = LightGBMPipeline(task_type=task_type)
-                    elif model_choice == "Ensemble":
-                        pipeline = EnsemblePipeline(task_type=task_type)
-                    else:
-                        pipeline = MLPipeline(task_type=task_type, model_name=model_choice)
-
-                    if task_type == "classification":
-                        from sklearn.preprocessing import LabelEncoder as _LE
-                        _le = _LE()
-                        y = pd.Series(_le.fit_transform(y_raw.astype(str)), name=target_col)
-                        pipeline.label_encoder = _le
-                        pipeline.classes_ = _le.classes_
-                    else:
-                        y = y_raw.astype(float)
-
-                    X_proc = pipeline._preprocess_X(
-                        pd.get_dummies(X_raw.select_dtypes(exclude=["datetime64"]), drop_first=True),
-                        fit=True,
-                    )
-                    pipeline.feature_names = pd.get_dummies(
-                        X_raw.select_dtypes(exclude=["datetime64"]), drop_first=True
-                    ).columns.tolist()
-
-                    metrics = pipeline.train(X_proc, y.values, test_size=test_size)
-
-                    st.session_state.ml_pipeline = pipeline
-                    st.session_state.ml_metrics = metrics
-                    st.session_state.ml_results = {
-                        "metrics": metrics,
-                        "feature_importance": pipeline.get_feature_importance().to_dict("records") if show_importance else [],
-                        "model_name": model_choice,
-                        "task_type": task_type,
-                        "y_test": pipeline.y_test.tolist() if pipeline.y_test is not None else [],
-                        "y_pred": pipeline.y_pred.tolist() if pipeline.y_pred is not None else [],
-                    }
-
-                    st.success(f"🎉 **{model_choice}** trained successfully!")
-
-                except Exception as e:
-                    st.error(f"❌ Training failed: {e}")
-                    import traceback
-                    with st.expander("🔍 Error details"):
-                        st.code(traceback.format_exc())
-
-        if st.session_state.ml_results:
-            res = st.session_state.ml_results
-            metrics = res["metrics"]
-
-            st.divider()
-            st.subheader(f"📈 Results — {res.get('model_name', 'Model')}")
-            render_metrics_row(metrics)
-
-            r1, r2 = st.tabs(["📊 Charts", "📋 Report"])
-
-            with r1:
-                ch1, ch2 = st.columns(2)
-                with ch1:
-                    fig_metrics = create_metrics_dashboard(metrics)
-                    st.plotly_chart(fig_metrics, width="stretch")
-
-                with ch2:
-                    if res.get("feature_importance"):
-                        fig_imp = create_feature_importance_chart(
-                            pd.DataFrame(res["feature_importance"]), top_n=15
-                        )
-                        st.plotly_chart(fig_imp, width="stretch")
-
-                y_test = res.get("y_test", [])
-                y_pred = res.get("y_pred", [])
-
-                if y_test and y_pred:
-                    if res["task_type"] == "classification":
-                        classes = (
-                            [str(c) for c in st.session_state.ml_pipeline.classes_]
-                            if st.session_state.ml_pipeline and st.session_state.ml_pipeline.classes_ is not None
-                            else None
-                        )
-                        unique_encoded = sorted(set(y_test + y_pred))
-                        if classes and len(classes) >= len(unique_encoded):
-                            label_map = {i: c for i, c in enumerate(classes)}
-                            y_test_labels = [label_map.get(v, str(v)) for v in y_test]
-                            y_pred_labels = [label_map.get(v, str(v)) for v in y_pred]
-                            display_classes = [label_map.get(i, str(i)) for i in unique_encoded]
-                        else:
-                            y_test_labels = [str(v) for v in y_test]
-                            y_pred_labels = [str(v) for v in y_pred]
-                            display_classes = [str(v) for v in unique_encoded]
-
-                        fig_cm = create_confusion_matrix(y_test_labels, y_pred_labels, labels=display_classes)
-                        st.plotly_chart(fig_cm, width="stretch")
-                    else:
-                        fig_av = create_actual_vs_predicted(y_test, y_pred)
-                        st.plotly_chart(fig_av, width="stretch")
-
-            with r2:
-                if "classification_report" in metrics:
-                    st.text(metrics["classification_report"])
-                if "confusion_matrix" in metrics:
-                    with st.expander("Raw Confusion Matrix"):
-                        st.write(np.array(metrics["confusion_matrix"]))
-                with st.expander("All Metrics (JSON)"):
-                    safe_metrics = {k: v for k, v in metrics.items() if isinstance(v, (int, float, str))}
-                    st.json(safe_metrics)
-
-            if st.button("📤 Export Predictions to CSV"):
-                try:
-                    pipeline = st.session_state.ml_pipeline
-                    X_export = df.drop(columns=[target_col])
-                    X_proc_export = pipeline._preprocess_X(
-                        pd.get_dummies(X_export.select_dtypes(exclude=["datetime64"]), drop_first=True),
-                        fit=False,
-                    )
-                    preds = pipeline.predict(X_proc_export)
-                    export_df = df.copy()
-                    export_df["prediction"] = preds
-                    csv_path = st.session_state.powerbi_exporter.export_to_csv(export_df, "ml_predictions")
-                    st.success(f"✅ Saved → `{csv_path}`")
-                    st.download_button(
-                        "⬇️ Download CSV",
-                        export_df.to_csv(index=False).encode(),
-                        file_name="ml_predictions.csv",
-                        mime="text/csv",
-                    )
-                except Exception as e:
-                    st.error(f"❌ Export error: {e}")
-
-with tab3:
-    section_header("🔮", "Advanced AI — Deep Learning")
-
-    dl = st.session_state.dl_pipeline
-
-    if dl is None:
-        if DL_IMPORT_OK:
-            try:
-                st.session_state.dl_pipeline = DeepLearningPipeline()
-                dl = st.session_state.dl_pipeline
-            except Exception as e:
-                st.error(f"Could not initialise DL pipeline: {e}")
-        else:
-            st.warning("⚠️ Deep learning import failed.")
-
-    if dl is not None:
-        status = dl.get_status()
-        c1, c2, c3 = st.columns(3)
-        c1.metric("PyTorch", "✅ Available" if status["torch_available"] else "❌ Not installed")
-        c2.metric("Transformers", "✅ Available" if status["transformers_available"] else "⚠️ Fallback mode")
-        c3.metric("Image / Text", "✅ Ready")
-
-        if not status["torch_available"]:
-            st.info("📦 Install PyTorch for GPU-accelerated inference")
-
-    dl_option = st.radio(
-        "Select Feature",
-        ["🖼️ Image Classification", "📝 Text Embeddings", "🏷️ Text Classification"],
-        horizontal=True,
-    )
-
-    if dl_option == "🖼️ Image Classification":
-        ci1, ci2 = st.columns(2)
-        with ci1:
-            section_header("📤", "Input Image")
-            if st.session_state.uploaded_image:
-                st.image(st.session_state.uploaded_image, caption="Loaded from Data tab", width=300)
-            else:
-                local_img = st.file_uploader("Upload image here", type=["jpg", "jpeg", "png", "bmp", "webp"], key="dl_img")
-                if local_img:
-                    img = Image.open(local_img).convert("RGB")
-                    st.session_state.uploaded_image = img
-                    st.image(img, width=300)
-
-            model_choice_dl = st.selectbox("Model", ["resnet50", "efficientnet_b0", "mobilenet_v3"])
-
-            if st.button("🔍 Classify", type="primary"):
-                if st.session_state.uploaded_image and dl:
-                    with st.spinner("Running inference…"):
-                        try:
-                            dl.image_classifier.model_name = model_choice_dl
-                            dl.image_classifier.model = None
-                            results = dl.process_image(st.session_state.uploaded_image)
-                            st.session_state.dl_results = results
-                            st.success("✅ Done!")
-                        except Exception as e:
-                            st.error(f"❌ {e}")
-                else:
-                    st.warning("⚠️ Upload an image first.")
-
-        with ci2:
-            section_header("📊", "Predictions")
-            if st.session_state.dl_results and st.session_state.dl_results.get("type") == "image":
-                preds = st.session_state.dl_results.get("predictions", [])
-                if preds:
-                    import plotly.graph_objects as go
-                    labels = [p.get("label", f"class_{p.get('class_id','?')}") for p in preds]
-                    probs = [p.get("probability", 0) for p in preds]
-                    fig_pred = go.Figure(go.Bar(
-                        x=probs, y=labels, orientation="h",
-                        marker=dict(color=probs, colorscale="Viridis"),
-                    ))
-                    fig_pred.update_layout(
-                        title="Class Probabilities", yaxis=dict(autorange="reversed"),
-                        template="plotly_dark", paper_bgcolor="rgba(0,0,0,0)",
-                    )
-                    st.plotly_chart(fig_pred, width="stretch")
-                else:
-                    st.info("No predictions yet.")
-
-    elif dl_option == "📝 Text Embeddings":
-        section_header("🔢", "Generate Text Embeddings")
-        st.info("Text embeddings map words/sentences into high-dimensional vectors.")
-
-        text_input = st.text_area("Enter text", "The quick brown fox jumps over the lazy dog.", height=120)
-        compare_text = st.text_input("Compare with (optional)", "")
-
-        if st.button("⚡ Generate Embeddings", type="primary"):
-            with st.spinner("Processing…"):
-                try:
-                    results = dl.process_text(text_input)
-                    st.session_state.dl_results = results
-                    st.success(f"✅ Embeddings generated via **{results.get('method', 'unknown')}**")
-
-                    cm1, cm2, cm3 = st.columns(3)
-                    cm1.metric("Shape", str(results.get("embeddings_shape", "N/A")))
-                    cm2.metric("Dimension", results.get("embedding_dim", "N/A"))
-                    cm3.metric("Device", results.get("device", "N/A"))
-
-                    if compare_text:
-                        sim = dl.text_embedder.semantic_similarity(text_input, compare_text)
-                        st.metric("🔗 Cosine Similarity", f"{sim:.4f}")
-
-                except Exception as e:
-                    st.error(f"❌ {e}")
-
-    elif dl_option == "🏷️ Text Classification":
-        section_header("🎯", "Train Text Classifier")
-
-        if st.session_state.df is not None:
-            df = st.session_state.df
-            text_cols = df.select_dtypes(include=["object"]).columns.tolist()
-
-            if text_cols:
-                tc1, tc2 = st.columns(2)
-                with tc1:
-                    text_col = st.selectbox("Text Column", text_cols)
-                with tc2:
-                    label_col = st.selectbox("Label Column", df.columns.tolist())
-
-                epochs = st.slider("Training Epochs", 1, 10, 3, key="nlp_epochs")
-
-                if st.button("🎓 Train Classifier", type="primary"):
-                    with st.spinner("Training…"):
-                        try:
-                            texts = df[text_col].dropna().astype(str).tolist()
-                            labels = df[label_col].dropna().astype(str).tolist()
-                            min_len = min(len(texts), len(labels))
-                            texts, labels = texts[:min_len], labels[:min_len]
-
-                            if min_len < 5:
-                                st.error("❌ Need at least 5 samples.")
-                            else:
-                                dl.nlp_classifier.train_classifier(texts, labels, epochs=epochs)
-                                st.success("🎉 Classifier trained!")
-
-                                sample = texts[:3]
-                                preds = dl.nlp_classifier.predict(sample)
-                                st.subheader("Sample Predictions")
-                                for t, p in zip(sample, preds):
-                                    st.markdown(f"**Text:** {t[:80]}…  \n**→ {p['predicted_class']}** ({p['confidence']:.2%})")
-                        except Exception as e:
-                            st.error(f"❌ {e}")
-
-                st.divider()
-                custom_text = st.text_area("🔍 Classify custom text", key="nlp_custom")
-                if st.button("Predict", key="nlp_predict") and custom_text:
-                    try:
-                        result = dl.nlp_classifier.predict([custom_text])
-                        if result:
-                            st.metric("Predicted Class", result[0]["predicted_class"])
-                            st.metric("Confidence", f"{result[0]['confidence']:.2%}")
-                            st.json(result[0]["probabilities"])
-                    except Exception as e:
-                        st.error(f"❌ {e}")
-            else:
-                st.warning("⚠️ No text columns found in the loaded dataset.")
-        else:
-            st.info("👆 Load a dataset with text columns in the **Data** tab first.")
-
-with tab4:
-    section_header("💡", "Generative AI Integration")
-
-    gen_ai = st.session_state.gen_ai
-    if gen_ai.is_available():
-        st.success(f"✅ **{gen_ai._provider_config['name']}** connected")
-    else:
-        st.warning("⚠️ No API key configured — running in offline fallback mode.")
-        st.info(f"Add your key in the sidebar. Get one from: {gen_ai._provider_config['url']}")
-
-    gen_option = st.selectbox(
-        "Analysis Type",
-        ["General Insights", "Trends Analysis", "Anomaly Detection", "Recommendations", "Generate Report", "Q&A"],
-    )
-
-    analysis_map = {
-        "General Insights": "general",
-        "Trends Analysis": "trends_analysis",
-        "Anomaly Detection": "anomaly_detection",
-        "Recommendations": "recommendations",
-    }
-
-    if gen_option in analysis_map:
-        if st.button("✨ Generate", type="primary"):
-            if st.session_state.data_summary:
-                with st.spinner("🤖 Generating…"):
-                    insights = gen_ai.generate_insights(
-                        st.session_state.data_summary, analysis_map[gen_option]
-                    )
-                st.markdown("### 📝 Result")
-                st.markdown(insights)
-            else:
-                st.warning("⚠️ Load data first in the **Data** tab.")
-
-    elif gen_option == "Generate Report":
-        if st.button("📄 Generate Report", type="primary"):
-            payload = {
-                "ml_metrics": st.session_state.ml_metrics or {},
-                "data_summary": st.session_state.data_summary or {},
-                "model": st.session_state.ml_results.get("model_name", "N/A") if st.session_state.ml_results else "N/A",
-            }
-            with st.spinner("📝 Writing report…"):
-                report = gen_ai.generate_report(payload)
-
-            st.markdown("### 📄 Report")
-            st.text_area("", report, height=400)
-            st.download_button(
-                "⬇️ Download Report",
-                report.encode(),
-                file_name="ai_report.txt",
-                mime="text/plain",
-            )
-
-    elif gen_option == "Q&A":
-        question = st.text_input("❓ Ask a question about your data")
-        if st.button("🔍 Ask", type="primary") and question:
-            context = json.dumps(st.session_state.data_summary, default=str) if st.session_state.data_summary else None
-            with st.spinner("Thinking…"):
-                answer = gen_ai.answer_question(question, context)
-            st.markdown("### 💬 Answer")
-            st.info(answer)
-
-with tab5:
-    section_header("📤", "Power BI Export")
-
-    exporter = st.session_state.powerbi_exporter
-
-    if st.session_state.df is None:
-        st.info("👆 Load data first.")
-    else:
-        df = st.session_state.df
-
-        st.markdown("### 📦 Export Options")
-        ec1, ec2 = st.columns(2)
-
-        with ec1:
-            include_parquet = st.checkbox("Include Parquet files", value=True)
-            export_name = st.text_input("Dataset name", value="main_data")
-
-        with ec2:
-            st.markdown("**Available datasets:**")
-            available = {"Main Data": df}
-            if st.session_state.ml_results and st.session_state.ml_results.get("feature_importance"):
-                available["Feature Importance"] = pd.DataFrame(st.session_state.ml_results["feature_importance"])
-            for name in available:
-                st.markdown(f"• {name}")
-
-        if st.button("📊 Export All for Power BI", type="primary", width="stretch"):
-            with st.spinner("Exporting…"):
-                try:
-                    named = {export_name: df}
-                    if "Feature Importance" in available:
-                        named["feature_importance"] = available["Feature Importance"]
-                    paths = exporter.export_all(named, include_parquet=include_parquet)
-                    st.success(f"✅ Exported **{len(paths)}** files to `{OUTPUT_DIR}`")
-                    for p in paths:
-                        st.markdown(f"  • `{p.name}`")
-                except Exception as e:
-                    st.error(f"❌ Export error: {e}")
-
-        st.divider()
-        st.markdown("### 📋 Power BI Instructions")
-        st.info(exporter.generate_powerbi_instructions())
-
-        st.markdown("### ⬇️ Direct Download")
-        dl1, dl2 = st.columns(2)
-        with dl1:
-            st.download_button(
-                "⬇️ Download Main Data (CSV)",
-                df.to_csv(index=False).encode(),
-                file_name=f"{export_name}.csv",
-                mime="text/csv",
-                width="stretch",
-            )
-        with dl2:
-            if st.session_state.ml_results and st.session_state.ml_results.get("feature_importance"):
-                fi_df = pd.DataFrame(st.session_state.ml_results["feature_importance"])
-                st.download_button(
-                    "⬇️ Download Feature Importance (CSV)",
-                    fi_df.to_csv(index=False).encode(),
-                    file_name="feature_importance.csv",
-                    mime="text/csv",
-                    width="stretch",
-                )
-
-st.divider()
-st.markdown(
-    '<p class="footer-text">Analytics-with-Ayush &nbsp;|&nbsp; Machine Learning • Deep Learning • Generative AI • Power BI'
-    '&nbsp;&nbsp;<span class="brand">| KYOTO-Z |</span></p>',
-    unsafe_allow_html=True,
-)