Update app.py

app.py

@@ -2133,71 +2133,433 @@ def extract_agentic_insights_v5(df: pd.DataFrame):
 # ===== MAIN APP ===========
 # ==========================
 
-st.markdown("<h3 class='section-title'>OBJECTIVE 7 — Insight and Recommendation (LLM powered)</h3>", unsafe_allow_html=True)
+# app.py
+import streamlit as st
+import pandas as pd
+import json
+from typing import List, Dict
 
-dev = extract_agentic_insights_v5(df_filtered)
+# Transformers pipeline for lightweight local LLM (text2text)
+from transformers import pipeline
+import math
 
-# Build INSIGHT SUMMARY as text for LLM
-summary_parts = []
+st.set_page_config(layout="wide", page_title="Objective 7 — Insight & Recommendation (LLM)")
 
-if dev["lowest_ratio_9_locs"]:
-    summary_parts.append(f"Lowest-ratio locations: {dev['lowest_ratio_9_locs']}")
+# --------------------
+# Utility: load small local model (flan-t5-small)
+# --------------------
+@st.cache_resource
+def load_local_model(model_name="google/flan-t5-small"):
+    # text2text pipeline works well for instruction-style prompts
+    return pipeline("text2text-generation", model=model_name, device_map="auto" if hasattr(__import__('torch'),'cuda') else None)
 
-if dev["obj3a_lowest_div"]:
-    summary_parts.append(f"Lowest performing division: {dev['obj3a_lowest_div']}")
+# Try to load model once
+try:
+    llm_pipe = load_local_model()
+    local_llm_available = True
+except Exception as e:
+    llm_pipe = None
+    local_llm_available = False
+    st.warning("Local LLM not available or failed to load (will fallback to rule-based recommendations).")
 
-if dev["obj3b_slowest_executor"]:
-    summary_parts.append(f"Slowest executor: {dev['obj3b_slowest_executor']}")
+# --------------------
+# Insert your extract_agentic_insights_v5 function (kept faithful to your original)
+# --------------------
+def extract_agentic_insights_v5(df: pd.DataFrame):
+    dev = {
+        "lowest_ratio_9_locs": [],
+        "obj3a_lowest_div": None,
+        "obj3b_slowest_executor": None,
+        "obj3c_lowest_reporter": None,
+        "obj3d_slowest_div": None,
+        "obj4_unsafe_condition_pct": 0.0,
+        "obj4_unsafe_action_pct": 0.0,
+        "obj4_near_miss_pct": 0.0,
+        "obj5_q1_divs": [],
+        "obj5_q2_divs": [],
+        "obj6_top2_categories": [],
+    }
 
