Upload 3 files

app.py

@@ -0,0 +1,1323 @@
+"""
+app.py  —  Multi-AI Analytics Platform v2.1 (Clean Edition)
+Run:  streamlit run app.py
+
+Requirements (install before running):
+    pip install streamlit pandas numpy pillow plotly scikit-learn xgboost lightgbm
+    pip install opencv-python-headless transformers torch torchvision
+    pip install openai google-generativeai anthropic   # optional, for API providers
+    pip install spacy && python -m spacy download en_core_web_sm   # optional NER
+
+Place these files in the SAME folder as app.py:
+    generative_ai.py
+    nlp_module.py
+    ml_models.py        (your existing file — unchanged)
+    dl_module.py        (your existing file — unchanged)
+    data/data_loader.py
+    data/powerbi_export.py
+    config.py
+    utils/helpers.py
+"""
+import warnings
+warnings.filterwarnings("ignore")
+
+import os
+import sys
+import json
+from pathlib import Path
+from typing import Any, Optional
+
+import streamlit as st
+import pandas as pd
+import numpy as np
+from PIL import Image
+
+# ── Root path setup ───────────────────────────────────────────────────────────
+ROOT = Path(__file__).parent
+sys.path.insert(0, str(ROOT))
+
+# ── Core imports ──────────────────────────────────────────────────────────────
+try:
+    from config import Config, OUTPUT_DIR
+except ImportError:
+    OUTPUT_DIR = ROOT / "outputs"
+    OUTPUT_DIR.mkdir(exist_ok=True)
+
+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, OPENAI_OK, GOOGLE_OK, ANTHROPIC_OK
+from utils.helpers import (
+    create_feature_importance_chart, create_metrics_dashboard,
+    create_confusion_matrix, create_correlation_heatmap,
+    create_class_distribution, create_actual_vs_predicted,
+)
+
+try:
+    from models.ml_models import LightGBMPipeline
+    LGB_OK = True
+except Exception:
+    LightGBMPipeline = None
+    LGB_OK = False
+
+
+# ── Page config ───────────────────────────────────────────────────────────────
+st.set_page_config(
+    page_title="Multi-AI Analytics Platform",
+    page_icon="⚡",
+    layout="wide",
+    initial_sidebar_state="expanded",
+)
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+#  Global CSS — Aurora Dark theme
+# ══════════════════════════════════════════════════════════════════════════════
+st.markdown("""
+<style>
+@import url('https://fonts.googleapis.com/css2?family=Outfit:wght@300;400;500;600;700;800&family=JetBrains+Mono:wght@400;500;600&display=swap');
+
+*, *::before, *::after { box-sizing: border-box; }
+html, body, [class*="css"] { font-family: 'Outfit', sans-serif !important; }
+
+.stApp {
+    background: #080b14;
+    background-image:
+        radial-gradient(ellipse 80% 50% at 20% -10%, rgba(99,102,241,0.18) 0%, transparent 60%),
+        radial-gradient(ellipse 60% 40% at 80% 110%, rgba(20,184,166,0.14) 0%, transparent 55%),
+        radial-gradient(ellipse 50% 60% at 50% 50%, rgba(139,92,246,0.05) 0%, transparent 70%);
+    color: #e2e8f0;
+}
+
+section[data-testid="stSidebar"] {
+    background: linear-gradient(180deg, #0c0f1d 0%, #0e1120 60%, #0a0d18 100%) !important;
+    border-right: 1px solid rgba(99,102,241,0.2);
+}
+section[data-testid="stSidebar"] * { color: #cbd5e1 !important; }
+
+.hero-wrap {
+    background: linear-gradient(135deg,
+        rgba(99,102,241,0.12) 0%, rgba(139,92,246,0.08) 40%, rgba(20,184,166,0.1) 100%);
+    border: 1px solid rgba(99,102,241,0.25);
+    border-radius: 20px;
+    padding: 2.4rem 2rem 2rem;
+    margin-bottom: 1.8rem;
+    position: relative; overflow: hidden;
+}
+.hero-title {
+    font-size: 2.6rem; font-weight: 800; line-height: 1.2;
+    background: linear-gradient(135deg, #a78bfa 0%, #60a5fa 50%, #2dd4bf 100%);
+    -webkit-background-clip: text; -webkit-text-fill-color: transparent;
+    background-clip: text; margin-bottom: 0.5rem;
+}
+.hero-sub { font-size: 1rem; color: #94a3b8; letter-spacing: 0.06em; }
+.hero-badges { display: flex; gap: 10px; flex-wrap: wrap; margin-top: 1.2rem; }
+.badge {
+    background: rgba(99,102,241,0.15); border: 1px solid rgba(99,102,241,0.3);
+    color: #a78bfa; padding: 4px 14px; border-radius: 999px;
+    font-size: 0.78rem; font-weight: 600; letter-spacing: 0.04em;
+    font-family: 'JetBrains Mono', monospace;
+}
+.badge.teal { background: rgba(20,184,166,0.12); border-color: rgba(20,184,166,0.3); color: #2dd4bf; }
+.badge.blue { background: rgba(59,130,246,0.12); border-color: rgba(59,130,246,0.3); color: #60a5fa; }
+
+.mod-grid { display: grid; grid-template-columns: repeat(3, 1fr); gap: 1rem; margin: 1.2rem 0; }
+.mod-card {
+    background: linear-gradient(135deg, rgba(15,18,35,0.9) 0%, rgba(20,24,42,0.9) 100%);
+    border: 1px solid rgba(99,102,241,0.2); border-radius: 16px;
+    padding: 1.4rem 1.2rem; transition: border-color 0.25s, transform 0.2s;
+    position: relative; overflow: hidden;
+}
+.mod-card:hover { border-color: rgba(139,92,246,0.55); transform: translateY(-2px); }
+.mod-card .icon { font-size: 2.2rem; margin-bottom: 0.7rem; }
+.mod-card .title { font-size: 1.05rem; font-weight: 700; color: #f1f5f9; margin-bottom: 0.3rem; }
+.mod-card .desc  { font-size: 0.82rem; color: #64748b; line-height: 1.5; }
+.mod-card .glow {
+    position: absolute; top: -40px; right: -40px;
+    width: 100px; height: 100px; border-radius: 50%;
+    background: radial-gradient(circle, var(--gc) 0%, transparent 70%); opacity: 0.35;
+}
+
+.stat-row { display: flex; gap: 1rem; margin: 1rem 0; }
+.stat-card {
+    flex: 1;
+    background: linear-gradient(135deg, rgba(15,18,35,0.95) 0%, rgba(20,24,45,0.95) 100%);
+    border: 1px solid rgba(99,102,241,0.18); border-radius: 14px;
+    padding: 1.1rem 1rem; text-align: center;
+}
+.stat-val { font-size: 1.7rem; font-weight: 700; color: #a78bfa; font-family: 'JetBrains Mono', monospace; }
+.stat-lbl { font-size: 0.75rem; color: #64748b; margin-top: 2px; text-transform: uppercase; letter-spacing: 0.07em; }
+
+.sec-head {
+    font-size: 1.35rem; font-weight: 700;
+    background: linear-gradient(90deg, #a78bfa, #60a5fa);
+    -webkit-background-clip: text; -webkit-text-fill-color: transparent;
+    background-clip: text; margin: 1rem 0 0.6rem;
+    display: flex; align-items: center; gap: 0.5rem;
+}
+
+.info-box {
+    background: rgba(99,102,241,0.08); border-left: 4px solid #6366f1;
+    border-radius: 0 12px 12px 0; padding: 0.9rem 1.1rem; margin: 0.7rem 0;
+    color: #cbd5e1; line-height: 1.6;
+}
+.success-box {
+    background: rgba(20,184,166,0.08); border-left: 4px solid #14b8a6;
+    border-radius: 0 12px 12px 0; padding: 0.9rem 1.1rem; margin: 0.7rem 0;
+    color: #99f6e4;
+}
+.result-box {
+    background: linear-gradient(135deg, rgba(15,18,35,0.98) 0%, rgba(20,24,48,0.98) 100%);
+    border: 1px solid rgba(99,102,241,0.22); border-radius: 14px;
+    padding: 1.3rem 1.4rem; margin: 0.8rem 0; color: #e2e8f0; line-height: 1.75;
+}
+
+.stButton > button {
+    background: linear-gradient(135deg, #6366f1 0%, #8b5cf6 100%) !important;
+    color: white !important; border: none !important; border-radius: 10px !important;
+    font-weight: 600 !important; font-family: 'Outfit', sans-serif !important;
+    letter-spacing: 0.02em; transition: opacity 0.2s, transform 0.15s !important;
+    padding: 0.55rem 1.4rem !important;
+}
+.stButton > button:hover { opacity: 0.88 !important; transform: translateY(-1px) !important; }
+
+.stTabs [data-baseweb="tab-list"] {
+    gap: 6px; background: rgba(8,11,20,0.6); border-radius: 12px; padding: 4px;
+    border: 1px solid rgba(99,102,241,0.15);
+}
+.stTabs [data-baseweb="tab"] {
+    border-radius: 9px; padding: 0.5rem 1.2rem; font-weight: 600; color: #64748b;
+}
+.stTabs [aria-selected="true"] {
+    background: linear-gradient(135deg, rgba(99,102,241,0.3), rgba(139,92,246,0.3)) !important;
+    color: #a78bfa !important;
+}
+
+.stTextArea textarea, .stTextInput input, .stSelectbox select {
+    background: rgba(15,18,35,0.9) !important; border: 1px solid rgba(99,102,241,0.2) !important;
+    border-radius: 10px !important; color: #e2e8f0 !important;
+}
+.stDataFrame { border: 1px solid rgba(99,102,241,0.2) !important; border-radius: 12px !important; }
+[data-testid="stMetricValue"] { color: #a78bfa !important; font-weight: 700; }
+[data-testid="stMetricLabel"] { color: #64748b !important; }
+[data-testid="stChatMessage"] {
+    background: rgba(15,18,35,0.7) !important;
+    border: 1px solid rgba(99,102,241,0.15) !important; border-radius: 14px !important;
+}
+.footer {
+    text-align: center; color: #334155; font-size: 0.78rem;
+    margin-top: 2.5rem; padding: 1rem;
+    border-top: 1px solid rgba(99,102,241,0.1); letter-spacing: 0.06em;
+}
+.footer span { color: #6366f1; font-family: 'JetBrains Mono', monospace; font-weight: 600; }
+.stSpinner > div { border-top-color: #6366f1 !important; }
+hr { border-color: rgba(99,102,241,0.15) !important; }
+::-webkit-scrollbar { width: 6px; height: 6px; }
+::-webkit-scrollbar-track { background: #080b14; }
+::-webkit-scrollbar-thumb { background: rgba(99,102,241,0.4); border-radius: 3px; }
+</style>
+""", unsafe_allow_html=True)
+
+
+# ═════════════════════��════════════════════════════════════════════════════════
+#  Sidebar
+# ══════════════════════════════════════════════════════════════════════════════
+with st.sidebar:
+    st.markdown("""
+    <div style="text-align:center;padding:1rem 0 0.5rem">
+        <div style="font-size:2.4rem">⚡</div>
+        <div style="font-size:1.1rem;font-weight:800;
+                    background:linear-gradient(135deg,#a78bfa,#2dd4bf);
+                    -webkit-background-clip:text;-webkit-text-fill-color:transparent">
+            AI Platform
+        </div>
+        <div style="font-size:0.72rem;color:#475569;letter-spacing:0.08em;margin-top:2px">
+            v2.1 · CLEAN EDITION
+        </div>
+    </div>
+    """, unsafe_allow_html=True)
+    st.divider()
+
+    st.markdown("### 🔑 Generative AI")
+    provider_choice = st.selectbox(
+        "Provider",
+        ["smart", "openai", "google", "anthropic"],
+        format_func=lambda x: {
+            "smart":     "⚡ Smart AI (Instant · No API Key)",
+            "openai":    "🟢 OpenAI GPT-4o",
+            "google":    "🔵 Google Gemini",
+            "anthropic": "🟣 Anthropic Claude",
+        }[x],
+    )
+    if provider_choice == "smart":
+        st.caption("✅ Instant responses — no API key, no downloads")
+        api_key_input = ""
+    else:
+        api_key_input = st.text_input("API Key", type="password", placeholder="Paste key here…")
+    st.divider()
+
+    st.markdown("### ⚙️ System Status")
+    for lib, label, emoji in [
+        ("torch",       "PyTorch",      "🔥"),
+        ("sklearn",     "sklearn",      "🤖"),
+        ("xgboost",     "XGBoost",      "⚡"),
+        ("transformers","Transformers", "🤗"),
+        ("cv2",         "OpenCV",       "📷"),
+        ("lightgbm",    "LightGBM",     "🌿"),
+    ]:
+        try:
+            mod = __import__(lib)
+            ver = getattr(mod, "__version__", "✓")
+            st.markdown(f"{emoji} {label} `{ver}`")
+        except ImportError:
+            st.markdown(f"{emoji} {label} ❌")
+    st.divider()
+
+    if st.button("🔄 Reset Session", use_container_width=True):
+        for k in list(st.session_state.keys()):
+            del st.session_state[k]
+        st.rerun()
+
+    st.markdown("""
+    <div style="text-align:center;margin-top:1rem;color:#334155;font-size:0.7rem">
+        Multi-AI Analytics Platform<br>
+        <span style="color:#6366f1;font-family:'JetBrains Mono',monospace">KYOTO-Z</span>
+    </div>""", unsafe_allow_html=True)
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+#  Session state initialisation
+# ══════════════════════════════════════════════════════════════════════════════
+def _init():
+    defaults = {
+        "data_loader":    DataLoader(),
+        "powerbi_exp":    PowerBIExporter(OUTPUT_DIR),
+        "df":             None,
+        "data_summary":   None,
+        "ml_pipeline":    None,
+        "ml_results":     None,
+        "ml_metrics":     None,
+        "gen_ai":         GenerativeAI(provider="smart"),
+        "uploaded_image": None,
+        "target_column":  None,
+    }
+    for k, v in defaults.items():
+        if k not in st.session_state:
+            st.session_state[k] = v
+
+_init()
+
+# Always rebuild gen_ai when provider/key change
+st.session_state.gen_ai = GenerativeAI(api_key=api_key_input, provider=provider_choice)
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+#  Hero Banner
+# ══════════════════════════════════════════════════════════════════════════════
+st.markdown("""
+<div class="hero-wrap">
+  <div class="hero-title">⚡ Multi-AI Analytics Platform</div>
+  <div class="hero-sub">Machine Learning &nbsp;·&nbsp; Deep Learning &nbsp;·&nbsp; NLP &nbsp;·&nbsp; Generative AI &nbsp;·&nbsp; Power BI Export</div>
+  <div class="hero-badges">
+    <span class="badge">scikit-learn</span>
+    <span class="badge">XGBoost</span>
+    <span class="badge teal">HuggingFace</span>
+    <span class="badge blue">OpenCV</span>
+    <span class="badge">PyTorch / TF</span>
+    <span class="badge teal">Plotly</span>
+    <span class="badge blue">Power BI</span>
+  </div>
+</div>
+""", unsafe_allow_html=True)
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+#  Main tabs
+# ══════════════════════════════════════════════════════════════════════════════
+tab_home, tab_data, tab_ml, tab_dl, tab_nlp, tab_genai, tab_pbi = st.tabs([
+    "🏠 Home", "📊 Data", "🤖 ML Pipeline",
+    "🧠 Deep Learning", "📝 NLP", "💡 Generative AI", "📤 Power BI",
+])
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+#  TAB 0 · HOME
+# ──────────────────────────────────────────────────────────────────────────────
+with tab_home:
+    st.markdown("""
+    <div class="mod-grid">
+      <div class="mod-card">
+        <div class="glow" style="--gc:rgba(99,102,241,0.5)"></div>
+        <div class="icon">🤖</div>
+        <div class="title">ML Pipeline</div>
+        <div class="desc">9+ models — Random Forest, XGBoost, LightGBM, Ensemble. Full metrics, ROC, feature importance.</div>
+      </div>
+      <div class="mod-card">
+        <div class="glow" style="--gc:rgba(20,184,166,0.5)"></div>
+        <div class="icon">📊</div>
+        <div class="title">Data Explorer</div>
+        <div class="desc">Upload CSV/Excel/JSON. Auto EDA, correlation heatmaps, distributions, scatter builder.</div>
+      </div>
+      <div class="mod-card">
+        <div class="glow" style="--gc:rgba(139,92,246,0.5)"></div>
+        <div class="icon">🧠</div>
+        <div class="title">Deep Learning</div>
+        <div class="desc">MobileNetV2, ResNet50, VGG16 classification. Grad-CAM, face/edge detection, image filters.</div>
+      </div>
+      <div class="mod-card">
+        <div class="glow" style="--gc:rgba(59,130,246,0.5)"></div>
+        <div class="icon">📝</div>
+        <div class="title">NLP Suite</div>
+        <div class="desc">Sentiment analysis, NER, zero-shot classification, summarization — all via HuggingFace.</div>
+      </div>
+      <div class="mod-card">
+        <div class="glow" style="--gc:rgba(236,72,153,0.5)"></div>
+        <div class="icon">💡</div>
+        <div class="title">Generative AI</div>
+        <div class="desc">GPT-4 · Gemini · Claude. Context-aware chatbot, Q&A, code gen, image generation, reports.</div>
+      </div>
+      <div class="mod-card">
+        <div class="glow" style="--gc:rgba(245,158,11,0.5)"></div>
+        <div class="icon">📤</div>
+        <div class="title">Power BI Export</div>
+        <div class="desc">Export datasets, feature importance tables, and predictions as CSV/Parquet for Power BI.</div>
+      </div>
+    </div>
+    """, unsafe_allow_html=True)
+
+    st.markdown("---")
+    c1, c2, c3, c4 = st.columns(4)
+    c1.markdown('<div class="stat-card"><div class="stat-val">9+</div><div class="stat-lbl">ML Models</div></div>', unsafe_allow_html=True)
+    c2.markdown('<div class="stat-card"><div class="stat-val">4</div><div class="stat-lbl">CNN Backbones</div></div>', unsafe_allow_html=True)
+    c3.markdown('<div class="stat-card"><div class="stat-val">5</div><div class="stat-lbl">NLP Tasks</div></div>', unsafe_allow_html=True)
+    c4.markdown('<div class="stat-card"><div class="stat-val">3</div><div class="stat-lbl">Gen AI Providers</div></div>', unsafe_allow_html=True)
+
+    st.markdown("""
+    <div class="info-box">
+    💡 <strong>Quick Start:</strong> Head to <em>📊 Data</em> to upload your dataset,
+    then use <em>🤖 ML Pipeline</em> to train models, or jump to <em>🧠 Deep Learning</em>
+    for image analysis. Use <em>💡 Generative AI</em> for automated insights.
+    </div>""", unsafe_allow_html=True)
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+#  TAB 1 · DATA
+# ──────────────────────────────────────────────────────────────────────────────
+with tab_data:
+    st.markdown('<div class="sec-head">📊 Data Loading & Exploration</div>', unsafe_allow_html=True)
+
+    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"],
+        )
+        if uploaded_file:
+            try:
+                if uploaded_file.type.startswith("image"):
+                    img = Image.open(uploaded_file).convert("RGB")
+                    st.image(img, caption=uploaded_file.name, width=420)
+                    st.session_state.uploaded_image = img
+                else:
+                    ext = Path(uploaded_file.name).suffix.lower()
+                    if ext == ".csv":
+                        df = pd.read_csv(uploaded_file)
+                    elif ext in [".xlsx", ".xls"]:
+                        df = pd.read_excel(uploaded_file)
+                    elif ext == ".json":
+                        df = pd.read_json(uploaded_file)
+                    else:
+                        df = pd.read_csv(uploaded_file)
+
+                    st.session_state.df = df
+                    st.session_state.data_summary = st.session_state.data_loader.get_data_summary(df)
+                    st.success(f"✅ Loaded **{uploaded_file.name}** — {df.shape[0]:,} rows × {df.shape[1]} cols")
+            except Exception as e:
+                st.error(f"❌ {e}")
+
+    if st.session_state.df is not None:
+        df = st.session_state.df
+        with col_sum:
+            st.markdown(f'<div class="stat-card" style="margin-bottom:8px"><div class="stat-val">{df.shape[0]:,}</div><div class="stat-lbl">Rows</div></div>', unsafe_allow_html=True)
+            st.markdown(f'<div class="stat-card" style="margin-bottom:8px"><div class="stat-val">{df.shape[1]}</div><div class="stat-lbl">Columns</div></div>', unsafe_allow_html=True)
+            st.markdown(f'<div class="stat-card"><div class="stat-val">{df.isnull().sum().sum()}</div><div class="stat-lbl">Missing</div></div>', unsafe_allow_html=True)
+
+        dtabs = st.tabs(["🔍 Preview", "📈 Statistics", "📊 Charts", "🌡️ Correlations"])
+
+        with dtabs[0]:
+            st.dataframe(df.head(50), use_container_width=True)
+
+        with dtabs[1]:
+            st.dataframe(df.describe(include="all").T, use_container_width=True)
+            col_a, col_b = st.columns(2)
+            with col_a:
+                st.markdown("**Data Types**")
+                st.dataframe(df.dtypes.rename("Type").reset_index().rename(columns={"index": "Column"}), use_container_width=True)
+            with col_b:
+                st.markdown("**Missing Values**")
+                miss = df.isnull().sum().reset_index()
+                miss.columns = ["Column", "Missing"]
+                miss["Pct"] = (miss["Missing"] / len(df) * 100).round(2)
+                st.dataframe(miss[miss["Missing"] > 0], use_container_width=True)
+
+        with dtabs[2]:
+            import plotly.express as px
+            num_cols = df.select_dtypes(include=np.number).columns.tolist()
+            cat_cols = df.select_dtypes(include="object").columns.tolist()
+            chart_type = st.selectbox("Chart Type", ["Histogram", "Bar Chart", "Scatter", "Box Plot", "Line"])
+
+            if chart_type == "Histogram" and num_cols:
+                col = st.selectbox("Column", num_cols)
+                fig = px.histogram(df, x=col, template="plotly_dark", color_discrete_sequence=["#6366f1"])
+                fig.update_layout(paper_bgcolor="rgba(0,0,0,0)", plot_bgcolor="rgba(15,18,35,0.6)")
+                st.plotly_chart(fig, use_container_width=True)
+            elif chart_type == "Bar Chart" and cat_cols and num_cols:
+                xc = st.selectbox("X (categorical)", cat_cols)
+                yc = st.selectbox("Y (numeric)", num_cols)
+                fig = px.bar(df.groupby(xc)[yc].mean().reset_index(), x=xc, y=yc,
+                             template="plotly_dark", color=yc, color_continuous_scale="Viridis")
+                fig.update_layout(paper_bgcolor="rgba(0,0,0,0)")
+                st.plotly_chart(fig, use_container_width=True)
+            elif chart_type == "Scatter" and len(num_cols) >= 2:
+                xc = st.selectbox("X", num_cols, key="sc_x")
+                yc = st.selectbox("Y", num_cols, index=1, key="sc_y")
+                cc = st.selectbox("Color", ["None"] + cat_cols)
+                fig = px.scatter(df, x=xc, y=yc, color=None if cc == "None" else cc,
+                                 template="plotly_dark", opacity=0.7)
+                fig.update_layout(paper_bgcolor="rgba(0,0,0,0)")
+                st.plotly_chart(fig, use_container_width=True)
+            elif chart_type == "Box Plot" and num_cols:
+                yc = st.selectbox("Value", num_cols, key="bp_y")
+                gc = st.selectbox("Group", ["None"] + cat_cols)
+                fig = px.box(df, y=yc, x=None if gc == "None" else gc,
+                             template="plotly_dark", color_discrete_sequence=["#8b5cf6"])
+                fig.update_layout(paper_bgcolor="rgba(0,0,0,0)")
+                st.plotly_chart(fig, use_container_width=True)
+            elif chart_type == "Line" and num_cols:
+                yc = st.selectbox("Column", num_cols, key="lc_y")
+                fig = px.line(df.reset_index(), x="index", y=yc,
+                              template="plotly_dark", color_discrete_sequence=["#2dd4bf"])
+                fig.update_layout(paper_bgcolor="rgba(0,0,0,0)")
+                st.plotly_chart(fig, use_container_width=True)
+
+        with dtabs[3]:
+            num_cols = df.select_dtypes(include=np.number).columns.tolist()
+            cat_cols = df.select_dtypes(include="object").columns.tolist()
+            if len(num_cols) >= 2:
+                fig = create_correlation_heatmap(df)
+                st.plotly_chart(fig, use_container_width=True)
+                if cat_cols:
+                    tc = st.selectbox("Class column for distribution", cat_cols)
+                    fig2 = create_class_distribution(df[tc], f"{tc} Distribution")
+                    st.plotly_chart(fig2, use_container_width=True)
+            else:
+                st.info("Need at least 2 numeric columns for correlation.")
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+#  TAB 2 · ML PIPELINE
+# ──────────────────────────────────────────────────────────────────────────────
+with tab_ml:
+    st.markdown('<div class="sec-head">🤖 Machine Learning Pipeline</div>', unsafe_allow_html=True)
+
+    if st.session_state.df is None:
+        st.markdown('<div class="info-box">👆 Load a dataset in the <strong>📊 Data</strong> tab first.</div>', unsafe_allow_html=True)
+    else:
+        df = st.session_state.df
+
+        mc1, mc2, mc3 = st.columns(3)
+        with mc1:
+            target_col = st.selectbox("🎯 Target Column", df.columns.tolist())
+            st.session_state.target_column = target_col
+        with mc2:
+            from data.data_loader import DataLoader as _DL
+            task_type = _DL().detect_task_type(df[target_col])
+            st.markdown(f"**Detected Task:** `{task_type}`")
+            model_options = {
+                "classification": ["Random Forest", "Gradient Boosting", "Logistic Regression", "SVM", "XGBoost", "LightGBM", "Ensemble"],
+                "regression":     ["Random Forest", "Gradient Boosting", "Ridge Regression", "Lasso Regression", "SVM", "XGBoost", "LightGBM", "Ensemble"],
+            }
+            model_name = st.selectbox("🧠 Algorithm", model_options[task_type])
+        with mc3:
+            test_size = st.slider("Test Split %", 10, 40, 20) / 100
+            cv_folds  = st.slider("CV Folds", 2, 10, 5)
+
+        if st.button("🚀 Train Model", type="primary", use_container_width=True):
+            with st.spinner("Training…"):
+                try:
+                    if model_name == "XGBoost":
+                        pipe = XGBoostPipeline(task_type=task_type)
+                    elif model_name == "LightGBM" and LGB_OK and LightGBMPipeline is not None:
+                        pipe = LightGBMPipeline(task_type=task_type)
+                    elif model_name == "Ensemble":
+                        pipe = EnsemblePipeline(task_type=task_type)
+                    else:
+                        pipe = MLPipeline(task_type=task_type, model_name=model_name)
+
+                    result = pipe.preprocess(df, target_col=target_col)
+                    if result is None:
+                        st.error("❌ Preprocessing returned None. Check your target column.")
+                        st.stop()
+                    X, y = result
+                    if y is None:
+                        st.error("❌ Target column could not be extracted.")
+                        st.stop()
+                    metrics = pipe.train(X, y, test_size=test_size)
+
+                    st.session_state.ml_pipeline = pipe
+                    st.session_state.ml_metrics  = metrics
+                    st.session_state.ml_results  = {
+                        "model_name": model_name,
+                        "task_type":  task_type,
+                        "feature_importance": pipe.get_feature_importance().to_dict("records")
+                            if hasattr(pipe, "get_feature_importance") else [],
+                    }
+                    st.success(f"✅ **{model_name}** trained successfully!")
+                except Exception as e:
+                    st.error(f"❌ Training failed: {e}")
+
+        if st.session_state.ml_metrics:
+            metrics = st.session_state.ml_metrics
+            st.markdown("---")
+            st.markdown('<div class="sec-head">📊 Results</div>', unsafe_allow_html=True)
+
+            num_m = {k: v for k, v in metrics.items() if isinstance(v, (int, float)) and not isinstance(v, bool)}
+            cols_m = st.columns(min(len(num_m), 4))
+            for i, (k, v) in enumerate(list(num_m.items())[:4]):
+                cols_m[i].metric(k.replace("_", " ").title(), f"{v:.4f}" if isinstance(v, float) else str(v))
+
+            fig_dash = create_metrics_dashboard(metrics)
+            st.plotly_chart(fig_dash, use_container_width=True)
+
+            pipe = st.session_state.ml_pipeline
+            if pipe and pipe.is_fitted:
+                result_tabs = st.tabs(["📉 Confusion Matrix / Scatter", "📈 Feature Importance", "📋 Report"])
+
+                with result_tabs[0]:
+                    task_type = st.session_state.ml_results["task_type"]
+                    if task_type == "classification" and pipe.y_pred is not None:
+                        labels = [str(c) for c in pipe.classes_] if pipe.classes_ is not None else None
+                        fig_cm = create_confusion_matrix(
+                            list(pipe.y_test),  # type: ignore[arg-type]
+                            list(pipe.y_pred),  # type: ignore[arg-type]
+                            labels,
+                        )
+                        st.plotly_chart(fig_cm, use_container_width=True)
+                    elif task_type == "regression" and pipe.y_pred is not None:
+                        fig_avp = create_actual_vs_predicted(
+                            pipe.y_test, pipe.y_pred,
+                            f"{st.session_state.ml_results['model_name']} — Actual vs Predicted"
+                        )
+                        st.plotly_chart(fig_avp, use_container_width=True)
+
+                with result_tabs[1]:
+                    if hasattr(pipe, "get_feature_importance"):
+                        fi_df = pipe.get_feature_importance()
+                        if not fi_df.empty:
+                            fig_fi = create_feature_importance_chart(fi_df, top_n=20)
+                            st.plotly_chart(fig_fi, use_container_width=True)
+                            st.dataframe(fi_df.head(20), use_container_width=True)
+
+                with result_tabs[2]:
+                    if "classification_report" in metrics:
+                        st.code(metrics["classification_report"], language="text")
+                    else:
+                        for k, v in num_m.items():
+                            st.markdown(f"**{k.replace('_', ' ').title()}:** `{v:.4f}`")
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+#  TAB 3 · DEEP LEARNING
+# ──────────────────────────────────────────────────────────────────────────────
+with tab_dl:
+    st.markdown('<div class="sec-head">🧠 Deep Learning & Computer Vision</div>', unsafe_allow_html=True)
+
+    from models.dl_module import (
+        _classify_image_tf, _classify_image_torch,
+        detect_edges_opencv, detect_faces_opencv, apply_image_filters,
+    )
+
+    dl_uploaded = st.file_uploader("📷 Upload Image (JPG / PNG)", type=["jpg", "jpeg", "png"], key="dl_up")
+
+    if dl_uploaded is None:
+        st.markdown('<div class="info-box">👆 Upload any image — try animals, faces, objects, or landscapes.</div>', unsafe_allow_html=True)
+    else:
+        pil_img = Image.open(dl_uploaded)
+        c1, c2 = st.columns([2, 1])
+        with c1:
+            st.image(pil_img, caption="Uploaded Image", use_column_width=True)
+        with c2:
+            w, h = pil_img.size
+            arr_np = np.array(pil_img.convert("RGB"))
+            for lbl, val in [
+                ("Resolution", f"{w}×{h}"),
+                ("Mode",       pil_img.mode),
+                ("Brightness", f"{arr_np.mean():.1f}"),
+                ("File size",  f"{dl_uploaded.size / 1024:.1f} KB"),
+            ]:
+                st.markdown(
+                    f'<div class="stat-card" style="margin-bottom:6px">'
+                    f'<div class="stat-val" style="font-size:1rem">{val}</div>'
+                    f'<div class="stat-lbl">{lbl}</div></div>',
+                    unsafe_allow_html=True,
+                )
+
+        st.markdown("---")
+        dl_tabs = st.tabs(["🏷️ Classification", "🔥 Grad-CAM", "👁️ Detection", "🎨 Filters"])
+
+        with dl_tabs[0]:
+            st.subheader("Image Classification — ImageNet 1K")
+            backend = st.radio("Backend", ["TensorFlow/Keras", "PyTorch"], horizontal=True)
+            if backend == "TensorFlow/Keras":
+                model_choice = st.selectbox("Model", ["MobileNetV2", "ResNet50", "VGG16"])
+            else:
+                model_choice = st.selectbox("Model", ["MobileNetV2", "ResNet50"])
+
+            if st.button("🔍 Classify Image", type="primary", key="cls_btn"):
+                with st.spinner(f"Running {model_choice}…"):
+                    try:
+                        # Verify TF is importable before calling classify
+                        if backend == "TensorFlow/Keras":
+                            try:
+                                import tensorflow as _tf_check  # type: ignore[import-untyped]
+                            except ImportError:
+                                raise ImportError("TensorFlow not installed. Run: pip install tensorflow")
+                            results = _classify_image_tf(pil_img, model_choice)
+                        else:
+                            results = _classify_image_torch(pil_img, model_choice)
+
+                        import plotly.graph_objects as go
+                        st.markdown(
+                            f'<div class="success-box">🏆 <strong>{results[0]["Label"]}</strong> — {results[0]["Confidence"]}</div>',
+                            unsafe_allow_html=True,
+                        )
+                        st.dataframe(pd.DataFrame(results), use_container_width=True)
+
+                        labels_list = [r["Label"][:28] for r in results]
+                        scores_list = [r["Score"] for r in results]
+                        colors_list = ["#a78bfa" if i == 0 else "#334155" for i in range(len(scores_list))]
+                        fig = go.Figure(go.Bar(
+                            x=scores_list[::-1], y=labels_list[::-1], orientation="h",
+                            marker=dict(color=colors_list[::-1]),
+                            text=[f"{s * 100:.1f}%" for s in scores_list[::-1]],
+                            textposition="outside",
+                        ))
+                        fig.update_layout(title="Top-5 Confidence Scores", template="plotly_dark",
+                                          paper_bgcolor="rgba(0,0,0,0)", height=280)
+                        st.plotly_chart(fig, use_container_width=True)
+                    except Exception as e:
+                        st.error(f"Classification failed: {e}")
+                        st.info("Make sure TensorFlow or PyTorch is installed.")
+
+        with dl_tabs[1]:
+            st.subheader("Grad-CAM — Class Activation Heatmap")
+            st.markdown("Highlights **which image regions** the model focused on for its prediction.")
+
+            _tf_ok, _pt_ok = False, False
+            try:
+                import tensorflow; _tf_ok = True
+            except ImportError:
+                pass
+            try:
+                import torch; _pt_ok = True
+            except ImportError:
+                pass
+
+            if not _tf_ok and not _pt_ok:
+                st.markdown("""
+                <div class="info-box">
+                ⚠️ Grad-CAM requires TensorFlow or PyTorch.<br>
+                Install: <code>pip install tensorflow</code> or <code>pip install torch torchvision</code>
+                </div>""", unsafe_allow_html=True)
+            else:
+                backend_opts = (["TensorFlow/Keras"] if _tf_ok else []) + (["PyTorch"] if _pt_ok else [])
+                gc_backend = st.radio("Backend", backend_opts, horizontal=True, key="gc_back")
+                gc_model   = st.selectbox(
+                    "Model",
+                    ["MobileNetV2", "ResNet50"] if gc_backend == "PyTorch" else ["MobileNetV2", "ResNet50", "VGG16"],
+                    key="gc_m",
+                )
+
+                if st.button("🔥 Generate Grad-CAM", type="primary"):
+                    with st.spinner("Computing Grad-CAM…"):
+                        try:
+                            import cv2 as _cv
+                            import numpy as _np
+
+                            orig_224 = _np.array(pil_img.convert("RGB").resize((224, 224)))
+
+                            if gc_backend == "TensorFlow/Keras":
+                                # Robust TensorFlow import — handles tf2, tf-cpu, standalone keras
+                                try:
+                                    import tensorflow as tf  # type: ignore[import-untyped]
+                                except ImportError:
+                                    st.error("❌ TensorFlow not installed. Run: pip install tensorflow")
+                                    st.stop()
+                                try:
+                                    from tensorflow.keras.preprocessing.image import img_to_array  # type: ignore[import-untyped]
+                                except ImportError:
+                                    try:
+                                        from tensorflow.keras.utils import img_to_array  # type: ignore[import-untyped]
+                                    except ImportError:
+                                        from keras.utils import img_to_array  # type: ignore[import-untyped]
+                                try:
+                                    from models.dl_module import _load_tf_model
+                                except ImportError:
+                                    from dl_module import _load_tf_model  # type: ignore[import]
+
+                                model, preprocess, decode, (ih, iw) = _load_tf_model(gc_model)
+                                arr = preprocess(_np.expand_dims(img_to_array(
+                                    pil_img.convert("RGB").resize((iw, ih))), 0))
+
+                                layer_name = None
+                                try:
+                                    _conv2d_cls = tf.keras.layers.Conv2D  # type: ignore[attr-defined]
+                                except AttributeError:
+                                    import keras
+                                    _conv2d_cls = keras.layers.Conv2D  # type: ignore[attr-defined]
+                                for layer in reversed(model.layers):
+                                    if isinstance(layer, _conv2d_cls):
+                                        layer_name = layer.name
+                                        break
+
+                                if not layer_name:
+                                    st.warning("No Conv2D layer found in model.")
+                                    st.stop()
+
+                                grad_model = tf.keras.models.Model(
+                                    inputs=model.inputs,
+                                    outputs=[model.get_layer(layer_name).output, model.output],
+                                )
+                                with tf.GradientTape() as tape:
+                                    conv_out, preds = grad_model(arr)
+                                    top_cls = int(tf.argmax(preds[0]).numpy())  # type: ignore[union-attr]
+                                    loss = preds[:, top_cls]  # type: ignore[index]
+                                grads   = tape.gradient(loss, conv_out)
+                                pooled  = tf.reduce_mean(grads, axis=(0, 1, 2))
+                                heatmap = conv_out[0] @ pooled[..., tf.newaxis]
+                                heatmap = tf.squeeze(heatmap).numpy()
+                                top_label = decode(model.predict(arr, verbose=0), top=1)[0][0][1].replace("_", " ").title()
+
+                            else:  # PyTorch
+                                import torch
+                                import torchvision.models as M
+                                import torchvision.transforms as T
+                                import json, urllib.request
+
+                                pt_map = {"MobileNetV2": M.mobilenet_v2, "ResNet50": M.resnet50}
+                                pt_model = pt_map.get(gc_model, M.mobilenet_v2)(weights="DEFAULT")
+                                pt_model.eval()
+
+                                last_conv = None
+                                for name, m in pt_model.named_modules():
+                                    if isinstance(m, torch.nn.Conv2d):
+                                        last_conv = (name, m)
+
+                                if last_conv is None:
+                                    st.warning("No Conv2d layer found.")
+                                    st.stop()
+
+                                activations, gradients = [], []
+
+                                def _fwd_hook(mod, inp, out):
+                                    activations.clear(); activations.append(out.detach())
+
+                                def _bwd_hook(mod, grad_in, grad_out):
+                                    gradients.clear(); gradients.append(grad_out[0].detach())
+
+                                h1 = last_conv[1].register_forward_hook(_fwd_hook)
+                                h2 = last_conv[1].register_full_backward_hook(_bwd_hook)
+
+                                _transform = T.Compose([
+                                    T.Resize(256), T.CenterCrop(224), T.ToTensor(),
+                                    T.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
+                                ])
+                                _tf_raw = _transform(pil_img.convert("RGB"))
+                                tf_img = _tf_raw.unsqueeze(0)  # torch Tensor — ignore PIL Image complaint  # type: ignore[union-attr]
+                                tf_img.requires_grad_(True)
+
+                                output = pt_model(tf_img)
+                                top_cls_pt = output.argmax(dim=1).item()
+                                pt_model.zero_grad()
+                                output[0, top_cls_pt].backward()
+                                h1.remove(); h2.remove()
+
+                                act     = activations[0].squeeze()
+                                grad    = gradients[0].squeeze()
+                                weights = grad.mean(dim=(1, 2))
+                                heatmap = (weights[:, None, None] * act).sum(dim=0).numpy()
+                                heatmap = _np.maximum(heatmap, 0)
+
+                                try:
+                                    url = "https://raw.githubusercontent.com/anishathalye/imagenet-simple-labels/master/imagenet-simple-labels.json"
+                                    with urllib.request.urlopen(url, timeout=5) as r:
+                                        class_labels = json.load(r)
+                                    top_label = class_labels[top_cls_pt].replace("_", " ").title()
+                                except Exception:
+                                    top_label = f"Class {top_cls_pt}"
+
+                            # ── Render heatmap ──
+                            heatmap = heatmap / (heatmap.max() + 1e-8)
+                            h_res   = _cv.resize(heatmap, (224, 224))
+                            _h_uint8 = _np.array(255 * h_res, dtype=_np.uint8)
+                            h_col   = _cv.cvtColor(
+                                _cv.applyColorMap(_h_uint8, _cv.COLORMAP_JET),  # type: ignore[call-overload]
+                                _cv.COLOR_BGR2RGB,
+                            )
+                            overlay = _np.array(orig_224 * 0.6 + h_col * 0.4, dtype=_np.uint8)
+
+                            gc1, gc2, gc3 = st.columns(3)
+                            gc1.image(orig_224, caption="Original",  use_column_width=True)
+                            gc2.image(h_col,    caption="Heatmap",   use_column_width=True)
+                            gc3.image(overlay,  caption="Overlay",   use_column_width=True)
+                            st.markdown(
+                                f'<div class="success-box">🏆 Top prediction: <strong>{top_label}</strong> '
+                                f'— red/yellow regions = highest model attention</div>',
+                                unsafe_allow_html=True,
+                            )
+
+                        except Exception as e:
+                            st.error(f"Grad-CAM failed: {e}")
+
+        with dl_tabs[2]:
+            st.subheader("OpenCV Detection")
+            cv_task = st.selectbox("Task", ["Face Detection", "Edge Detection"])
+            t1 = t2 = None
+            if cv_task == "Edge Detection":
+                t1 = st.slider("Threshold 1", 10, 200, 50)
+                t2 = st.slider("Threshold 2", 50, 400, 150)
+
+            if st.button("▶ Run Detection", type="primary", key="det_btn"):
+                with st.spinner("Running OpenCV…"):
+                    if cv_task == "Edge Detection":
+                        import cv2 as _cv
+                        _t1: float = float(t1) if t1 is not None else 50.0
+                        _t2: float = float(t2) if t2 is not None else 150.0
+                        gray  = _cv.cvtColor(np.array(pil_img.convert("RGB")), _cv.COLOR_RGB2GRAY)
+                        edges = _cv.Canny(_cv.GaussianBlur(gray, (5, 5), 0), _t1, _t2)
+                        dc1, dc2 = st.columns(2)
+                        dc1.image(pil_img, caption="Original",       use_column_width=True)
+                        dc2.image(edges,   caption="Edges",           use_column_width=True, clamp=True)
+                        st.info(f"Edge pixels: **{np.sum(edges > 0):,}**")
+                    else:
+                        result_img, face_count = detect_faces_opencv(pil_img)
+                        dc1, dc2 = st.columns(2)
+                        dc1.image(pil_img,    caption="Original",    use_column_width=True)
+                        dc2.image(result_img, caption="Detections",  use_column_width=True)
+                        if face_count > 0:
+                            st.markdown(f'<div class="success-box">✅ Detected <strong>{face_count}</strong> face(s).</div>', unsafe_allow_html=True)
+                        else:
+                            st.warning("No faces detected. Try a clear frontal portrait.")
+
+        with dl_tabs[3]:
+            st.subheader("Image Filters Gallery")
+            if st.button("🎨 Apply All Filters", type="primary", key="flt_btn"):
+                with st.spinner("Applying filters…"):
+                    filters  = apply_image_filters(pil_img)
+                    cols_f   = st.columns(3)
+                    for i, (name, img) in enumerate(filters.items()):
+                        with cols_f[i % 3]:
+                            st.image(img, caption=name, use_column_width=True, clamp=True)
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+#  TAB 4 · NLP
+# ──────────────────────────────────────────────────────────────────────────────
+with tab_nlp:
+    st.markdown('<div class="sec-head">📝 NLP Suite</div>', unsafe_allow_html=True)
+
+    try:
+        from models.nlp_module import (  # type: ignore[import]
+            run_sentiment, run_ner, run_text_classification,
+            run_summarization, chat_with_model,
+        )
+    except ImportError:
+        from nlp_module import (  # type: ignore[import]
+            run_sentiment, run_ner, run_text_classification,
+            run_summarization, chat_with_model,
+        )
+
+    nlp_tabs = st.tabs(["😊 Sentiment", "🏷️ NER", "📂 Classification", "📰 Summarization", "💬 Chatbot"])
+
+    # ── Sentiment ──
+    with nlp_tabs[0]:
+        st.subheader("Sentiment Analysis — DistilBERT")
+        mode = st.radio("Mode", ["Single", "Batch"], horizontal=True)
+        if mode == "Single":
+            txt = st.text_area("Text to analyze:", height=110,
+                               placeholder="The product quality is amazing and delivery was super fast!")
+            if st.button("🔍 Analyze", type="primary", key="sa_btn"):
+                if not txt.strip():
+                    st.warning("Enter some text.")
+                else:
+                    with st.spinner("Loading DistilBERT and analyzing…"):
+                        r = run_sentiment([txt])
+                    if r:
+                        color = "#22c55e" if r[0]["Sentiment"] == "POSITIVE" else "#ef4444"
+                        icon  = "😊" if r[0]["Sentiment"] == "POSITIVE" else "😞"
+                        st.markdown(f"""
+                        <div class="result-box" style="border-left:5px solid {color}">
+                            <div style="font-size:2rem">{icon}</div>
+                            <div style="font-size:1.4rem;font-weight:700;color:{color}">{r[0]["Sentiment"]}</div>
+                            <div style="color:#94a3b8;margin-top:6px">Confidence: <strong style="color:#e2e8f0">{r[0]["Confidence"]}</strong></div>
+                        </div>""", unsafe_allow_html=True)
+        else:
+            batch = st.text_area("One sentence per line:", height=180,
+                                 placeholder="Great product!\nTerrible experience.\nIt was okay.")
+            if st.button("🔍 Analyze All", type="primary", key="sa_batch"):
+                lines = [ln.strip() for ln in batch.split("\n") if ln.strip()]
+                if lines:
+                    with st.spinner("Analyzing…"):
+                        results = run_sentiment(lines)
+                    df_s = pd.DataFrame(results)
+                    st.dataframe(df_s, use_container_width=True)
+                    import plotly.express as px
+                    pos = sum(1 for r in results if r["Sentiment"] == "POSITIVE")
+                    fig = px.pie(
+                        values=[pos, len(results) - pos],
+                        names=["Positive", "Negative"],
+                        color_discrete_sequence=["#22c55e", "#ef4444"],
+                        hole=0.4, template="plotly_dark",
+                    )
+                    fig.update_layout(paper_bgcolor="rgba(0,0,0,0)")
+                    st.plotly_chart(fig, use_container_width=True)
+
+    # ── NER ──
+    with nlp_tabs[1]:
+        st.subheader("Named Entity Recognition")
+        ner_txt = st.text_area("Text for NER:", height=130,
+            value="Apple Inc. was founded by Steve Jobs in Cupertino, California in 1976.")
+        if st.button("🏷️ Extract Entities", type="primary", key="ner_btn"):
+            with st.spinner("Running NER…"):
+                ents = run_ner(ner_txt)
+            if ents:
+                df_ner = pd.DataFrame(ents)
+                st.dataframe(df_ner, use_container_width=True)
+                import plotly.express as px
+                vc = df_ner["Type"].value_counts().reset_index()
+                vc.columns = ["Type", "count"]
+                fig = px.bar(vc, x="Type", y="count", template="plotly_dark",
+                             color="Type", color_discrete_sequence=["#a78bfa", "#60a5fa", "#34d399", "#f472b6"])
+                fig.update_layout(paper_bgcolor="rgba(0,0,0,0)", showlegend=False)
+                st.plotly_chart(fig, use_container_width=True)
+                type_icons = {"PER": "🧑", "ORG": "🏢", "LOC": "📍", "MISC": "🔖", "GPE": "🌍"}
+                for _, row in df_ner.iterrows():
+                    st.markdown(f"- **{row['Entity']}** → {type_icons.get(row['Type'], '')} `{row['Type']}` ({row['Score']})")
+            else:
+                st.info("No entities found.")
+
+    # ── Zero-Shot Classification ──
+    with nlp_tabs[2]:
+        st.subheader("Zero-Shot Text Classification")
+        cl_txt = st.text_area("Text to classify:", height=110,
+            value="The new iPhone features an upgraded camera and faster processor.")
+        cl_labels = st.text_input("Candidate labels (comma-separated):",
+            value="technology, sports, politics, business, health, entertainment")
+        if st.button("📂 Classify", type="primary", key="zs_btn"):
+            lbls = [lb.strip() for lb in cl_labels.split(",") if lb.strip()]
+            if cl_txt.strip() and lbls:
+                with st.spinner("Running zero-shot classification…"):
+                    results = run_text_classification(cl_txt, lbls)
+                st.markdown(
+                    f'<div class="success-box">🏆 Best: <strong>{results[0]["Label"]}</strong> ({results[0]["Confidence"]})</div>',
+                    unsafe_allow_html=True,
+                )
+                import plotly.express as px
+                df_zs = pd.DataFrame(results)
+                fig = px.bar(df_zs, x="Label", y="Score", template="plotly_dark",
+                             color="Score", color_continuous_scale="Purples")
+                fig.update_layout(paper_bgcolor="rgba(0,0,0,0)")
+                st.plotly_chart(fig, use_container_width=True)
+
+    # ── Summarization ──
+    with nlp_tabs[3]:
+        st.subheader("Text Summarization — DistilBART")
+        long_txt = st.text_area("Long text to summarize:", height=220,
+            value=(
+                "Artificial intelligence (AI) is intelligence demonstrated by machines, as opposed to "
+                "the natural intelligence displayed by animals including humans. AI research has been defined "
+                "as the field of study of intelligent agents, which refers to any system that perceives its "
+                "environment and takes actions that maximize its chance of achieving its goals. AI applications "
+                "include advanced web search engines, recommendation systems, understanding human speech, "
+                "self-driving cars, generative or creative tools, automated decision-making, and competing "
+                "at the highest level in strategic game systems."
+            ))
+        if st.button("📰 Summarize", type="primary", key="sum_btn"):
+            if len(long_txt.split()) < 30:
+                st.warning("Need at least 30 words.")
+            else:
+                with st.spinner("Loading DistilBART and summarizing…"):
+                    summary = run_summarization(long_txt)
+                st.markdown(f'<div class="result-box">{summary}</div>', unsafe_allow_html=True)
+                sc1, sc2 = st.columns(2)
+                sc1.metric("Original Words", len(long_txt.split()))
+                sc2.metric("Summary Words",  len(summary.split()))
+
+    # ── Chatbot ──
+    with nlp_tabs[4]:
+        st.subheader("💬 AI Chatbot")
+        if "chat_pairs" not in st.session_state:
+            st.session_state.chat_pairs = []
+
+        with st.expander("⚙️ Settings"):
+            sys_hint = st.text_input("System hint:", value="You are a helpful AI assistant. Be concise.")
+            if st.button("🗑️ Clear Chat"):
+                st.session_state.chat_pairs = []
+                st.rerun()
+
+        for um, bm in st.session_state.chat_pairs:
+            with st.chat_message("user"):
+                st.markdown(um)
+            with st.chat_message("assistant"):
+                st.markdown(bm)
+
+        user_input = st.chat_input("Ask anything…")
+        if user_input:
+            with st.chat_message("user"):
+                st.markdown(user_input)
+            with st.chat_message("assistant"):
+                with st.spinner("Thinking…"):
+                    try:
+                        prompt = f"{sys_hint}\n\n{user_input}" if sys_hint else user_input
+                        resp   = chat_with_model(prompt, st.session_state.chat_pairs)
+                    except Exception as e:
+                        resp = f"⚠️ {e}"
+                st.markdown(resp)
+            st.session_state.chat_pairs.append((user_input, resp))
+
+        if not st.session_state.chat_pairs:
+            examples = [
+                "What is machine learning?", "Explain neural networks simply.",
+                "Top 3 AI programming languages?", "Benefits of deep learning?",
+            ]
+            ecols = st.columns(2)
+            for i, ex in enumerate(examples):
+                with ecols[i % 2]:
+                    if st.button(ex, key=f"ex_{i}", use_container_width=True):
+                        with st.spinner("Thinking…"):
+                            try:
+                                resp = chat_with_model(ex, [])
+                            except Exception as e:
+                                resp = f"⚠️ {e}"
+                        st.session_state.chat_pairs.append((ex, resp))
+                        st.rerun()
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+#  TAB 5 · GENERATIVE AI
+# ──────────────────────────────────────────────────────────────────────────────
+with tab_genai:
+    st.markdown('<div class="sec-head">💡 Generative AI Suite</div>', unsafe_allow_html=True)
+    gen_ai = st.session_state.gen_ai
+
+    # ── Status banner ──
+    if gen_ai._provider == "smart":
+        st.markdown("""
+        <div class="success-box">
+        ⚡ <strong>Smart AI active</strong> — instant built-in responses, zero downloads, no API key needed.<br>
+        Knows: ML algorithms, deep learning, NLP, Python, data science, and more.
+        For open-ended GPT-4 quality responses, add an API key in the sidebar.
+        </div>""", unsafe_allow_html=True)
+    elif gen_ai.is_available():
+        st.markdown(f'<div class="success-box">✅ <strong>{gen_ai._provider_config["name"]}</strong> connected and ready.</div>', unsafe_allow_html=True)
+    elif not gen_ai.pkg_installed():
+        st.markdown(f"""
+        <div class="info-box">
+        ⚠️ <strong>{gen_ai._provider_config["name"]}</strong> package not installed.<br>
+        Run: <code>{gen_ai.install_cmd()}</code> — then restart Streamlit.
+        </div>""", unsafe_allow_html=True)
+    else:
+        pkg_status = {
+            "🟢 OpenAI":    "✅ installed" if OPENAI_OK    else "❌  pip install openai",
+            "🔵 Google":    "✅ installed" if GOOGLE_OK    else "❌  pip install google-generativeai",
+            "🟣 Anthropic": "✅ installed" if ANTHROPIC_OK else "❌  pip install anthropic",
+        }
+        rows = "<br>".join(f"&nbsp;&nbsp;{k}: <code>{v}</code>" for k, v in pkg_status.items())
+        st.markdown(f"""
+        <div class="info-box">
+        ⚠️ No API key entered — using Smart AI mode.<br>
+        To enable full LLM responses, install a package and add your key:<br><br>{rows}
+        </div>""", unsafe_allow_html=True)
+
+    gen_tabs = st.tabs(["💬 Chatbot", "❓ Data Q&A", "💻 Code Gen", "🎨 Image Gen", "📄 Report"])
+
+    # ── Chatbot ──
+    with gen_tabs[0]:
+        st.subheader("Context-Aware Chatbot")
+        if "gen_chat" not in st.session_state:
+            st.session_state.gen_chat    = []
+            st.session_state.gen_history = []
+
+        for role, msg in st.session_state.gen_chat:
+            with st.chat_message(role):
+                st.markdown(msg)
+
+        user_q = st.chat_input("Chat with AI…", key="gen_chat_input")
+        if user_q:
+            st.session_state.gen_chat.append(("user", user_q))
+            st.session_state.gen_history.append({"role": "user", "content": user_q})
+            with st.chat_message("user"):
+                st.markdown(user_q)
+            with st.chat_message("assistant"):
+                with st.spinner("Generating…"):
+                    try:
+                        resp = gen_ai.chat(st.session_state.gen_history)
+                    except Exception as e:
+                        resp = f"⚠️ {e}"
+                st.markdown(resp)
+            st.session_state.gen_chat.append(("assistant", resp))
+            st.session_state.gen_history.append({"role": "assistant", "content": resp})
+
+        if st.button("🗑️ Clear Conversation", key="clr_gen"):
+            st.session_state.gen_chat    = []
+            st.session_state.gen_history = []
+            st.rerun()
+
+    # ── Data Q&A ──
+    with gen_tabs[1]:
+        st.subheader("Prompt-Based Data Q&A")
+        st.markdown("Ask questions about your loaded dataset and get AI-generated insights.")
+        gen_option = st.selectbox("Analysis Type", [
+            "General Insights", "Trends Analysis", "Anomaly Detection", "Recommendations", "Custom Question",
+        ])
+        analysis_map = {
+            "General Insights":  "general",
+            "Trends Analysis":   "trends_analysis",
+            "Anomaly Detection": "anomaly_detection",
+            "Recommendations":   "recommendations",
+        }
+        if gen_option != "Custom Question":
+            if st.button("✨ Generate Insights", type="primary", key="gen_ins"):
+                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(f'<div class="result-box">{insights}</div>', unsafe_allow_html=True)
+                else:
+                    st.warning("Load data in the 📊 Data tab first.")
+        else:
+            question = st.text_input("Your question:", placeholder="What features are most correlated with the target?")
+            if st.button("🔍 Ask", type="primary", key="gen_qa") and question:
+                ctx = 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, ctx)
+                st.markdown(f'<div class="result-box">{answer}</div>', unsafe_allow_html=True)
+
+    # ── Code Generation ──
+    with gen_tabs[2]:
+        st.subheader("💻 Code Generation")
+        code_lang   = st.selectbox("Language", ["Python", "JavaScript", "SQL", "Bash", "R", "TypeScript"])
+        code_prompt = st.text_area(
+            "Describe what you want to code:", height=110,
+            placeholder="Write a Python function to clean a pandas dataframe by removing duplicates and filling nulls with median values.",
+        )
+        if st.button("⚡ Generate Code", type="primary", key="code_gen"):
+            if code_prompt.strip():
+                with st.spinner("Generating code…"):
+                    code_result = gen_ai.generate_code(code_prompt, language=code_lang)
+                st.code(code_result, language=code_lang.lower())
+                st.download_button(
+                    "⬇️ Download", code_result.encode(),
+                    file_name=f"generated.{code_lang.lower()[:2]}",
+                    mime="text/plain",
+                )
+            else:
+                st.warning("Enter a code description.")
+
+    # ── Image Generation ──
+    with gen_tabs[3]:
+        st.subheader("🎨 Image Generation from Text")
+        img_prompt = st.text_area(
+            "Image description:", height=100,
+            placeholder="A futuristic city at night with neon lights and flying cars, digital art style",
+        )
+        img_style = st.selectbox("Style", ["Photorealistic", "Digital Art", "Oil Painting", "Anime", "Sketch", "Cyberpunk"])
+        img_size  = st.selectbox("Size", ["1024x1024", "512x512", "1792x1024"])
+
+        if st.button("🎨 Generate Image", type="primary", key="img_gen"):
+            if img_prompt.strip():
+                full_prompt = f"{img_prompt}, {img_style} style"
+                with st.spinner("Generating image…"):
+                    result = gen_ai.generate_image(full_prompt, size=img_size)
+                if result.get("url"):
+                    st.image(result["url"], caption=f"Generated: {img_prompt[:60]}…", use_column_width=True)
+                    st.markdown(f"[🔗 Open full size]({result['url']})")
+                elif result.get("error"):
+                    st.markdown(f'<div class="info-box">⚠️ {result["error"]}</div>', unsafe_allow_html=True)
+            else:
+                st.warning("Enter an image description.")
+
+    # ── Report ──
+    with gen_tabs[4]:
+        st.subheader("📄 Auto-Generated Analysis Report")
+        if st.button("📝 Generate Report", type="primary", key="gen_rep"):
+            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.text_area("Report", report, height=420)
+            st.download_button("⬇️ Download Report", report.encode(), file_name="ai_report.txt", mime="text/plain")
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+#  TAB 6 · POWER BI
+# ──────────────────────────────────────────────────────────────────────────────
+with tab_pbi:
+    st.markdown('<div class="sec-head">📤 Power BI Export</div>', unsafe_allow_html=True)
+    exporter = st.session_state.powerbi_exp
+
+    if st.session_state.df is None:
+        st.markdown('<div class="info-box">👆 Load data in the <strong>📊 Data</strong> tab first.</div>', unsafe_allow_html=True)
+    else:
+        df = st.session_state.df
+        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", use_container_width=True):
+            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"❌ {e}")
+
+        st.divider()
+        st.info(exporter.generate_powerbi_instructions())
+
+        dl1, dl2 = st.columns(2)
+        with dl1:
+            st.download_button("⬇️ Download CSV", df.to_csv(index=False).encode(),
+                               file_name=f"{export_name}.csv", mime="text/csv", use_container_width=True)
+        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("⬇️ Feature Importance CSV", fi_df.to_csv(index=False).encode(),
+                                   file_name="feature_importance.csv", mime="text/csv", use_container_width=True)
+
+
+# ── Footer ────────────────────────────────────────────────────────────────────
+st.markdown("""
+<div class="footer">
+    Multi-AI Analytics Platform v2.1 &nbsp;·&nbsp; Clean Edition &nbsp;·&nbsp;
+    ML · DL · NLP · GenAI · PowerBI &nbsp;&nbsp;
+    <span>| KYOTO-Z |</span>
+</div>
+""", unsafe_allow_html=True)

