Add unified multi-task model (single checkpoint, 7 domains)

README.md

@@ -1,89 +1,139 @@
----
-license: mit
-library_name: pytorch
-tags:
-- time-series
-- forecasting
-- lstm
-- finance
-- weather
-- multi-domain
-language:
-- en
-metrics:
-- mae
-- mape
-pipeline_tag: time-series-forecasting
----
-
-# Future Prediction Models (Multi-Domain LSTM)
-
-An end-to-end multi-domain forecasting system. For each of **7 topics** it automatically fetches a real dataset, trains a 2-layer LSTM, evaluates on a held-out test set (no leakage), and generates ChatGPT-style future predictions.
-
-## Topics & validated accuracy
-
-| Topic | Asset | Source | H1 MAPE | vs naive |
-|---|---|---|---|---|
-| AI | NVIDIA daily close | Yahoo Finance | 1.86% | ~naive |
-| Economy | S&P 500 daily close | Yahoo Finance | 0.64% | beats naive 1.8% |
-| Energy | WTI crude oil close | Yahoo Finance | 2.83% | ~naive |
-| Finance | Bitcoin BTC-USD | Yahoo Finance | 1.52% | ~naive |
-| Programming | `react` npm downloads | npm registry | 7.12% | **beats naive 77.5%** |
-| Sports | ATP world #1 Elo | Hugging Face tennis | 0.06% | ~naive |
-| Weather | Daily mean temperature | Open-Meteo | 0.18% | beats naive 1.9% |
-
-> Markets behave near a random walk, so 100% accuracy is impossible — these are honest, validated numbers.
-
-## Quick start
-
-```bash
-pip install -r requirements.txt
-python data.py --topic finance --refresh   # fetch real data
-python train.py --topic finance            # train the LSTM
-python ask.py "what will bitcoin do next week?"
-python ask.py "compare all topics"
+# Future Prediction Models (Global: 7 topics)
+
+An end-to-end multi-domain AI forecasting system. Real datasets, two model modes, ChatGPT-style predictions.
+
+## Models: separate vs unified
+
+- **Separate** (`model_<topic>.pt`) — 7 dedicated 2-layer LSTMs, one per topic
+- **Unified** (`unified_model.pt`) — ONE combined model for all 7 domains: shared LSTM backbone + per-domain embedding + per-domain heads, trained jointly on 31,735 windows from every topic
+
+```powershell
+python train_unified.py                          # train the single combined model
+python predict.py --topic finance --mode unified # query it for any topic
+python ask.py "compare all topics"               # chat uses unified automatically when available
 ```
 
-## Architecture
+## Topics & datasets (all real, fetched automatically)
+
+| Topic | Asset | Source | Points |
+|---|---|---|---|
+| **AI** | NVIDIA daily close | Yahoo Finance | 6,933 |
+| **Programming** | Daily `react` npm downloads | npm registry API | 547 |
+| **Finance** | Bitcoin BTC-USD close | Yahoo Finance (Hugging Face fallback) | 4,247 |
+| **Sports** | ATP world #1 Elo rating | Hugging Face tennis (93,028 matches, Elo computed from results) | 10,944 |
+| **Weather** | Daily mean temperature (any city) | Open-Meteo archive | 4,248 |
+| **Economy** | S&P 500 daily close | Yahoo Finance | 6,694 |
+| **Energy** | WTI crude oil close | Yahoo Finance | 6,524 |
+
+- Weather city is configurable: set env vars `WEATHER_NAME` / `WEATHER_LAT` / `WEATHER_LON`, or add cities to `weather_cities.py` (Chennai, Mumbai, Delhi, London, Tokyo, ... included).
+- Every topic falls back gracefully: Hugging Face search -> API -> synthetic data if fully offline.
+
+## Validated accuracy (held-out test set, no data leakage)
+
+Separate per-topic models:
+
+| Topic | MAE | H1 MAPE | vs naive baseline |
+|---|---|---|---|
+| AI (NVIDIA) | $6.73 | 1.86% | ~naive |
+| Economy (S&P 500) | $85.51 | 0.64% | beats naive by 1.8% |
+| Energy (WTI) | $4.78 | 2.83% | ~naive |
+| Finance (Bitcoin) | $1,982.95 | 1.52% | ~naive |
+| Programming (react) | 1.17M downloads | 7.12% | **beats naive by 77.5%** |
+| Sports (ATP #1 Elo) | 3.40 Elo | 0.06% | ~naive |
+| Weather (Chennai temp) | 0.99 K | 0.18% | beats naive by 1.9% |
+
+Unified single model (trained jointly, one checkpoint for everything):
+
+| Topic | MAE | H1 MAPE |
+|---|---|---|
+| AI | $3.40 | 2.36% |
+| Economy | $72.21 | 0.75% |
+| Energy | $2.93 | 1.90% |
+| Finance | $2,863.45 | 1.74% |
+| Programming | 1.14M downloads | 5.42% |
+| Sports | 2.75 Elo | 0.04% |
+| Weather | 0.94 K | 0.18% |
+
+> Markets behave near a random walk, so 100% accuracy is impossible — these are honest, validated numbers. No model can guarantee the future.
+
+## Architecture (normal mode shows only the final response)
 
 ```
 user question -> intent detection (response.py)
               -> prediction_engine.py   (structured metrics, prints nothing)