-if dev["obj3c_lowest_reporter"]:
-    summary_parts.append(f"Least active reporter: {dev['obj3c_lowest_reporter']}")
+    # === 1. 9 locations with lowest finding-to-reporter ratio ===
+    if {'nama_lokasi_full', 'creator_nid', 'created_at', 'kode_temuan'}.issubset(df.columns):
+        calc = df[['nama_lokasi_full', 'creator_nid', 'created_at', 'kode_temuan']].copy()
+        calc['created_at'] = pd.to_datetime(calc['created_at'], errors='coerce')
+        calc = calc.dropna(subset=['created_at', 'nama_lokasi_full', 'creator_nid'])
+        calc['bulan'] = calc['created_at'].dt.to_period('M')
+        monthly = calc.groupby(['nama_lokasi_full', 'bulan']).agg(
+            findings=('kode_temuan', 'size'),
+            reporters=('creator_nid', 'nunique')
+        ).reset_index()
+        monthly = monthly[monthly['reporters'] > 0]
+        monthly['ratio'] = monthly['findings'] / monthly['reporters']
+        loc_avg = monthly.groupby('nama_lokasi_full')['ratio'].mean()
+        lowest_9 = loc_avg.nsmallest(9)
+        dev["lowest_ratio_9_locs"] = [(loc, round(ratio, 3)) for loc, ratio in lowest_9.items()]
+
+    # === 2a: Division — lowest finding-to-reporter ratio (Obj 3a) ===
+    if {'nama', 'creator_nid', 'created_at', 'kode_temuan'}.issubset(df.columns):
+        calc = df[['nama', 'creator_nid', 'created_at', 'kode_temuan']].copy()
+        calc['bulan'] = pd.to_datetime(calc['created_at']).dt.to_period('M')
+        agg = calc.groupby(['nama', 'bulan']).agg(
+            findings=('kode_temuan', 'size'),
+            reporters=('creator_nid', 'nunique')
+        )
+        agg = agg[agg['reporters'] > 0].reset_index()
+        agg['ratio'] = agg['findings'] / agg['reporters']
+        div_ratio = agg.groupby('nama')['ratio'].mean()
+        if not div_ratio.empty:
+            name = div_ratio.idxmin()
+            val = round(div_ratio.min(), 2)
+            dev["obj3a_lowest_div"] = (name, val)
+
+    # === 2b: Executor — longest average resolution time (Obj 3b) ===
+    if 'days_to_close' in df.columns:
+        valid = df[df['days_to_close'].notna() & (df['days_to_close'] >= 0)]
+        exec_col = 'nama_pic' if 'nama_pic' in valid.columns else 'creator_name'
+        if exec_col in valid.columns:
+            lead = valid.groupby(exec_col)['days_to_close'].mean()
+            if not lead.empty:
+                name = lead.idxmax()
+                val = round(lead.max(), 1)
+                dev["obj3b_slowest_executor"] = (name, val)
+
+    # === 2c: Reporter — lowest reporting frequency (Obj 3c) ===
+    if {'creator_name', 'created_at'}.issubset(df.columns):
+        calc = df[['creator_name', 'created_at']].copy()
+        calc['bulan'] = pd.to_datetime(calc['created_at']).dt.to_period('M')
+        monthly = calc.groupby(['creator_name', 'bulan']).size().reset_index(name='count')
+        avg = monthly.groupby('creator_name')['count'].mean()
+        avg = avg[avg > 0]
+        if not avg.empty:
+            name = avg.idxmin()
+            val = round(avg.min(), 2)
+            dev["obj3c_lowest_reporter"] = (name, val)
 
