Upload 42 files

.gitattributes

@@ -34,3 +34,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
 models/yahoo_history_cache.sqlite3 filter=lfs diff=lfs merge=lfs -text
+nifty_backend/__pycache__/runtime.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text

data/tomorrow_test_predictions.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:10065b1a9ef8b127e324103911731856946700e857f932ff8f54adb93c63c143
-size 9555
+oid sha256:a0f2de230f3ae32dd009829efe7b90333dfa7f07bdb9a627d96f6173c30c77bb
+size 10739

models/nifty_tomorrow_direction_model.joblib

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:486ac9963b76c67863e49b75422ff6d299bbf85cd8bd9932291016c832794c82
-size 328
+oid sha256:fffacba0382c720974d006020e083b14fe13510c5347b8e2778bc514bb965e34
+size 443

models/tomorrow_latest_prediction.csv

@@ -1,2 +1,2 @@
-input_date,target_date,prediction,prob_up,confidence,threshold,model_name,source_model,validation_accuracy,test_accuracy
-2026-05-27,2026-05-29,DOWN,0.503279589082978,0.503279589082978,0.543,nifty_tomorrow_direction_model,tuned_daily_forest_single,0.5780141843971631,0.6182795698924731
+input_date,target_date,prediction,prob_up,confidence,threshold,model_name,source_model,validation_accuracy,test_accuracy,artifact_source
+2026-05-27,2026-05-29,DOWN,0.4807130191016562,0.5192869808983438,0.54,nifty_tomorrow_direction_model,locked_multiwindow_nifty50_ensemble,0.5673758865248227,0.6368421052631579,C:\Users\jhaji\Downloads\forecasting project\Code\models\nifty_forecaster\outputs

models/tomorrow_summary.json

@@ -3,35 +3,40 @@
   "horizon": "daily",
   "horizon_bars": 1,
   "config": {
-    "name": "tuned_daily_forest_single",
-    "use_intraday": false,
+    "name": "locked_multiwindow_nifty50_ensemble",
+    "use_intraday": true,
     "use_external": true,
     "use_institutional": false,
     "use_options": true,
     "use_engineered_macro_flow": false,
-    "blend_mode": "single_model",
+    "blend_mode": "locked_nifty50_multiwindow",
     "decision_overlay": "bank_body_near_threshold"
   },
-  "threshold": 0.543,
-  "validation_accuracy": 0.5780141843971631,
-  "test_accuracy": 0.6182795698924731,
-  "baseline_accuracy": 0.5053763440860215,
+  "threshold": 0.54,
+  "validation_accuracy": 0.5673758865248227,
+  "test_accuracy": 0.6368421052631579,
+  "baseline_accuracy": 0.5052631578947369,
   "n_train": 2221,
   "n_valid": 282,
-  "n_test": 186,
+  "n_test": 190,
   "train_start": "2015-01-09",
   "train_end": "2023-12-31",
   "valid_start": "2024-07-01",
   "valid_end": "2025-08-17",
   "test_start": "2025-08-18",
-  "test_end": "2026-05-20",
+  "test_end": "2026-05-26",
   "latest_forecast_date": "2026-05-27",
-  "latest_forecast_for": "next trading session 2026-05-29",
-  "latest_forecast_prob_up": 0.503279589082978,
+  "latest_forecast_for": "next trading bar after 2026-05-27",
+  "latest_forecast_prob_up": 0.48071301910165626,
   "latest_forecast_signal": "DOWN",
-  "feature_count": 301,
+  "feature_count": 204,
+  "validation_prob_std": 0.07748322465953016,
+  "test_prob_std": 0.07363146825392504,
+  "test_prob_min": 0.37108281367720986,
+  "test_prob_max": 0.6611571963678617,
   "model_name": "nifty_tomorrow_direction_model",
-  "source_model": "tuned_daily_forest_single",
+  "source_model": "locked_multiwindow_nifty50_ensemble",
   "target": "next trading session NIFTY 50 direction",
-  "latest_target_date": "2026-05-29"
+  "artifact_type": "daily_forecaster_outputs",
+  "artifact_source": "C:\\Users\\jhaji\\Downloads\\forecasting project\\Code\\models\\nifty_forecaster\\outputs"
 }

nifty_backend/runtime.py

@@ -1,9 +1,10 @@
 from __future__ import annotations
 
-import json
-import copy
-import sys
-import threading
+import json
+import copy
+import os
+import sys
+import threading
 from dataclasses import dataclass
 from datetime import date, datetime, time, timedelta
 from functools import lru_cache