-              -> response_formatter.py  (natural summary + Markdown)
-              -> ask.py                 (chat CLI, stdout)
+              -> response_formatter.py  (natural summary + Markdown, no internal details)
+              -> ask.py                 (chat_output, stdout)
+```
+
+- `ask.py` — chat CLI; only the final assistant response reaches the user
+- `response.py` — intent detection + orchestration (topic, location, horizon, style)
+- `prediction_engine.py` — runs the LSTM, returns distinct metrics:
+  `net_change_pct` (path change), `forecast_range_pct` (path min-max range),
+  `current_to_forecast_pct` (vs latest observed value), `direction`
+  (rising/falling/sideways, configurable threshold), `primary_forecast`
+  (end-of-horizon value)
+- `response_formatter.py` — presents metrics naturally; opens with a one-sentence
+  ChatGPT-style summary; never invents confidence, probability, or values
+- `debug_logger.py` — internal logs go to stderr only when `FORECAST_DEBUG=1` (or `--debug`)
+- `data.py` — multi-topic data pipeline (fetchers + caching to `data/<topic>.csv`)
+- `weather_cities.py` — city registry for location-specific weather models
+- `model.py` / `train.py` — 2-layer LSTM, Huber loss, AdamW, early stopping, temporal split
+- `predict.py` — per-topic model loader, rollout forecast, chart + text report
+- `multi.py` — trains + evaluates all topics; quiet in normal mode
+
+## Ask it anything (ChatGPT-style)
+
+```powershell
+.\.venv\Scripts\python.exe ask.py                                 # interactive chat
+.\.venv\Scripts\python.exe ask.py "what will bitcoin do next week?"
+.\.venv\Scripts\python.exe ask.py "compare all topics"
+.\.venv\Scripts\python.exe ask.py --detailed "predict programming for 14 days"
+.\.venv\Scripts\python.exe ask.py --debug "predict ai for 3 days" # internal logs on stderr
 ```
 
-The engine returns clearly separated metrics — never conflating them:
-- `net_change_pct` (first → last forecast along the path)
-- `forecast_range_pct` (max − min of the forecast path)
-- `current_to_forecast_pct` (final forecast vs latest observed value)
-- `direction` (rising / falling / sideways, configurable threshold)
+Example response:
 
-Only the final assistant response reaches the user; internal logs go to stderr and only when `FORECAST_DEBUG=1`.
+```
+In short, the model expects Bitcoin to stay roughly stable next week, hovering near $63,228.
 
-## Files
+Bitcoin Forecast
 