+    # === 2d: Division — longest average resolution time (Obj 3d) ===
+    if 'days_to_close' in df.columns and 'nama' in df.columns:
+        valid = df[df['days_to_close'].notna() & (df['days_to_close'] >= 0)]
+        if not valid.empty:
+            lead = valid.groupby('nama')['days_to_close'].mean()
+            if not lead.empty:
+                name = lead.idxmax()
+                val = round(lead.max(), 1)
+                dev["obj3d_slowest_div"] = (name, val)
+
+    # === 3. Composition of non-Positive findings ===
+    if 'temuan_kategori' in df.columns:
+        cnt = df['temuan_kategori'].value_counts(normalize=True) * 100
+        dev["obj4_unsafe_condition_pct"] = round(cnt.get("Unsafe Condition", 0), 1)
+        dev["obj4_unsafe_action_pct"] = round(cnt.get("Unsafe Action", 0), 1)
+        dev["obj4_near_miss_pct"] = round(cnt.get("Near Miss", 0), 1)
+
+    # === 4. Risk Quadrants (X=20 findings/month, Y=3 days avg lead time) ===
+    X_LIMIT, Y_LIMIT = 20, 3
+    if {'nama', 'created_at', 'days_to_close', 'kode_temuan'}.issubset(df.columns):
+        calc = df.copy()
+        calc['created_at'] = pd.to_datetime(calc['created_at'], errors='coerce')
+        calc = calc.assign(month=calc['created_at'].dt.to_period('M').astype(str))
+        monthly_counts = calc.groupby(['nama', 'month'])['kode_temuan'].nunique().reset_index()
+        avg_count = monthly_counts.groupby('nama')['kode_temuan'].mean().reset_index(name='Finding Count')
+        leadtime = calc.groupby('nama')['days_to_close'].mean().reset_index(name='Avg Lead Time')
+        mat = avg_count.merge(leadtime, on='nama', how='left').fillna(0)
+        for _, r in mat.iterrows():
+            if r['Finding Count'] >= X_LIMIT and r['Avg Lead Time'] >= Y_LIMIT:
+                dev["obj5_q1_divs"].append(r['nama'])
+            elif r['Finding Count'] < X_LIMIT and r['Avg Lead Time'] >= Y_LIMIT:
+                dev["obj5_q2_divs"].append(r['nama'])
+
+    # === 5. Top 2 non-Positive categories (avg per month) ===
+    if {'kategori', 'temuan_kategori', 'created_at'}.issubset(df.columns):
+        nonpos = df[df['temuan_kategori'] != 'Positive']
+        if not nonpos.empty:
+            start = nonpos['created_at'].min().to_period('M')
+            end = nonpos['created_at'].max().to_period('M')
+            n_months = len(pd.period_range(start=start, end=end, freq='M'))
+            if n_months == 0:
+                n_months = 1
+            cat_avg = (nonpos.groupby('kategori').size() / n_months).sort_values(ascending=False).head(2)
+            dev["obj6_top2_categories"] = [(cat, round(val, 1)) for cat, val in cat_avg.items()]
+
+    return dev
+
+# --------------------
+# Sample fallback data (if user didn't provide)
+# --------------------
+def sample_dataframe():
+    sample = {
+        "nama_lokasi_full": ["Loc A","Loc B","Loc C","Loc D","Loc E","Loc F","Loc G","Loc H","Loc I","Loc J"],
+        "creator_nid": [1,2,3,4,5,6,7,8,9,10],
+        "created_at": pd.date_range(end=pd.Timestamp("now"), periods=10).astype(str),
+        "kode_temuan": list(range(10)),
+        "nama": ["Div1","Div1","Div2","Div2","Div3","Div3","Div4","Div4","Div5","Div5"],
+        "days_to_close": [2,5,10,1,20,3,4,6,2,8],
+        "creator_name": ["A","B","C","D","E","F","G","H","I","J"],
+        "temuan_kategori": ["Unsafe Condition","Positive","Unsafe Action","Near Miss","Positive","Unsafe Condition","Unsafe Action","Positive","Near Miss","Unsafe Condition"],
+        "kategori": ["Electrical","Mechanical","Electrical","Civil","Mechanical","Electrical","Civil","Mechanical","Civil","Electrical"]
+    }
+    return pd.DataFrame(sample)
+
+# --------------------
+# LLM prompt & call (local using flan T5 small via pipeline)
+# --------------------
+def generate_recs_with_local_llm(insight_text: str, dev: dict, n_items: int = 5) -> List[Dict]:
+    """
+    Return list of objects: [{"point":"1","rec":"...","mit":"..."} ...]
+    Uses local text2text pipeline.
+    """
+    if not local_llm_available or llm_pipe is None:
+        return None
+
+    # Build very clear prompt asking for JSON list
+    prompt = (
+        "You are an expert Safety Analytics advisor for a power utility. "
+        "Based on the structured analytics below, produce EXACTLY "
+        f"{n_items} items. For each item return a JSON object with keys: point, rec, mit. "
+        "rec = Recommended Action (concise, 1-2 sentences). "
+        "mit = Risk Mitigation Strategy (concise, 1-2 sentences). "
+        "Return only a JSON array (no extra text).\n\n"
+        "Structured analytics (python dict):\n"
+        f"{json.dumps(dev, ensure_ascii=False, indent=2)}\n\n"
+        "Insight summary (short):\n"
+        f"{insight_text}\n\n"
+        "Output example:\n"
+        '[{"point":"1","rec":"...","mit":"..."}, ..., {"point":"5","rec":"...","mit":"..."}]\n'
+    )
+
+    # use pipeline to generate
+    try:
+        gen = llm_pipe(prompt, max_new_tokens=400, do_sample=False)[0]["generated_text"]
+    except Exception as e:
+        st.error(f"Local LLM generation failed: {e}")
+        return None
+
+    # try parse JSON array inside output text
+    try:
+        start = gen.index('[')
+        end = gen.rindex(']') + 1
+        arr_text = gen[start:end]
+        obj = json.loads(arr_text)
+        # Normalize: ensure point fields exist; if not, assign numbers
+        for idx, item in enumerate(obj):
+            if 'point' not in item:
+                item['point'] = str(idx+1)
+        return obj
+    except Exception:
+        # fallback: try to parse lines heuristically
+        lines = [ln.strip() for ln in gen.splitlines() if ln.strip()]
+        items = []
+        num = 1
+        for ln in lines:
+            if len(items) >= n_items:
+                break
+            # naive split by '|' or '-' if present
+            if '|' in ln:
+                parts = [p.strip() for p in ln.split('|') if p.strip()]
+                if len(parts) >= 2:
+                    rec = parts[0]
+                    mit = parts[1] if len(parts) > 1 else ""
+                    items.append({"point": str(num), "rec": rec, "mit": mit})
+                    num += 1
+            else:
+                # fallback short capture
+                items.append({"point": str(num), "rec": ln[:200], "mit": ""})
+                num += 1
+        if items:
+            return items
+    return None
+
+# --------------------
+# Rule-based fallback generator (if LLM unavailable)
+# --------------------
+def rule_based_recs(dev: dict) -> List[Dict]:
+    recs = []
+    if dev["lowest_ratio_9_locs"]:
+        recs.append({
+            "point": "1",
+            "rec": "Launch Agency Activation Sprint across the identified low-ratio locations: weekly micro-inspection by Area PIC.",
+            "mit": "Enable QR-based checklists with automatic reminders; monitor ratio weekly and target improvement within 45 days."
+        })
+    parts_exist = any([dev["obj3a_lowest_div"], dev["obj3c_lowest_reporter"], dev["obj3d_slowest_div"], dev["obj3b_slowest_executor"]])
+    if parts_exist:
+        recs.append({
+            "point": "2",
+            "rec": "Deploy Agentic Capacity Dashboard to monitor reporting & resolution KPIs per division/individual.",
+            "mit": "Auto-trigger coaching alerts when deviation >20% from baseline; weekly manager reports."
+        })
+    uc, ua, nm = dev["obj4_unsafe_condition_pct"], dev["obj4_unsafe_action_pct"], dev["obj4_near_miss_pct"]
+    if uc + ua + nm > 0:
+        recs.append({
+            "point": "3",
+            "rec": "Enforce photo-based validation for Unsafe categories to improve classification fidelity.",
+            "mit": "Block submission without evidence and require mandatory justification for manual overrides."
+        })
+    if dev["obj5_q1_divs"] or dev["obj5_q2_divs"]:
+        recs.append({
+            "point": "4",
+            "rec": "Assign Rapid Response Teams for Q1 divisions and apply One-Finding-One-Day policy for Q2.",
+            "mit": "Auto-escalate to senior ops if division remains Q1/Q2 for >=2 months."
+        })
+    if dev["obj6_top2_categories"]:
+        c1, c2 = dev["obj6_top2_categories"]
+        recs.append({
+            "point": "5",
+            "rec": f"Form RCA Task Force for {c1[0]} and {c2[0]} with cross-functional owners.",
+            "mit": "Update SOP and tender templates to include mitigations based on historical findings."
+        })
+    # Ensure at least 5 items
+    i = 1
+    while len(recs) < 5:
+        recs.append({"point": str(len(recs)+1), "rec": "Operational review and monitoring.", "mit": "Periodic review & KPIs."})
+        i += 1
+    return recs[:5]
+
+# --------------------
+# Streamlit UI
+# --------------------
+st.markdown("<h3 class='section-title'>OBJECTIVE 7 — Insight and Recommendation</h3>", unsafe_allow_html=True)
+
+col1, col2 = st.columns([2,1])
+
+with col1:
+    st.subheader("Upload data (or use sample)")
+    uploaded = st.file_uploader("Upload CSV (must contain relevant columns)", type=["csv"])
+    if uploaded is not None:
+        try:
+            df = pd.read_csv(uploaded)
+            st.success("CSV loaded.")
+        except Exception as e:
+            st.error(f"Failed to read CSV: {e}")
+            df = sample_dataframe()
+            st.info("Using sample dataframe due to read error.")
+    else:
+        st.info("No file uploaded — using sample dataset.")
+        df = sample_dataframe()
+
+    st.markdown("### Preview data (first 5 rows)")
+    st.dataframe(df.head(), use_container_width=True)
+
+with col2:
+    st.subheader("LLM / Mode")
+    st.write("Local LLM (flan-t5-small) will be used if available.")
+    st.write(f"Local LLM available: {local_llm_available}")
+    st.button("Reload model", on_click=lambda: st.experimental_rerun())
+
+# --------------------
+# Compute insights
+# --------------------
+dev = extract_agentic_insights_v5(df)
+
+# Build insight_text exactly similar to your format
+insight_lines = []
+if dev["lowest_ratio_9_locs"]:
+    loc_list = ", ".join([f"<strong>{loc}</strong> ({ratio})" for loc, ratio in dev["lowest_ratio_9_locs"]])
+    insight_lines.append(f"1. Nine locations with the <em>lowest</em> finding-to-reporter ratio: {loc_list}.")
+
+parts = []
+if dev["obj3a_lowest_div"]:
+    parts.append(f"division <strong>{dev['obj3a_lowest_div'][0]}</strong> (ratio: {dev['obj3a_lowest_div'][1]})")
+if dev["obj3c_lowest_reporter"]:
+    parts.append(f"reporter <strong>{dev['obj3c_lowest_reporter'][0]}</strong> ({dev['obj3c_lowest_reporter'][1]} findings/month)")
 if dev["obj3d_slowest_div"]:
-    summary_parts.append(f"Slowest division resolution: {dev['obj3d_slowest_div']}")
+    parts.append(f"division <strong>{dev['obj3d_slowest_div'][0]}</strong> (avg. resolution: {dev['obj3d_slowest_div'][1]} days)")
+if dev["obj3b_slowest_executor"]:
+    parts.append(f"executor <strong>{dev['obj3b_slowest_executor'][0]}</strong> (avg. resolution: {dev['obj3b_slowest_executor'][1]} days)")
+
+if parts:
+    insight_lines.append(
+        f"2. Agentic AI highlights operational imbalance: {'; '.join(parts)}. These patterns indicate uneven engagement and resolution capability."
+    )
 
 uc, ua, nm = dev["obj4_unsafe_condition_pct"], dev["obj4_unsafe_action_pct"], dev["obj4_near_miss_pct"]
-summary_parts.append(f"Non-Positive: UnsafeCondition={uc}%, UnsafeAction={ua}%, NearMiss={nm}%")
+if uc + ua + nm > 0:
+    insight_lines.append(f"3. Non-Positive composition: Unsafe Condition ({uc}%), Unsafe Action ({ua}%), Near Miss ({nm}%).")
 
-summary_parts.append(f"Quadrant I: {dev['obj5_q1_divs']}")
-summary_parts.append(f"Quadrant II: {dev['obj5_q2_divs']}")
+if dev["obj5_q1_divs"] or dev["obj5_q2_divs"]:
+    q1 = ", ".join([f"<strong>{d}</strong>" for d in dev["obj5_q1_divs"]]) or "—"
+    q2 = ", ".join([f"<strong>{d}</strong>" for d in dev["obj5_q2_divs"]]) or "—"
+    insight_lines.append(f"4. Quadrant I high-risk divisions: {q1}. Quadrant II hidden-risk divisions: {q2}.")
 
 if dev["obj6_top2_categories"]:
-    summary_parts.append(f"Top non-positive categories: {dev['obj6_top2_categories']}")
-
-insight_summary_text = "\n".join(summary_parts)
+    c1, c2 = dev["obj6_top2_categories"]
+    insight_lines.append(f"5. Top recurring categories: <strong>{c1[0]}</strong> ({c1[1]}/month) and <strong>{c2[0]}</strong> ({c2[1]}/month).")
 
-# Call LLM to generate recommendation + mitigation
-llm_json = llm_generate_recommendation(insight_summary_text)
+insight_text_html = "<br>".join(insight_lines)
+insight_text_plain = "\n".join([s.replace("<strong>", "").replace("</strong>", "").replace("<em>", "").replace("</em>", "") for s in insight_lines])
 
-# Try to parse JSON
-import json
-try:
-    llm_output = json.loads(llm_json)
-    recommendation = llm_output["recommendation"]
-    mitigation = llm_output["mitigation"]
-except:
-    recommendation = "LLM output not valid JSON."
-    mitigation = "-"
-
-# Render
+# --------------------
+# Render Insight card
+# --------------------
 st.markdown(
     f"""
-    <div style="padding:15px; background:#eef3ff; border-left:4px solid #003DA5;">
-        <h4>Insight Summary</h4>
-        <pre style="white-space: pre-wrap;">{insight_summary_text}</pre>
+    <div class="card" style="
+        background-color: #f8f9fa;
+        border-left: 4px solid #003DA5;
+        padding: 16px;
+        margin-bottom: 20px;
+        border-radius: 4px;
+        box-shadow: 0 2px 4px rgba(0,0,0,0.05);
+    ">
+        <h4 style="margin-top: 0; color: #FF6B6B;">Insight Summary</h4>
+        <p style="margin-bottom: 0; line-height: 1.6; font-size: 0.98em;">{insight_text_html if insight_text_html else 'No insights (missing columns).'}</p>
     </div>
     """,
-    unsafe_allow_html=True,
+    unsafe_allow_html=True
 )
 