@@ -42,8 +43,18 @@ TEST_PREDICTIONS_PATH = DATA_DIR / "test_predictions.parquet"
 TOMORROW_MODEL_PATH = MODEL_DIR / "nifty_tomorrow_direction_model.joblib"
 TOMORROW_LATEST_PATH = MODEL_DIR / "tomorrow_latest_prediction.csv"
 TOMORROW_SUMMARY_PATH = MODEL_DIR / "tomorrow_summary.json"
-TOMORROW_TEST_PREDICTIONS_PATH = DATA_DIR / "tomorrow_test_predictions.parquet"
-TPLUS1_MODEL_PATH = MODEL_DIR / "nifty_1420_tplus1_logistic_model.joblib"
+TOMORROW_TEST_PREDICTIONS_PATH = DATA_DIR / "tomorrow_test_predictions.parquet"
+FORECASTING_PROJECT_ROOT = Path(
+    os.environ.get(
+        "FORECASTING_PROJECT_ROOT",
+        str(BACKEND_ROOT.parent.parent / "forecasting project"),
+    )
+)
+DAILY_FORECASTER_OUTPUT_DIR = FORECASTING_PROJECT_ROOT / "Code" / "models" / "nifty_forecaster" / "outputs"
+DAILY_FORECASTER_SUMMARY_PATH = DAILY_FORECASTER_OUTPUT_DIR / "forecaster_summary.json"
+DAILY_FORECASTER_LATEST_PATH = DAILY_FORECASTER_OUTPUT_DIR / "forecaster_latest.csv"
+DAILY_FORECASTER_PREDICTIONS_PATH = DAILY_FORECASTER_OUTPUT_DIR / "forecaster_test_predictions.csv"
+TPLUS1_MODEL_PATH = MODEL_DIR / "nifty_1420_tplus1_logistic_model.joblib"
 TPLUS1_LATEST_PATH = MODEL_DIR / "tplus1_latest_prediction.csv"
 TPLUS1_SUMMARY_PATH = MODEL_DIR / "tplus1_summary.json"
 TPLUS1_TEST_PREDICTIONS_PATH = DATA_DIR / "tplus1_test_predictions.parquet"
@@ -541,19 +552,125 @@ def latest_saved_prediction() -> dict[str, Any]:
     return dict(_latest_saved_prediction_cached(_file_cache_key(LATEST_PATH), _file_cache_key(MODEL_DIR / "summary.json")))
 
 
-def _latest_saved_prediction_uncached() -> dict[str, Any]:
+def _latest_saved_prediction_uncached() -> dict[str, Any]:
     if LATEST_PATH.exists():
         return pd.read_csv(LATEST_PATH).iloc[-1].to_dict()
     summary_path = MODEL_DIR / "summary.json"
     if summary_path.exists():
         return json.loads(summary_path.read_text(encoding="utf-8"))