-- `model_<topic>.pt` — trained PyTorch LSTM checkpoint per topic
-- `config_<topic>.json` — hyperparameters + validation metrics per topic
-- `data.py`, `train.py`, `predict.py`, `model.py` — data + training + inference core
-- `ask.py`, `response.py`, `response_formatter.py`, `prediction_engine.py`, `debug_logger.py` — the chat/response layer
-- `weather_cities.py` — city registry for location-specific weather models
+August 18-24, 2026
+
+The model forecasts relatively sideways movement for Bitcoin next week, with an
+estimated level around **$63,228**.
+
+Outlook: Sideways
+Predicted level (2026-08-24): ~$63,228
+Expected change: <0.01%
+Forecast range: <0.01%
+From latest observed value ($63,229, 2026-08-17): <0.01%
+
+This is a model-generated forecast, and actual market behavior may differ.
+```
 
 ## Weather for any city
 
-```bash
-export WEATHER_NAME='Chennai, India' WEATHER_LAT=13.0827 WEATHER_LON=80.2707
-python data.py --topic weather --refresh
-python train.py --topic weather
-python ask.py "predict weather in chennai tomorrow"
+```powershell
+$env:WEATHER_NAME='Chennai, India'; $env:WEATHER_LAT='13.0827'; $env:WEATHER_LON='80.2707'
+.\.venv\Scripts\python.exe data.py --topic weather --refresh
+.\.venv\Scripts\python.exe train.py --topic weather --epochs 150
+.\.venv\Scripts\python.exe ask.py "predict weather in chennai tomorrow"
 ```
 
-## Add a new domain
+## Train / refresh
 
-1. Add an entry to `TOPICS` in `data.py` (label, unit, asset)
-2. Add a fetcher returning `{source, series}` to `FETCHERS`
-3. Run `python train.py --topic <name>` — everything else is automatic
+```powershell
+.\run_all.ps1                        # everything (default topics)
+.\.venv\Scripts\python.exe multi.py  # all topics
+.\.venv\Scripts\python.exe train.py --topic sports
+.\.venv\Scripts\python.exe predict.py --topic ai --days 14
+```
 
-## License
+Outputs: `model_<topic>.pt`, `config_<topic>.json`, `prediction_<topic>.png`, `prediction_<topic>.txt`, `results.json`.
 
-MIT
+## Add a new domain
+
+1. Add an entry to `TOPICS` in `data.py` (label, unit, asset name)
+2. Add a fetcher returning `{source, series}` (date + value columns) to `FETCHERS`
+3. Run `python train.py --topic <name>` — everything else is automatic

config_weather.json

@@ -0,0 +1,18 @@
+{
+  "topic": "weather",
+  "topic_label": "Weather",
+  "unit": "K",
+  "source": "open-meteo:Chennai, India",
+  "lookback": 60,
+  "horizon_steps": 7,
+  "horizon_days": 7,
+  "hidden_size": 64,
+  "num_layers": 2,
+  "dropout": 0.1,
+  "val_mae": 0.9925612108358967,
+  "val_rel_mae": 0.0032603859435766935,
+  "val_h1_mape": 0.0018425700744697428,
+  "naive_baseline_mae": 1.0116436048493131,
+  "last_date": "2026-08-18",
+  "last_value": 303.25
+}

data.py

@@ -337,10 +337,7 @@ def set_weather_location(name: str, lat, lon):
 
 
 def artifact_suffix(topic: str) -> str:
-    """Per-domain variant suffix so different instances (e.g. cities) of the
-    same topic keep separate artifacts."""
-    if topic == "weather":
-        return f"_{weather_slug()}"
+    """Kept for compatibility; artifacts use plain `model_<topic>.pt` names."""
     return ""
 
 

model.py

@@ -2,6 +2,44 @@ import torch
 import torch.nn as nn
 
 