-st.markdown(
-    f"""
-    <div style="padding:15px; background:#e8f5e9; border-left:4px solid #4CAF50; margin-top:20px;">
-        <h4>LLM Recommended Action</h4>
-        <p>{recommendation}</p>
-        <h4>LLM Risk Mitigation</h4>
-        <p>{mitigation}</p>
+# --------------------
+# Generate Recs via LLM (or fallback)
+# --------------------
+st.markdown("## Recommendations & Risk Mitigation (generated)")
+with st.spinner("Generating recommendations..."):
+    recs = generate_recs_with_local_llm(insight_text_plain, dev, n_items=5) if local_llm_available else None
+
+if not recs:
+    st.warning("LLM not available or failed to parse — using fallback rule-based recommendations.")
+    recs = rule_based_recs(dev)
+
+# --------------------
+# Render Recommendation table (same style)
+# --------------------
+if recs:
+    rows_html = ""
+    for r in recs[:5]:
+        rows_html += (
+            f"<tr>"
+            f"<td style='text-align:center; font-weight:bold; width:5%;'>{r.get('point','')}</td>"
+            f"<td style='padding:8px;'>{r.get('rec','')}</td>"
+            f"<td style='padding:8px;'>{r.get('mit','')}</td>"
+            f"</tr>"
+        )
+
+    table_html = f"""
+    <div class="card" style="
+        background-color: #e8f5e9;
+        border-left: 4px solid #4CAF50;
+        padding: 16px;
+        margin-bottom: 20px;
+        border-radius: 4px;
+        box-shadow: 0 2px 4px rgba(0,0,0,0.05);
+    ">
+        <h4 style="margin-top: 0; color: #2E7D32;">Recommended Actions & Agentic Risk Mitigation</h4>
+        <table style="width:100%; border-collapse:collapse; font-size:0.95em; margin-top:12px;">
+            <thead>
+                <tr style="background-color:#e8f5ee;">
+                    <th style="padding:10px; text-align:center; border:1px solid #ccc;">#</th>
+                    <th style="padding:10px; text-align:left; border:1px solid #ccc;">Recommended Action</th>
+                    <th style="padding:10px; text-align:left; border:1px solid #ccc;">Risk Mitigation Strategy</th>
+                </tr>
+            </thead>
+            <tbody>
+                {rows_html}
+            </tbody>
+        </table>
     </div>
-    """,
-    unsafe_allow_html=True,
-)
+    """
+    st.markdown(table_html, unsafe_allow_html=True)
+else:
+    st.info("No recommendations available.")
+
+# --------------------
+# End
+# --------------------
+st.caption("Objective 7 — Streamlit app. LLM (local) used when available; fallback rule-based otherwise.")