-    raise FileNotFoundError("No latest prediction is available yet.")
-
-
-def load_tomorrow_model_artifact() -> dict[str, Any]:
-    if TOMORROW_MODEL_PATH.exists():
-        return joblib.load(TOMORROW_MODEL_PATH)
-    summary = load_tomorrow_summary()
+    raise FileNotFoundError("No latest prediction is available yet.")
+
+
+def _read_daily_forecaster_summary() -> dict[str, Any] | None:
+    if not DAILY_FORECASTER_SUMMARY_PATH.exists():
+        return None
+    raw = json.loads(DAILY_FORECASTER_SUMMARY_PATH.read_text(encoding="utf-8"))
+    if isinstance(raw, list):
+        matches = [row for row in raw if row.get("symbol") == "NIFTY 50"]
+        summary = dict(matches[0] if matches else raw[0])
+    elif isinstance(raw, dict):
+        summary = dict(raw)
+    else:
+        return None
+    config = summary.get("config") if isinstance(summary.get("config"), dict) else {}
+    summary.setdefault("symbol", "NIFTY 50")
+    summary.setdefault("horizon", "daily")
+    summary.setdefault("horizon_bars", 1)
+    summary["model_name"] = "nifty_tomorrow_direction_model"
+    summary["source_model"] = str(config.get("name") or summary.get("source_model") or "locked_multiwindow_nifty50_ensemble")
+    summary["target"] = "next trading session NIFTY 50 direction"
+    summary["artifact_type"] = "daily_forecaster_outputs"
+    summary["artifact_source"] = str(DAILY_FORECASTER_OUTPUT_DIR)
+    return summary
+
+
+def _read_daily_forecaster_latest(summary: dict[str, Any]) -> dict[str, Any] | None:
+    if not DAILY_FORECASTER_LATEST_PATH.exists():
+        return None
+    latest = pd.read_csv(DAILY_FORECASTER_LATEST_PATH)
+    if latest.empty:
+        return None
+    if "symbol" in latest.columns:
+        filtered = latest[latest["symbol"].astype(str) == "NIFTY 50"]
+        if not filtered.empty:
+            latest = filtered
+    row = {k: (None if pd.isna(v) else v) for k, v in latest.iloc[-1].to_dict().items()}
+    input_date = row.get("latest_forecast_date") or row.get("input_date")
+    target_date = row.get("target_date")
+    if not target_date and input_date:
+        try:
+            target_date = next_trading_day(date.fromisoformat(str(input_date)[:10]) + timedelta(days=1)).isoformat()
+        except Exception:
+            target_date = None
+    prob_up = row.get("latest_forecast_prob_up", row.get("prob_up"))
+    prediction = row.get("latest_forecast_signal", row.get("prediction"))
+    threshold = row.get("threshold", summary.get("threshold"))
+    confidence = row.get("confidence")
+    if confidence is None and prob_up is not None:
+        try:
+            confidence = float(max(float(prob_up), 1.0 - float(prob_up)))
+        except Exception:
+            confidence = None
+    return {
+        "input_date": input_date,
+        "target_date": target_date,
+        "prediction": prediction,
+        "prob_up": prob_up,
+        "confidence": confidence,
+        "threshold": threshold,
+        "model_name": "nifty_tomorrow_direction_model",
+        "source_model": summary.get("source_model", "locked_multiwindow_nifty50_ensemble"),
+        "validation_accuracy": summary.get("validation_accuracy"),
+        "test_accuracy": summary.get("test_accuracy"),
+        "artifact_source": str(DAILY_FORECASTER_OUTPUT_DIR),
+    }
+
+
+def sync_daily_forecaster_outputs() -> dict[str, Any] | None:
+    summary = _read_daily_forecaster_summary()
+    if summary is None:
+        return None
+    latest = _read_daily_forecaster_latest(summary)
+    TOMORROW_SUMMARY_PATH.write_text(json.dumps(summary, indent=2), encoding="utf-8")
+    if latest is not None:
+        pd.DataFrame([latest]).to_csv(TOMORROW_LATEST_PATH, index=False)
+    if DAILY_FORECASTER_PREDICTIONS_PATH.exists():
+        predictions = pd.read_csv(DAILY_FORECASTER_PREDICTIONS_PATH)
+        if "symbol" in predictions.columns:
+            predictions = predictions[predictions["symbol"].astype(str) == "NIFTY 50"].copy()
+        if not predictions.empty:
+            if "pred" in predictions.columns and "prediction" not in predictions.columns:
+                predictions["prediction"] = np.where(pd.to_numeric(predictions["pred"], errors="coerce") == 1, "UP", "DOWN")
+            if "correct" not in predictions.columns and {"target", "pred"}.issubset(predictions.columns):
+                predictions["correct"] = (
+                    pd.to_numeric(predictions["target"], errors="coerce")
+                    == pd.to_numeric(predictions["pred"], errors="coerce")
+                )
+            predictions.to_parquet(TOMORROW_TEST_PREDICTIONS_PATH, index=False)
+    artifact = {
+        "artifact_type": "daily_forecaster_outputs",
+        "model_name": "nifty_tomorrow_direction_model",
+        "source_model": summary.get("source_model", "locked_multiwindow_nifty50_ensemble"),
+        "threshold": float(summary.get("threshold", 0.54)),
+        "validation_accuracy": summary.get("validation_accuracy"),
+        "test_accuracy": summary.get("test_accuracy"),
+        "validation_prob_std": summary.get("validation_prob_std"),
+        "test_prob_std": summary.get("test_prob_std"),
+        "test_prob_min": summary.get("test_prob_min"),
+        "test_prob_max": summary.get("test_prob_max"),
+        "artifact_source": str(DAILY_FORECASTER_OUTPUT_DIR),
+    }
+    joblib.dump(artifact, TOMORROW_MODEL_PATH)
+    return latest or summary
+
+
+def load_tomorrow_model_artifact() -> dict[str, Any]:
+    synced = sync_daily_forecaster_outputs()
+    if synced is not None and TOMORROW_MODEL_PATH.exists():
+        return joblib.load(TOMORROW_MODEL_PATH)
+    if TOMORROW_MODEL_PATH.exists():
+        return joblib.load(TOMORROW_MODEL_PATH)
+    summary = load_tomorrow_summary()
     return {
         "artifact_type": "daily_forecaster_snapshot",
         "model_name": summary.get("model_name", "nifty_tomorrow_direction_model"),
@@ -562,23 +679,27 @@ def load_tomorrow_model_artifact() -> dict[str, Any]:
     }
 
 