config.py

@@ -0,0 +1,53 @@
+# import os
+# from pathlib import Path
+
+# BASE_DIR = Path(__file__).parent
+# OUTPUT_DIR = BASE_DIR / "output"
+# OUTPUT_DIR.mkdir(exist_ok=True)
+
+# class Config:
+#     OPENAI_API_KEY = os.getenv("OPENAI_API_KEY", "")
+#     GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY", "")
+#     MODEL_CACHE_DIR = BASE_DIR / "model_cache"
+#     MAX_IMAGE_SIZE = (1024, 1024)
+#     BATCH_SIZE = 16
+#     DEFAULT_LLM_MODEL = "gemini-pro"
+#     DEFAULT_VISION_MODEL = "facebook/deit-base-patch16-224"
+#     DEFAULT_NLP_MODEL = "distilbert-base-uncased"
+
+
+import os
+from pathlib import Path
+
+BASE_DIR = Path(__file__).parent
+OUTPUT_DIR = BASE_DIR / "output"
+OUTPUT_DIR.mkdir(exist_ok=True)
+
+MODEL_CACHE_DIR = BASE_DIR / "model_cache"
+MODEL_CACHE_DIR.mkdir(exist_ok=True)
+
+class Config:
+    # API Keys
+    OPENAI_API_KEY = os.getenv("OPENAI_API_KEY", "")
+    GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY", "")
+    ANTHROPIC_API_KEY = os.getenv("ANTHROPIC_API_KEY", "")
+
+    # Paths
+    BASE_DIR = BASE_DIR
+    OUTPUT_DIR = OUTPUT_DIR
+    MODEL_CACHE_DIR = MODEL_CACHE_DIR
+
+    # Image settings
+    MAX_IMAGE_SIZE = (1024, 1024)
+    BATCH_SIZE = 16
+
+    # Model defaults
+    DEFAULT_LLM_MODEL = "gpt-4"
+    DEFAULT_VISION_MODEL = "resnet50"
+    DEFAULT_NLP_MODEL = "distilbert-base-uncased"
+
+    # ML defaults
+    N_ESTIMATORS = 150
+    MAX_DEPTH = 6
+    RANDOM_STATE = 42
+    CV_FOLDS = 5