+class UnifiedForecaster(nn.Module):
+    """Single multi-task model for all domains: one shared LSTM backbone,
+    a per-domain embedding, and a per-domain output head."""
+
+    def __init__(self, num_domains, input_size=1, hidden_size=128, num_layers=2,
+                 dropout=0.1, horizon=7, embed_dim=16):
+        super().__init__()
+        self.horizon = horizon
+        self.num_domains = num_domains
+        self.domain_embed = nn.Embedding(num_domains, embed_dim)
+        self.lstm = nn.LSTM(
+            input_size=input_size + embed_dim,
+            hidden_size=hidden_size,
+            num_layers=num_layers,
+            batch_first=True,
+            dropout=dropout if num_layers > 1 else 0.0,
+        )
+        self.heads = nn.ModuleList([
+            nn.Sequential(
+                nn.Linear(hidden_size, hidden_size // 2),
+                nn.ReLU(),
+                nn.Dropout(dropout),
+                nn.Linear(hidden_size // 2, horizon),
+            )
+            for _ in range(num_domains)
+        ])
+
+    def forward(self, x, domain_ids):
+        emb = self.domain_embed(domain_ids).unsqueeze(1).expand(-1, x.size(1), -1)
+        out, _ = self.lstm(torch.cat([x, emb], dim=-1))
+        last = out[:, -1, :]
+        preds = torch.empty(x.size(0), self.horizon, device=x.device, dtype=last.dtype)
+        for d in torch.unique(domain_ids):
+            mask = domain_ids == d
+            preds[mask] = self.heads[int(d.item())](last[mask])
+        return preds
+
+
 class LSTMForecaster(nn.Module):
     def __init__(self, input_size=1, hidden_size=64, num_layers=2, dropout=0.1, horizon=7):
         super().__init__()

model_weather.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1c99536594bd56b91868633503b129d30d94eec7ac6eeab0e9c50569663e1b5b
+size 224939

predict.py

@@ -10,9 +10,11 @@ matplotlib.use("Agg")
 import matplotlib.pyplot as plt
 
 import data
-from model import LSTMForecaster
+from model import LSTMForecaster, UnifiedForecaster
 
 BASE_DIR = Path(__file__).resolve().parent
+UNIFIED_MODEL = BASE_DIR / "unified_model.pt"
+UNIFIED_CONFIG = BASE_DIR / "unified_config.json"
 
 
 def write_text_report(rows, cfg, topic):
@@ -52,13 +54,68 @@ def write_text_report(rows, cfg, topic):
     return txt_path
 
 
-def load_artifacts(topic, device="cpu"):
+def load_unified(device="cpu"):
+    """Load the single combined model that serves all topics."""
+    if not UNIFIED_MODEL.exists() or not UNIFIED_CONFIG.exists():
+        raise FileNotFoundError("Unified model not trained yet. Run: python train_unified.py")
+    ucfg = json.loads(UNIFIED_CONFIG.read_text())
+    model = UnifiedForecaster(
+        num_domains=ucfg["num_domains"],
+        hidden_size=ucfg["hidden_size"],
+        num_layers=ucfg["num_layers"],
+        dropout=ucfg["dropout"],
+        horizon=ucfg["horizon_steps"],
+        embed_dim=ucfg["embed_dim"],
+    ).to(device)
+    model.load_state_dict(torch.load(UNIFIED_MODEL, map_location=device))
+    model.eval()
+    return model, ucfg
+
+
+def load_topic_cfg(topic):
+    config_path = BASE_DIR / f"config_{topic}{data.artifact_suffix(topic)}.json"
+    if config_path.exists():
+        return json.loads(config_path.read_text())
+    return None
+
+
+def load_artifacts(topic, device="cpu", mode="auto"):
+    """mode: 'unified' -> single combined model; 'separate' -> per-topic LSTM;
+    'auto' -> unified when available, else per-topic."""
+    if mode in ("unified", "auto") and UNIFIED_MODEL.exists():
+        model, ucfg = load_unified(device)
+        cfg = load_topic_cfg(topic) or {}
+        topic_metrics = ucfg.get("metrics_per_topic", {}).get(topic, {})
+        meta = json.loads((BASE_DIR / "data" / f"{topic}.meta.json").read_text()) if (
+            BASE_DIR / "data" / f"{topic}.meta.json").exists() else {}
+        merged = {
+            "topic": topic,
+            "topic_label": data.TOPICS.get(topic, {}).get("label", topic),
+            "unit": data.TOPICS.get(topic, {}).get("unit", cfg.get("unit", "")),
+            "source": cfg.get("source", meta.get("source", "unified")),
+            "lookback": ucfg["lookback"],
+            "horizon_steps": ucfg["horizon_steps"],
+            "horizon_days": ucfg.get("horizon_days", 7),
+            "hidden_size": ucfg["hidden_size"],
+            "num_layers": ucfg["num_layers"],
+            "dropout": ucfg["dropout"],
+            "val_mae": topic_metrics.get("mae", cfg.get("val_mae", float("nan"))),
+            "val_rel_mae": topic_metrics.get("rel_mae", cfg.get("val_rel_mae", float("nan"))),
+            "val_h1_mape": topic_metrics.get("h1_mape", cfg.get("val_h1_mape", float("nan"))),
+            "naive_baseline_mae": topic_metrics.get("naive_mae", cfg.get("naive_baseline_mae", float("nan"))),
+            "last_date": cfg.get("last_date", meta.get("end", "")),
+            "last_value": cfg.get("last_value", float("nan")),
+            "engine": "unified",
+        }
+        return model, merged
+
     suffix = data.artifact_suffix(topic)
     model_path = BASE_DIR / f"model_{topic}{suffix}.pt"
     config_path = BASE_DIR / f"config_{topic}{suffix}.json"
     if not model_path.exists() or not config_path.exists():
         raise FileNotFoundError(f"Model for topic '{topic}' not trained yet. Run: python train.py --topic {topic}")
     cfg = json.loads(config_path.read_text())
+    cfg["engine"] = "separate"
     model = LSTMForecaster(
         hidden_size=cfg["hidden_size"],
         num_layers=cfg["num_layers"],
@@ -70,8 +127,19 @@ def load_artifacts(topic, device="cpu"):
     return model, cfg
 
 
-def predict(topic, days=None, device="cpu"):
-    model, cfg = load_artifacts(topic, device)
+def _run_step(model, rel, lb, topic, engine, device):
+    x = torch.from_numpy(rel[-lb:].astype(np.float32)).unsqueeze(0).unsqueeze(-1).to(device)
+    with torch.no_grad():
+        if engine == "unified":
+            ucfg = json.loads(UNIFIED_CONFIG.read_text())
+            did = torch.tensor([ucfg["domain_ids"][topic]], dtype=torch.int64, device=device)
+            return model(x, did).cpu().numpy().flatten()
+        return model(x).cpu().numpy().flatten()
+
+
+def predict(topic, days=None, device="cpu", mode="auto"):
+    model, cfg = load_artifacts(topic, device, mode=mode)
+    engine = cfg.get("engine", "separate")
     series = pd.read_csv(BASE_DIR / "data" / f"{topic}.csv")
     vals = series["value"].to_numpy(dtype=np.float64)
     lb = cfg["lookback"]
@@ -85,9 +153,7 @@ def predict(topic, days=None, device="cpu"):
     last_date = pd.Timestamp(cfg["last_date"])
     rows = []
     for step in range(n_steps):
-        x = torch.from_numpy(rel[-lb:].astype(np.float32)).unsqueeze(0).unsqueeze(-1).to(device)
-        with torch.no_grad():
-            pred_rel = model(x).cpu().numpy().flatten()
+        pred_rel = _run_step(model, rel, lb, topic, engine, device)
         cur_val = last_val * (1.0 + pred_rel[0])
         rel = np.concatenate([rel, pred_rel])
         rows.append({
@@ -124,11 +190,14 @@ def main():
     parser = argparse.ArgumentParser()
     parser.add_argument("--topic", default="finance", choices=list(data.TOPICS))
     parser.add_argument("--days", type=float, default=None, help="how many days ahead to predict")
+    parser.add_argument("--mode", default="auto", choices=["auto", "unified", "separate"],
+                        help="unified = the single combined model; separate = per-topic LSTMs")
     parser.add_argument("--device", default="cuda" if torch.cuda.is_available() else "cpu")
     args = parser.parse_args()
-    rows, cfg, chart_path, txt_path = predict(args.topic, days=args.days, device=args.device)
+    rows, cfg, chart_path, txt_path = predict(args.topic, days=args.days, device=args.device, mode=args.mode)
     unit = cfg.get("unit", "")
     print(f"Topic        : {cfg.get('topic_label', args.topic)} - {cfg['source']}")
+    print(f"Engine       : {cfg.get('engine', 'separate')} model")
     print(f"Last known   : {cfg['last_date']} = {cfg['last_value']:,.2f} {unit}")
     print(f"Validated on : MAE={cfg['val_mae']:,.2f}, rel MAE={cfg['val_rel_mae'] * 100:.2f}%, "
           f"H1 MAPE={cfg['val_h1_mape'] * 100:.2f}% (naive baseline MAE={cfg['naive_baseline_mae']:,.2f})")

train_unified.py

@@ -0,0 +1,187 @@
+"""Train ONE model for all domains (UnifiedForecaster).
+
+Loads every topic's dataset, builds normalized windows tagged with a domain
+id, and trains a shared LSTM backbone + per-domain heads jointly. Saves a
+single checkpoint used by predict.py (mode=unified).
+"""
+
+import argparse
+import json
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import torch
+import torch.nn as nn
+from torch.utils.data import DataLoader, TensorDataset
+
+import data
+from model import UnifiedForecaster
+
+BASE_DIR = Path(__file__).resolve().parent
+UNIFIED_MODEL = BASE_DIR / "unified_model.pt"
+UNIFIED_CONFIG = BASE_DIR / "unified_config.json"
+
+DOMAIN_ORDER = ["ai", "programming", "finance", "sports", "weather", "economy", "energy"]
+DOMAIN_IDS = {name: i for i, name in enumerate(DOMAIN_ORDER)}
+
+
+def build_windows(values, lookback, horizon):
+    xs, ys, bases = [], [], []
+    for i in range(lookback, len(values) - horizon):
+        base = values[i - 1]
+        if not np.isfinite(base) or base <= 0:
+            continue
+        xs.append(values[i - lookback:i] / base - 1.0)
+        ys.append(values[i:i + horizon] / base - 1.0)
+        bases.append(base)
+    return (np.array(xs, dtype=np.float32), np.array(ys, dtype=np.float32), np.array(bases, dtype=np.float64))
+
+
+def collect_all(topics, lookback, horizon, test_frac=0.2):
+    train_x, train_y, train_d = [], [], []
+    test_sets = {}
+    for topic in topics:
+        series, source = data.load(topic=topic, refresh=False)
+        vals = series["value"].to_numpy(dtype=np.float64)
+        x, y, b = build_windows(vals, lookback, horizon)
+        if len(x) == 0:
+            continue
+        n_test = max(horizon, int(len(x) * test_frac))
+        n_train = len(x) - n_test
+        did = DOMAIN_IDS[topic]
+        train_x.append(x[:n_train])
+        train_y.append(y[:n_train])
+        train_d.append(np.full(n_train, did, dtype=np.int64))
+        test_sets[topic] = (x[n_train:], y[n_train:], b[n_train:])
+        print(f"[unified] {topic:12s} train={n_train:6d} test={n_test:5d} ({source})")
+    X = np.concatenate(train_x)
+    Y = np.concatenate(train_y)
+    D = np.concatenate(train_d)
+    return X, Y, D, test_sets
+
+
+def evaluate_unified(model, loader, device):
+    model.eval()
+    preds, actuals, bases = [], [], []
+    with torch.no_grad():
+        for xb, yb, bb, db in loader:
+            preds.append(model(xb.to(device), db.to(device)).cpu().numpy())
+            actuals.append(yb.numpy())
+            bases.append(bb.numpy())
+    preds = np.concatenate(preds)
+    actuals = np.concatenate(actuals)
+    bases = np.concatenate(bases)[:, None]
+    pred_usd = bases * (1.0 + preds)
+    act_usd = bases * (1.0 + actuals)
+    mae = float(np.mean(np.abs(pred_usd - act_usd)))
+    rel_mae = float(np.mean(np.abs(preds - actuals)))
+    denom = np.where(act_usd[:, 0] == 0, 1e-9, act_usd[:, 0])
+    h1_mape = float(np.mean(np.abs((act_usd[:, 0] - pred_usd[:, 0]) / denom)))
+    naive_mae = float(np.mean(np.abs(act_usd - bases)))
+    return mae, rel_mae, h1_mape, naive_mae
+
+
+def train(topics=None, lookback=60, horizon=7, epochs=40, batch_size=256, lr=1e-3,
+          device="cpu", seed=0, hidden_size=128, num_layers=2, dropout=0.1, embed_dim=16,
+          patience=10):
+    torch.manual_seed(seed)
+    np.random.seed(seed)
+    topics = topics or DOMAIN_ORDER
+    X, Y, D, test_sets = collect_all(topics, lookback, horizon)
+    n_train = len(X)
+    if n_train < 100:
+        raise SystemExit("[unified] not enough training windows; run data.py --refresh for each topic first")
+
+    train_ds = TensorDataset(torch.from_numpy(X).unsqueeze(-1), torch.from_numpy(Y), torch.from_numpy(D))
+    train_loader = DataLoader(train_ds, batch_size=batch_size, shuffle=True)
+
+    test_by_topic = {}
+    for topic, (tx, ty, tb) in test_sets.items():
+        test_by_topic[topic] = DataLoader(
+            TensorDataset(torch.from_numpy(tx).unsqueeze(-1), torch.from_numpy(ty),
+                          torch.from_numpy(tb),
+                          torch.full((len(tx),), DOMAIN_IDS[topic], dtype=torch.int64)),
+            batch_size=512)
+
+    model = UnifiedForecaster(num_domains=len(DOMAIN_ORDER), hidden_size=hidden_size,
+                              num_layers=num_layers, dropout=dropout, horizon=horizon,
+                              embed_dim=embed_dim).to(device)
+    opt = torch.optim.AdamW(model.parameters(), lr=lr, weight_decay=1e-5)
+    sched = torch.optim.lr_scheduler.ReduceLROnPlateau(opt, patience=4, factor=0.5)
+    crit = nn.HuberLoss()
+
+    best_rel, best_state, seen = float("inf"), None, 0
+    for epoch in range(1, epochs + 1):
+        model.train()
+        total = 0.0
+        for xb, yb, db in train_loader:
+            opt.zero_grad()
+            loss = crit(model(xb.to(device), db.to(device)), yb.to(device))
+            loss.backward()
+            torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
+            opt.step()
+            total += float(loss.item()) * len(xb)
+
+        rels, h1s = [], []
+        for topic, loader in test_by_topic.items():
+            mae, rel_mae, h1_mape, naive = evaluate_unified(model, loader, device)
+            rels.append(rel_mae)
+            h1s.append(h1_mape)
+        val_rel = float(np.mean(rels))
+        val_h1 = float(np.mean(h1s))
+        sched.step(val_rel)
+        print(f"epoch {epoch:3d}/{epochs}  loss={total / n_train:.5f}  "
+              f"val_relMAE={val_rel * 100:.2f}%  avg_H1_MAPE={val_h1 * 100:.2f}%")
+        if val_rel < best_rel - 1e-6:
+            best_rel, seen = val_rel, 0
+            best_state = {k: v.detach().cpu().clone() for k, v in model.state_dict().items()}
+        else:
+            seen += 1
+            if seen >= patience:
+                print("[unified] early stopping")
+                break
+
+    if best_state is not None:
+        model.load_state_dict(best_state)
+
+    per_topic = {}
+    for topic, loader in test_by_topic.items():
+        mae, rel_mae, h1_mape, naive = evaluate_unified(model, loader, device)
+        per_topic[topic] = {"mae": mae, "rel_mae": rel_mae, "h1_mape": h1_mape, "naive_mae": naive}
+        print(f"[unified] {topic:12s} MAE={mae:,.2f}  relMAE={rel_mae * 100:.2f}%  "
+              f"H1_MAPE={h1_mape * 100:.2f}%  naive={naive:,.2f}")
+
+    torch.save(model.state_dict(), UNIFIED_MODEL)
+    cfg = {
+        "mode": "unified",
+        "num_domains": len(DOMAIN_ORDER),
+        "domain_order": DOMAIN_ORDER,
+        "domain_ids": DOMAIN_IDS,
+        "lookback": lookback,
+        "horizon_steps": horizon,
+        "horizon_days": horizon,
+        "hidden_size": hidden_size,
+        "num_layers": num_layers,
+        "dropout": dropout,
+        "embed_dim": embed_dim,
+        "n_train_windows": int(n_train),
+        "metrics_per_topic": per_topic,
+    }
+    UNIFIED_CONFIG.write_text(json.dumps(cfg, indent=2))
+    print(f"\n[unified] saved single model -> {UNIFIED_MODEL.name}, config -> {UNIFIED_CONFIG.name}")
+    return model, cfg
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--epochs", type=int, default=40)
+    parser.add_argument("--horizon", type=int, default=7)
+    parser.add_argument("--lookback", type=int, default=60)
+    parser.add_argument("--device", default="cuda" if torch.cuda.is_available() else "cpu")
+    args = parser.parse_args()
+    train(epochs=args.epochs, horizon=args.horizon, lookback=args.lookback, device=args.device)
+
+
+if __name__ == "__main__":
+    main()

unified_config.json

@@ -0,0 +1,74 @@
+{
+  "mode": "unified",
+  "num_domains": 7,
+  "domain_order": [
+    "ai",
+    "programming",
+    "finance",
+    "sports",
+    "weather",
+    "economy",
+    "energy"
+  ],
+  "domain_ids": {
+    "ai": 0,
+    "programming": 1,
+    "finance": 2,
+    "sports": 3,
+    "weather": 4,
+    "economy": 5,
+    "energy": 6
+  },
+  "lookback": 60,
+  "horizon_steps": 7,
+  "horizon_days": 7,
+  "hidden_size": 128,
+  "num_layers": 2,
+  "dropout": 0.1,
+  "embed_dim": 16,
+  "n_train_windows": 31735,
+  "metrics_per_topic": {
+    "ai": {
+      "mae": 3.4010714403826725,
+      "rel_mae": 0.046488404273986816,
+      "h1_mape": 0.023641787109347494,
+      "naive_mae": 3.4285758835207747
+    },
+    "programming": {
+      "mae": 1135964.0941619105,
+      "rel_mae": 0.058158028870821,
+      "h1_mape": 0.054231874000870206,
+      "naive_mae": 5238840.46007266
+    },
+    "finance": {
+      "mae": 2863.447612711464,
+      "rel_mae": 0.03436192125082016,
+      "h1_mape": 0.017374594652497116,
+      "naive_mae": 2704.601283383124
+    },
+    "sports": {
+      "mae": 2.7536647755605217,
+      "rel_mae": 0.0012617451138794422,
+      "h1_mape": 0.0003771134174271423,
+      "naive_mae": 2.502011465506802
+    },
+    "weather": {
+      "mae": 0.9439951772615057,
+      "rel_mae": 0.003122166031971574,
+      "h1_mape": 0.0017910992340668128,
+      "naive_mae": 0.9435578352786341
+    },
+    "economy": {
+      "mae": 72.2052313993689,
+      "rel_mae": 0.014413672499358654,
+      "h1_mape": 0.007524061656098242,
+      "naive_mae": 73.12155254020708
+    },
+    "energy": {
+      "mae": 2.9286401717398816,
+      "rel_mae": 0.03628615289926529,
+      "h1_mape": 0.018979403445247508,
+      "naive_mae": 2.9195108923456288
+    }
+  }
+}

unified_model.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6eadd67d78c1019664062377451681c04815c0878c32e95de3532b216802a9ec
+size 1086390