-def load_tomorrow_summary() -> dict[str, Any]:
-    if TOMORROW_SUMMARY_PATH.exists():
-        return json.loads(TOMORROW_SUMMARY_PATH.read_text(encoding="utf-8"))
-    return {
-        "model_name": "nifty_tomorrow_direction_model",
-        "source_model": "tuned_daily_forest_single",
-        "target": "next trading session NIFTY 50 direction",
-        "threshold": 0.543,
-        "validation_accuracy": 0.5780141843971631,
-        "test_accuracy": 0.6182795698924731,
-        "baseline_accuracy": 0.5053763440860215,
-        "n_test": 186,
-        "feature_count": 301,
-    }
+def load_tomorrow_summary() -> dict[str, Any]:
+    synced = sync_daily_forecaster_outputs()
+    if synced is not None and TOMORROW_SUMMARY_PATH.exists():
+        return json.loads(TOMORROW_SUMMARY_PATH.read_text(encoding="utf-8"))
+    if TOMORROW_SUMMARY_PATH.exists():
+        return json.loads(TOMORROW_SUMMARY_PATH.read_text(encoding="utf-8"))
+    return {
+        "model_name": "nifty_tomorrow_direction_model",
+        "source_model": "locked_multiwindow_nifty50_ensemble",
+        "target": "next trading session NIFTY 50 direction",
+        "threshold": 0.54,
+        "validation_accuracy": 0.5673758865248227,
+        "test_accuracy": 0.6451612903225806,
+        "baseline_accuracy": 0.5053763440860215,
+        "n_test": 186,
+        "feature_count": 204,
+    }
 
 
 def latest_tomorrow_prediction() -> dict[str, Any]:
+    sync_daily_forecaster_outputs()
     latest_daily = latest_parquet_date(NIFTY_1D_PATH)
     if TOMORROW_LATEST_PATH.exists():
         row = pd.read_csv(TOMORROW_LATEST_PATH).iloc[-1].to_dict()
@@ -589,9 +710,15 @@ def latest_tomorrow_prediction() -> dict[str, Any]:
             input_day = None
         if latest_daily is not None and (input_day is None or input_day < latest_daily):
             try:
-                return refresh_tomorrow_prediction(session_date=latest_daily)
+                refreshed = refresh_tomorrow_prediction(session_date=latest_daily)
+                try:
+                    refreshed_day = date.fromisoformat(str(refreshed.get("input_date"))[:10])
+                except Exception:
+                    refreshed_day = None
+                if refreshed_day is not None and refreshed_day >= latest_daily:
+                    return refreshed
             except Exception:
-                return cleaned
+                pass
         return cleaned
     summary = load_tomorrow_summary()
     try:
@@ -835,9 +962,23 @@ def _tomorrow_probability_from_daily(daily: pd.DataFrame, fallback_prob: float)
     return float(np.clip(score, 0.35, 0.65))
 
 
-def refresh_tomorrow_prediction(session_date: date | None = None) -> dict[str, Any]:
-    summary = load_tomorrow_summary()
-    artifact = load_tomorrow_model_artifact()
+def refresh_tomorrow_prediction(session_date: date | None = None) -> dict[str, Any]:
+    synced = sync_daily_forecaster_outputs()
+    if synced is not None and TOMORROW_LATEST_PATH.exists():
+        latest = pd.read_csv(TOMORROW_LATEST_PATH).iloc[-1].to_dict()
+        cleaned = {k: (None if pd.isna(v) else v) for k, v in latest.items()}
+        if session_date is None:
+            clear_dashboard_payload_cache()
+            return cleaned
+        try:
+            input_day = date.fromisoformat(str(cleaned.get("input_date"))[:10])
+        except Exception:
+            input_day = None
+        if input_day is not None:
+            clear_dashboard_payload_cache()
+            return cleaned
+    summary = load_tomorrow_summary()
+    artifact = load_tomorrow_model_artifact()
     daily = pd.read_parquet(NIFTY_1D_PATH)
     daily["date"] = pd.to_datetime(daily["date"], errors="coerce").dt.normalize()
     daily = daily.dropna(subset=["date"]).sort_values("date")