AlecAlameddine's picture
Upload 105 files
d79a78d verified
Raw History Blame Contribute Delete
9.03 kB
"""Refit the selected models on all data up to 2018 and write submission.csv.
Reads reports/backtest/selected.json (written by the backtest: the model of each metric),
forecasts 2019-2025 for the 210 cities, validates the file with the Space's own checks,
and writes plausibility reports to reports/forecast/.
Run: PYTHONPATH=code python -m protostar.forecast
"""
import json
import numpy as np
import pandas as pd
from .common import FORECAST_YEARS, METRICS, N_CITIES, REPORTS, ROOT, TRAIN_END, UNITS
from .data import assert_no_leak, cities, load_annual, long_table, panels
from .common import BASELINE_WINDOW, MIN_VALID_YEARS
from .models import last_valid_mean, neighbor_order, predict, window_mean
OUT = REPORTS / "forecast"
COLUMNS = ["city_id", "year", "metric", "predicted_value"]
DECIMALS = {"annual_avg_temp": 2, "total_precip_in": 2, "hottest_day_temp": 2, "cdd": 1}
RANGE_FACTOR = 1.5 # flag forecasts outside the 1989-2018 [min, max] widened to 1.5x its width
def check_forecasts(df: pd.DataFrame, city_ids: set[str]) -> list[str]:
"""The checks of the challenge Space (utils.check_forecasts); [] if the file can be scored."""
if list(df.columns) != COLUMNS:
return [f"columns must be exactly {COLUMNS}"]
problems = []
year = pd.to_numeric(df["year"], errors="coerce")
value = pd.to_numeric(df["predicted_value"], errors="coerce")
for mask, what in ((~df["city_id"].isin(city_ids), "unknown city_id"),
(~year.isin(set(FORECAST_YEARS)), "year outside 2019-2025"),
(~df["metric"].isin(set(METRICS)), "unknown metric"),
(value.isna() | value.abs().eq(float("inf")), "missing or non-numeric predicted_value"),
(df.duplicated(["city_id", "year", "metric"]), "duplicate rows")):
if mask.any():
problems.append(f"{int(mask.sum())} rows: {what}")
expected = len(city_ids) * len(FORECAST_YEARS) * len(METRICS)
if not problems and len(df) != expected:
problems.append(f"{len(df)} rows; expected {expected}")
return problems
def main():
OUT.mkdir(parents=True, exist_ok=True)
annual = load_annual()
long = long_table(annual)
assert_no_leak(long["year"], "training table") # the data rule, enforced
P = panels(long)
assert all(p.origin == TRAIN_END for p in P.values())
geo = cities(annual)
ids = P["cdd"].city_ids
assert list(geo["city_id"]) == list(ids) and len(ids) == N_CITIES
order = neighbor_order(geo["lat"].to_numpy(), geo["lon"].to_numpy())
choice = json.loads((REPORTS / "backtest" / "selected.json").read_text())
assert all(choice["gate_beats_both_baselines_on_both_selection_folds"].values()), \
"the backtest gate failed: no forecast from an ungated selection"
selected = choice["selected"]
years = np.array(FORECAST_YEARS)
frames, summary, notes = [], [], []
for metric in METRICS:
pred = predict(selected[metric], P, metric, order, years)
unfitted = ~np.isfinite(predict(selected[metric], P, metric, order, years, fill=False)).all(axis=1)
no_baseline = ~np.isfinite(window_mean(P[metric], BASELINE_WINDOW, MIN_VALID_YEARS))
assert (unfitted == no_baseline).all(), "the fallback must only serve city-metrics without a baseline"
for i in np.flatnonzero(unfitted):
notes.append(f"{ids[i]} ({geo['name'].iloc[i]}) `{metric}`: no baseline (fewer than {MIN_VALID_YEARS} valid "
f"years in 1989-2018, not scored); neighbor-anomaly fallback, forecast "
f"{pred[i, 0]:.2f} .. {pred[i, -1]:.2f}")
missing = ~np.isfinite(pred).all(axis=1)
if missing.any(): # a city with no valid year at all for this metric: mean of its 8 nearest cities
for i in np.flatnonzero(missing):
near = [j for j in order[i] if not missing[j]][:8]
pred[i] = pred[near].mean(axis=0)
notes.append(f"{ids[i]} {metric}: no valid year in the record; mean of the 8 nearest cities")
pred = np.round(pred, DECIMALS[metric])
frames.append(pd.DataFrame({"city_id": np.repeat(ids, len(years)), "year": np.tile(years, len(ids)),
"metric": metric, "predicted_value": pred.ravel()}))
# plausibility against the city's own 1989-2018 valid years
hist = P[metric].y[:, -30:]
n_valid = np.isfinite(hist).sum(axis=1)
lo, hi = np.nanmin(np.where(np.isfinite(hist), hist, np.inf), axis=1), \
np.nanmax(np.where(np.isfinite(hist), hist, -np.inf), axis=1)
lo, hi = np.where(n_valid > 0, lo, np.nan), np.where(n_valid > 0, hi, np.nan)
mid, half = (lo + hi) / 2, (hi - lo) / 2
summary.append(pd.DataFrame({
"city_id": ids, "name": geo["name"].to_numpy(), "lat": geo["lat"].to_numpy(),
"lon": geo["lon"].to_numpy(), "metric": metric,
"n_valid_1989_2018": n_valid, "min_1989_2018": lo, "max_1989_2018": hi,
"mean_1989_2018": window_mean(P[metric], 30, 1), "mean_last10_valid": last_valid_mean(P[metric], 10),
"forecast_2019": pred[:, 0], "forecast_2025": pred[:, -1], "forecast_mean_2019_2025": pred.mean(axis=1),
"outside_hist_range": (pred.min(axis=1) < lo) | (pred.max(axis=1) > hi),
"outside_1p5x_range": np.abs(pred - mid[:, None]).max(axis=1) > RANGE_FACTOR * half,
}))
sub = pd.concat(frames, ignore_index=True)
sub["metric"] = pd.Categorical(sub["metric"], categories=list(METRICS), ordered=True)
sub = sub.sort_values(["city_id", "year", "metric"]).reset_index(drop=True)
sub["metric"] = sub["metric"].astype(str)
sub = sub[COLUMNS]
problems = check_forecasts(sub, set(ids))
assert not problems, problems
assert len(sub) == N_CITIES * len(FORECAST_YEARS) * len(METRICS) == 5880
assert np.isfinite(sub["predicted_value"]).all()
assert (sub.loc[sub["metric"].isin(["cdd", "total_precip_in"]), "predicted_value"] >= 0).all()
sub.to_csv(ROOT / "submission.csv", index=False)
s = pd.concat(summary, ignore_index=True)
s["change_vs_1989_2018"] = s["forecast_mean_2019_2025"] - s["mean_1989_2018"]
s["change_pct"] = 100 * s["change_vs_1989_2018"] / s["mean_1989_2018"].where(s["mean_1989_2018"].abs() > 1e-9)
s.to_csv(OUT / "forecast_summary.csv", index=False)
flagged = s[s["outside_1p5x_range"] | (s["n_valid_1989_2018"] < 10)]
lines = ["# Forecast validation", "",
"Generated by `python -m protostar.forecast` (do not edit).", "",
f"- Rows: {len(sub)} = {N_CITIES} cities x {len(FORECAST_YEARS)} years x {len(METRICS)} metrics; "
"no missing, non-finite or duplicate values; the Space's `check_forecasts` rules pass.",
f"- Training data: years <= {TRAIN_END} only (asserted in code).",
f"- Models: " + "; ".join(f"`{m}`: {json.dumps(selected[m])}" for m in METRICS), "",
"## Plausibility against each city's own 1989-2018 valid years", "",
"City-metrics with a baseline only (the 9 without one are listed below; they are not scored).", "",
"| metric | forecasts outside the historical [min, max] | outside that interval widened to 1.5x | "
"median change vs 1989-2018 mean | min change | max change |", "|---|---|---|---|---|---|"]
for metric in METRICS:
g = s[(s["metric"] == metric) & (s["n_valid_1989_2018"] >= MIN_VALID_YEARS)] # city-metrics with a baseline
ch = g["change_vs_1989_2018"]
lines.append(f"| `{metric}` ({UNITS[metric]}) | {int(g['outside_hist_range'].sum())} cities | "
f"{int(g['outside_1p5x_range'].sum())} cities | {ch.median():+.2f} | {ch.min():+.2f} | {ch.max():+.2f} |")
lines += ["", "## Flagged city-metrics (outside the 1.5x interval, or fewer than 10 valid years in 1989-2018)", ""]
if len(flagged):
cols = ["city_id", "name", "metric", "n_valid_1989_2018", "min_1989_2018", "max_1989_2018",
"mean_last10_valid", "forecast_2019", "forecast_2025", "outside_1p5x_range"]
lines += ["| " + " | ".join(cols) + " |", "|" + "---|" * len(cols)]
for _, r in flagged[cols].iterrows():
lines.append("| " + " | ".join(f"{v:.2f}" if isinstance(v, float) else str(v) for v in r) + " |")
else:
lines.append("None.")
lines += ["", "## Fallbacks used", "",
"City-metrics without a baseline cannot be fitted; `models.fallback` gives them the mean of their "
"last 10 valid years plus the change their 8 nearest fitted cities forecast relative to the same years.",
""] + ([f"- {n}" for n in notes] or ["None."])
(OUT / "VALIDATION.md").write_text("\n".join(lines) + "\n")
print("\n".join(lines[:22]))
print(f"\nwrote {ROOT / 'submission.csv'} ({len(sub)} rows); flagged city-metrics: {len(flagged)}")
if __name__ == "__main__":
main()