requirements.txt

@@ -0,0 +1,46 @@
+# ══════════════════════════════════════════════
+#  Multi-AI Analytics Platform v2.0
+#  Merged Requirements
+# ══════════════════════════════════════════════
+
+# ── Core ──────────────────────────────────────
+streamlit>=1.32.0
+pandas>=2.0.0
+numpy>=1.24.0
+pillow>=10.0.0
+python-dotenv>=1.0.0
+requests>=2.31.0
+
+# ── Machine Learning ──────────────────────────
+scikit-learn>=1.4.0
+xgboost>=2.0.0
+lightgbm>=4.0.0
+
+# ── Deep Learning (choose one or both) ───────
+torch>=2.1.0
+torchvision>=0.16.0
+tensorflow>=2.13.0          # Optional — comment out if using PyTorch only
+
+# ── NLP / HuggingFace ─────────────────────────
+transformers>=4.38.0
+sentencepiece>=0.1.99       # Required by some HuggingFace tokenizers
+
+# ── Computer Vision ───────────────────────────
+opencv-python-headless>=4.8.0
+
+# ── Visualization ─────────────────────────────
+plotly>=5.18.0
+matplotlib>=3.7.0
+seaborn>=0.12.0
+
+# ── Generative AI Providers ───────────────────
+openai>=1.12.0              # For GPT-4o + DALL-E 3 image generation
+google-generativeai>=0.4.0  # For Gemini
+anthropic>=0.20.0           # For Claude
+
+# ── Export ────────────────────────────────────
+pyarrow>=14.0.0             # For Parquet export (Power BI)
+
+# ── Optional ──────────────────────────────────
+# accelerate>=0.24.0        # Faster HuggingFace inference
+# kaleido>=0.2.1            # Save Plotly charts as images