Refine scoring calibration, Kisan recommendations, and stress-test edge cases

app.py

@@ -623,8 +623,8 @@ def build_farmer_input(prefix: str, compact: bool = False, label_lang: Optional[
             prev_default = st.radio(
                 text["default_hist"], ["No", "Yes"], horizontal=True, key=f"{prefix}_default"
             )
-            rain_def = st.slider(text["rain_def"], 0, 60, 20, 1, key=f"{prefix}_rain")
-            spi = st.slider(text["spi"], -3.0, 2.0, -1.0, 0.1, key=f"{prefix}_spi")
+            rain_def = st.slider(text["rain_def"], 0, 60, 0, 1, key=f"{prefix}_rain")
+            spi = st.slider(text["spi"], -3.0, 2.0, 0.3, 0.1, key=f"{prefix}_spi")
             drought = st.selectbox(
                 text["drought_years"],
                 DROUGHT_OPTIONS,
@@ -643,8 +643,8 @@ def build_farmer_input(prefix: str, compact: bool = False, label_lang: Optional[
         )
         st.markdown("---")
         st.markdown(f"<div class='section-label'>{html.escape(text['section_climate'])}</div>", unsafe_allow_html=True)
-        rain_def = st.slider(text["rain_def"], 0, 60, 20, 1, key=f"{prefix}_rain")
-        spi = st.slider(text["spi"], -3.0, 2.0, -1.0, 0.1, key=f"{prefix}_spi")
+        rain_def = st.slider(text["rain_def"], 0, 60, 0, 1, key=f"{prefix}_rain")
+        spi = st.slider(text["spi"], -3.0, 2.0, 0.3, 0.1, key=f"{prefix}_spi")
         spi_label_idx = 0 if spi <= -1.5 else 1 if spi <= -0.5 else 2
         st.caption(SPI_LABELS[lang][spi_label_idx])
         drought = st.selectbox(
@@ -708,19 +708,64 @@ def build_score_gauge(score: int, risk_band: str):
     return plotly_theme(fig)
 
 
-def extract_action_cards(text: str, language: str) -> List[str]:
+def extract_action_cards(text: str, language: str, farmer_input: Dict, result: Dict) -> List[str]:
     fallback = (
-        ["🌱 Fasal Badlein", "💧 Sinchai Sudharen", "🛡️ Bima Karwain"]
+        ["🌱 फसल विविधीकरण करें", "💧 सिंचाई दक्षता बढ़ाएँ", "🛡️ फसल बीमा लें"]
         if language == "Hindi"
-        else ["🌱 Shift Crop Mix", "💧 Improve Irrigation", "🛡️ Take Insurance"]
+        else ["🌱 Diversify crop mix", "💧 Improve irrigation efficiency", "🛡️ Take crop insurance"]
     )
-    if not text:
-        return fallback
-    lines = [ln.strip(" -•\t") for ln in text.splitlines() if ln.strip()]
-    picks = [
-        ln for ln in lines if any(k in ln.lower() for k in ["insurance", "crop", "irrig", "बीमा", "फसल", "सिंच"])
-    ]
-    return (picks[:3] if len(picks) >= 3 else fallback)[:3]
+
+    def _uniq(items: List[str]) -> List[str]:
+        out: List[str] = []
+        for it in items:
+            clean = it.strip()
+            if clean and clean not in out:
+                out.append(clean)
+        return out
+
+    picked_from_text: List[str] = []
+    if text:
+        lines = [ln.strip(" -•\t") for ln in text.splitlines() if ln.strip()]
+        picked_from_text = [
+            ln
+            for ln in lines
+            if any(k in ln.lower() for k in ["insurance", "crop", "irrig", "बीमा", "फसल", "सिंच"])
+        ][:3]
+
+    rf = float(farmer_input.get("rainfall_deficit_pct", 0.0))
+    spi = float(farmer_input.get("spi", 0.0))
+    dyears = int(farmer_input.get("consecutive_drought_years", 0))
+    prev = int(farmer_input.get("previous_defaults", 0))
+    dti = float(farmer_input.get("loan_amount_lakhs", 0.0)) / max(float(farmer_input.get("annual_income_lakhs", 1.0)), 0.1)
+    crop = str(farmer_input.get("crop_type", ""))
+    risk_band = str(result.get("risk_band", ""))
+
+    dynamic: List[str] = []
+    if language == "Hindi":
+        if rf <= -20 or spi <= -1.2 or dyears >= 1:
+            dynamic.append("💧 तुरंत जल-संरक्षण योजना अपनाएँ (ड्रिप/मल्च/लाइन सिंचाई)")
+        if crop in {"Rice", "Sugarcane"} and rf <= -15:
+            dynamic.append("🌱 कम पानी वाली फसल/मिश्रित खेती पर विचार करें")
+        if dti > 0.5:
+            dynamic.append("📉 ऋण राशि या किश्त संरचना को आय के अनुसार पुनर्संतुलित करें")
+        if prev == 1:
+            dynamic.append("🧾 पिछले बकाये के लिए समयबद्ध चुकौती योजना बनाएं")
+        if "High" in risk_band or "Medium" in risk_band:
+            dynamic.append("🛡️ मौसम-आधारित फसल बीमा और नुकसान कवर सक्रिय करें")
+    else:
+        if rf <= -20 or spi <= -1.2 or dyears >= 1:
+            dynamic.append("💧 Start an immediate water-conservation plan (drip/mulch/scheduling)")
+        if crop in {"Rice", "Sugarcane"} and rf <= -15:
+            dynamic.append("🌱 Consider a lower water-intensity crop mix for the next cycle")
+        if dti > 0.5:
+            dynamic.append("📉 Rebalance loan size/instalments to better match farm income")
+        if prev == 1:
+            dynamic.append("🧾 Create a time-bound plan to clear past overdues")
+        if "High" in risk_band or "Medium" in risk_band:
+            dynamic.append("🛡️ Activate weather-index crop insurance and loss cover")
+
+    cards = _uniq(picked_from_text + dynamic + fallback)
+    return cards[:3]
 
 
 def try_farmer_explanation(client, farmer_input, result, language: str) -> str:
@@ -821,7 +866,7 @@ def tab_kisan(client):
                 stored.setdefault("explanation_sources", {})[lang] = get_inference_config()[0]
         explanation = stored["explanations"][lang]
         expl_mode = stored.get("explanation_sources", {}).get(lang, get_inference_config()[0])
-        cards = extract_action_cards(explanation, lang)
+        cards = extract_action_cards(explanation, lang, stored["input"], result)
 
         st.plotly_chart(build_score_gauge(result["credit_score"], result["risk_band"]), use_container_width=True)
         st.markdown(
@@ -962,6 +1007,11 @@ def tab_officer(client):
 
 
 def build_portfolio(n_loans: int, avg_loan: float, dominant_crop: str):
+    """
+    Synthetic portfolio draws. Uses an isolated RNG so each Run produces a fresh book even if
+    global np.random was seeded elsewhere (e.g. training helpers).
+    """
+    rng = np.random.default_rng()
     crops = list(CROP_WATER_MAP.keys())
     probs_map = {
         "Cotton": [0.5 if c == "Cotton" else 0.5 / (len(crops) - 1) for c in crops],
@@ -972,16 +1022,16 @@ def build_portfolio(n_loans: int, avg_loan: float, dominant_crop: str):
     crop_probs = probs_map[dominant_crop]
     portfolio = []
     for _ in range(n_loans):
-        crop = np.random.choice(crops, p=crop_probs)
+        crop = str(rng.choice(crops, p=crop_probs))
         portfolio.append(
             {
-                "age": int(np.random.randint(28, 62)),
-                "land_size_acres": round(np.random.uniform(1, 10), 2),
-                "annual_income_lakhs": round(np.random.uniform(1.5, 10), 2),
-                "loan_amount_lakhs": round(max(0.5, np.random.normal(avg_loan, 0.6)), 2),
-                "previous_defaults": int(np.random.choice([0, 1], p=[0.82, 0.18])),
+                "age": int(rng.integers(28, 62)),
+                "land_size_acres": round(float(rng.uniform(1, 10)), 2),
+                "annual_income_lakhs": round(float(rng.uniform(1.5, 10)), 2),
+                "loan_amount_lakhs": round(max(0.5, float(rng.normal(avg_loan, 0.6))), 2),
+                "previous_defaults": int(rng.choice([0, 1], p=[0.82, 0.18])),
                 "crop_type": crop,
-                "state": str(np.random.choice(["Maharashtra", "Punjab"], p=[0.6, 0.4])),
+                "state": str(rng.choice(["Maharashtra", "Punjab"], p=[0.6, 0.4])),
                 "rainfall_deficit_pct": 0.0,
                 "spi": 0.0,
                 "consecutive_drought_years": 0,
@@ -1014,17 +1064,39 @@ def tab_portfolio(client):
     if run:
         with st.spinner("Simulating portfolio across climate scenarios…"):
             portfolio = build_portfolio(int(n_loans), float(avg_loan), dominant_crop)
-            stress = run_stress_test(st.session_state.model, st.session_state.scaler, portfolio)
-        rr = recovery_rate / 100
-        for row in stress:
-            row["total_loss_lakhs"] = round(row["avg_default_pct"] / 100 * avg_loan * (1 - rr) * n_loans, 2)
-        st.session_state.last_stress_result = {"stress": stress, "narratives": {}, "narrative_sources": {}}
+            rr = recovery_rate / 100
+            stress = run_stress_test(
+                st.session_state.model,
+                st.session_state.scaler,
+                portfolio,
+                avg_loan_lakhs=float(avg_loan),
+                recovery_rate=float(rr),
+            )
+        st.session_state.last_stress_result = {
+            "stress": stress,
+            "narratives": {},
+            "narrative_sources": {},
+            "portfolio_meta": {
+                "n_loans": int(n_loans),
+                "avg_loan": float(avg_loan),
+                "recovery_pct": int(recovery_rate),
+                "dominant_crop": dominant_crop,
+            },
+        }
         st.success("Stress test complete. Charts are below.")
 
     if not st.session_state.last_stress_result:
         st.markdown(narr_html(text["empty_portfolio"]), unsafe_allow_html=True)
         return
 
+    meta = st.session_state.last_stress_result.get("portfolio_meta")
+    if meta:
+        st.caption(
+            f"Charts reflect your last Run: {meta['n_loans']} loans, avg ticket ₹{meta['avg_loan']} lakhs, "
+            f"{meta['recovery_pct']}% recovery, dominant crop mix {meta['dominant_crop']}. "
+            "Change inputs and tap Run stress test again for a new simulated book."
+        )
+
     stress = st.session_state.last_stress_result["stress"]
     df = pd.DataFrame(stress)
     order = ["Normal Monsoon", "Moderate Drought", "Severe Drought", "Back-to-Back Drought"]
@@ -1049,6 +1121,7 @@ def tab_portfolio(client):
             "Back-to-Back Drought": "#7F0000",
         },
     )
+    bar.update_traces(texttemplate="%{x:.2f}", textposition="outside", cliponaxis=False)
     bar.update_layout(showlegend=False, yaxis_title="", xaxis_title="Estimated loss (₹ lakhs)", height=330)
     st.plotly_chart(plotly_theme(bar), use_container_width=True)
 
@@ -1098,13 +1171,12 @@ def tab_portfolio(client):
 
     normal_loss = float(df[df["scenario"] == "Normal Monsoon"]["total_loss_lakhs"].iloc[0])
     worst_loss = float(df["total_loss_lakhs"].max())
-    gap = round(worst_loss - normal_loss, 2)
-    buf = int(gap // 100 * 100)
+    gap = round(max(worst_loss - normal_loss, 0), 2)
     cap_lines = (
         f"<b>Capital buffer indicator</b><br><br>"
-        f"Baseline (normal monsoon) loss estimate: ₹{normal_loss} lakhs<br>"
-        f"Incremental stress to worst scenario shown: ₹{gap} lakhs<br>"
-        f"Rule-of-thumb buffer to discuss with risk: ₹{buf} lakhs+"
+        f"Baseline (normal monsoon) loss estimate: ₹{round(normal_loss, 2)} lakhs<br>"
+        f"Worst scenario loss in this run: ₹{round(worst_loss, 2)} lakhs<br>"
+        f"<b>Incremental climate tail</b> (worst minus baseline): ₹{gap} lakhs — use this gap when discussing extra provisioning vs normal weather."
     )
     st.markdown(f"<div class='soft-note narr-body'>{cap_lines}</div>", unsafe_allow_html=True)
 

climaiq_engine.py

@@ -188,24 +188,38 @@ def engineer_single_input(data: dict) -> pd.DataFrame:
 
 # ─── Credit Score Calculation ──────────────────────────────────────────────────
 
-def compute_credit_score(model, scaler, feature_row: pd.DataFrame,
-                          base_score=650, pdo=50) -> int:
-    """Convert default probability into 300–850 credit score."""
-    coef = model.coef_[0]
-    factor = pdo / np.log(2)
-    offset = base_score - factor * np.log(20)
+def compute_credit_score(
+    model,
+    scaler,
+    feature_row: pd.DataFrame,
+    base_score: int = 650,
+    pdo: int = 50,
+    p_ref: float = 0.20,
+) -> int:
+    """
+    Convert model PD to score using a log-odds mapping.
 
-    z = scaler.transform(feature_row)[0]
-    score = offset + np.sum(z * (-factor * coef))
+    Calibration anchor:
+      - score = base_score when PD = p_ref
+      - +pdo points for each halving of default odds
+    """
+    scaled = scaler.transform(feature_row)
+    pd_raw = float(model.predict_proba(scaled)[0][1])
+    pd_safe = float(np.clip(pd_raw, 1e-4, 1 - 1e-4))
+
+    factor = pdo / np.log(2)
+    logit = np.log(pd_safe / (1 - pd_safe))
+    logit_ref = np.log(p_ref / (1 - p_ref))
+    score = base_score - factor * (logit - logit_ref)
     return int(np.clip(score, 300, 850))
 
 
 def get_risk_band(score: int) -> str:
     if score >= 700:
         return "Very Low Risk"
-    elif score >= 650:
+    elif score >= 640:
         return "Low Risk"
-    elif score >= 600:
+    elif score >= 560:
         return "Medium Risk"
     else:
         return "High Risk"
@@ -286,20 +300,31 @@ def predict_single(data: dict, model, scaler) -> dict:
 
 # ─── Stress Test ───────────────────────────────────────────────────────────────
 
-def run_stress_test(model, scaler, base_portfolio: list) -> list:
+def run_stress_test(
+    model,
+    scaler,
+    base_portfolio: list,
+    avg_loan_lakhs: float = 3.0,
+    recovery_rate: float = 0.30,
+) -> list:
     """
     Run 4 climate scenarios across a list of farmer input dicts.
-    Returns list of scenario result dicts.
+    Expected portfolio loss uses the supplied average ticket (₹ lakhs) and recovery_rate (0–1).
     """
     scenarios = {
-        "Normal Monsoon":     {"rainfall_deficit_pct": 0,   "spi": 0,    "consecutive_drought_years": 0},
-        "Moderate Drought":   {"rainfall_deficit_pct": -20, "spi": -1.2, "consecutive_drought_years": 1},
-        "Severe Drought":     {"rainfall_deficit_pct": -35, "spi": -1.8, "consecutive_drought_years": 1},
+        "Normal Monsoon": {"rainfall_deficit_pct": 0, "spi": 0, "consecutive_drought_years": 0},
+        "Moderate Drought": {"rainfall_deficit_pct": -20, "spi": -1.2, "consecutive_drought_years": 1},
+        "Severe Drought": {"rainfall_deficit_pct": -35, "spi": -1.8, "consecutive_drought_years": 1},
         "Back-to-Back Drought": {"rainfall_deficit_pct": -25, "spi": -1.5, "consecutive_drought_years": 2},
     }
 
-    avg_loan = 3.0
-    recovery = 0.30
+    n = len(base_portfolio)
+    rm = float(recovery_rate)
+    if rm < 0:
+        rm = 0.0
+    elif rm > 1:
+        rm = 1.0
+
     results = []
 
     for scenario_name, overrides in scenarios.items():
@@ -310,13 +335,13 @@ def run_stress_test(model, scaler, base_portfolio: list) -> list:
             probs.append(result["default_probability"] / 100)
 
         avg_default_pct = np.mean(probs) * 100
-        total_loss = np.mean(probs) * avg_loan * (1 - recovery) * len(base_portfolio)
+        total_loss = np.mean(probs) * float(avg_loan_lakhs) * (1 - rm) * n
 
         results.append({
             "scenario": scenario_name,
             "avg_default_pct": round(avg_default_pct, 2),
             "total_loss_lakhs": round(total_loss, 2),
-            "portfolio_size": len(base_portfolio)
+            "portfolio_size": n,
         })
 
     return results

climaiq_gemma.py

@@ -31,6 +31,13 @@ GEMMA_MODEL = GEMMA_MODEL_CLOUD
 
 DEFAULT_OLLAMA_BASE = os.environ.get("OLLAMA_BASE_URL", "http://127.0.0.1:11434").rstrip("/")
 DEFAULT_OLLAMA_MODEL = os.environ.get("OLLAMA_MODEL", "gemma3:4b")
+CROP_WATER_CLASS = {
+    "Rice": "very high",
+    "Sugarcane": "very high",
+    "Cotton": "moderate",
+    "Wheat": "low",
+    "Millets": "very low",
+}
 
 
 def _ollama_installed_name_matches(installed: str, requested: str) -> bool:
@@ -153,6 +160,8 @@ def generate_explanation_text(
 
 def _build_farmer_prompt(farmer_data: dict, result: dict, language: str) -> str:
     drivers = "\n".join([f"- {d['display_name']}" for d in result["top_risk_drivers"]])
+    crop = str(farmer_data["crop_type"])
+    water_class = CROP_WATER_CLASS.get(crop, "moderate")
 
     if language == "Hindi":
         return f"""
@@ -178,6 +187,7 @@ ClimaIQ परिणाम:
 1. किसान को सरल भाषा में बताएं कि उनका स्कोर क्यों कम/अधिक है
 2. मौसम और फसल का जोखिम पर क्या असर हुआ, यह समझाएं
 3. किसान 3 व्यावहारिक कदम क्या उठा सकते हैं (बीमा, वैकल्पिक फसल, सिंचाई आदि)
+महत्वपूर्ण तथ्य: इस इंजन में {crop} की पानी-आधारित श्रेणी "{water_class}" मानी जाती है। पानी-आवश्यकता के बारे में इससे उल्टा दावा न करें।
 केवल हिंदी में उत्तर दें। जटिल शब्दों से बचें।
 """
     else:
@@ -204,6 +214,7 @@ In 4-5 simple sentences:
 1. Explain why their score is what it is
 2. Explain how the weather and crop type has affected their risk
 3. Give 3 practical steps they can take (insurance, alternate crops, irrigation, etc.)
+Important fact guardrail: in this engine, {crop} is classified as "{water_class}" water-intensity. Do not claim the opposite.
 Use simple, non-technical language. Be empathetic and constructive.
 """