Blame for code/baseline.py

"""Forecasts for the Protostar Climate Risk challenge.

Runs the three official reference baselines (last value, 30-year average,
30-year linear trend) plus two added methods, backtests them at several
cutoff years (all using data <= 2018 only), picks the best per metric, and
fills submission.csv.

Added methods:
  pooled  (temperature, CDD): one warming line fitted to the average anomaly of
          all cities, added to each city's 30-year mean. For CDD the shift is
          scaled by the city's own CDD-per-degree sensitivity.
  pooledNN / pooled25 / pooled50: variants with a shorter baseline window (NN
          years) or some weight on each city's own slope.
  medNN, avgNN (precipitation, hottest day): median or mean of the last NN years.
Method choice uses backtests on data <= 2018 only, never leaderboard scores.

Usage (from the dataset root):
    python code/baseline.py            # validate, then write submission.csv
    python code/baseline.py --validate # validation table only

Data rule: uses only the challenge dataset (records up to 2018-12-31).
"""
import argparse
from pathlib import Path

import numpy as np
import pandas as pd

REPO = "CMU-OSPO/protostar-climate-train-to-2018"
ROOT = Path(__file__).resolve().parent.parent
SUBMISSION = ROOT / "submission.csv"

# metric code -> column in annual_indices
METRICS = {
    "annual_avg_temp": "Avg Temp",
    "total_precip_in": "ToT Prcp",
    "hottest_day_temp": "Max Tmax",
    "cdd": "cdd",
}
# pooled variants: name -> (baseline window in years, weight on the city's own slope)
POOLED = {"pooled": (30, 0.0), "pooled25": (30, 0.25), "pooled50": (30, 0.5),
          "pooled20": (20, 0.0), "pooled15": (15, 0.0), "pooled10": (10, 0.0)}
# ensembles: name -> component methods, averaged with equal weight
_ENS_WARM = {"ensP": ("pooled", "pooled20", "pooled15", "pooled10"),
             "ensPT": ("pooled", "pooled10", "trend30", "avg10")}
_ENS_FLAT = {"ensA": ("avg30", "med30", "avg15", "avg10"),
             "ensB": ("avg20", "avg10", "med15")}
ENSEMBLES = {"annual_avg_temp": _ENS_WARM, "cdd": _ENS_WARM,
             "total_precip_in": _ENS_FLAT, "hottest_day_temp": _ENS_FLAT}
# methods tried per metric
_BASIC = ("last", "avg30", "trend30")
METHODS = {
    "annual_avg_temp": _BASIC + tuple(POOLED) + tuple(_ENS_WARM),
    "cdd": _BASIC + tuple(POOLED) + tuple(_ENS_WARM),
    "total_precip_in": _BASIC + ("med30", "avg20", "avg15", "avg10", "med15") + tuple(_ENS_FLAT),
    "hottest_day_temp": _BASIC + ("med30", "avg20", "avg15", "avg10", "med15") + tuple(_ENS_FLAT),
}
# departure persistence: name -> (base method, strength). The base forecast plus a faded copy of the city's
# latest departure from the national warming line (see persistence_adjust).
PERSIST = {"pooled15p": ("pooled15", 1.0), "pooled15h": ("pooled15", 0.5),
           "ensPp": ("ensP", 1.0), "ensPh": ("ensP", 0.5)}
for _m in ("annual_avg_temp", "cdd"):
    METHODS[_m] = METHODS[_m] + tuple(PERSIST)
COL_TO_CODE = {v: k for k, v in METRICS.items()}
# geography-shrunk trend: name -> (fit window in years, shrinkage k toward the geography slope)
GEO_METHODS = {"geo30": (30, 0.5), "geo40": (40, 0.5), "geo50": (50, 0.5), "geo30k8": (30, 0.8)}
for _m in METHODS:
    METHODS[_m] = METHODS[_m] + tuple(GEO_METHODS)
GEO_FEATURES = ROOT / "data" / "city_features.csv"


def geo_matrix():
    g = pd.read_csv(GEO_FEATURES).set_index("ID")
    return pd.DataFrame({
        "elev": g["elevation_m"] / 1000,
        "w_coast": g["w_coast"], "w_gulf": g["w_gulf_stream"], "w_calif": g["w_calif_current"],
        "lat": (g["Lat"] - g["Lat"].mean()) / g["Lat"].std(),
        "lon": (g["Lon"] - g["Lon"].mean()) / g["Lon"].std(),
    })


def predict_geo(df, last_year, years, col, window, k, lam=1.0):
    """Each city's trend, shrunk toward the slope predicted from its geography
    (ridge regression across cities on elevation, coast and ocean-current features)."""
    G = geo_matrix()
    fits = {}
    for city, g in df[(df["Year"] <= last_year) & (df["Year"] > last_year - window)].groupby("ID"):
        g = g[["Year", col]].dropna()
        if len(g) >= 10 and city in G.index:
            slope = np.polyfit(g["Year"], g[col], 1)[0]
            fits[city] = (slope, g[col].mean(), g["Year"].mean())
    s = pd.DataFrame(fits, index=["slope", "mean", "xm"]).T
    X = np.c_[np.ones(len(s)), G.loc[s.index].values]
    beta = np.linalg.solve(X.T @ X + lam * np.eye(X.shape[1]), X.T @ s["slope"].values)
    s["geo_slope"] = X @ beta
    yrs = np.asarray(years)
    out = []
    for city in df[df["Year"] <= last_year]["ID"].unique():
        if city in s.index:
            r = s.loc[city]
            sl = (1 - k) * r["slope"] + k * r["geo_slope"]
            p = r["mean"] + sl * (yrs - r["xm"])
            if col in ("cdd", "ToT Prcp"):
                p = np.maximum(p, 0)
        else:  # too little history: fall back to the 30-year average
            h = df[(df["ID"] == city) & (df["Year"] <= last_year)].set_index("Year")[col]
            p = forecast(h, last_year, years, "avg30").values
        out.append(pd.DataFrame({"ID": city, "Year": years, "pred": p}))
    return pd.concat(out, ignore_index=True)
WINDOW = 30
TREND_WINDOW = 40  # years used to fit the pooled warming line
HORIZON = 7
ORIGINS = (1996, 2000, 2004, 2008, 2011)  # backtest cutoffs; each predicts the next 7 years
MAX_MISSING_DAYS = 10


CURATED = ROOT / "data" / "annual_valid.csv"


def load_annual():
    """Read the curated table in data/; build it from the challenge dataset if missing."""
    if CURATED.exists():
        df = pd.read_csv(CURATED)
    else:
        from datasets import load_dataset  # only needed when the curated table is missing
        df = load_dataset(REPO, "annual_indices", split="train").to_pandas()
        df = df.replace([np.inf, -np.inf], np.nan)  # Max Tmax is -inf in empty years
        miss_cols = [c for c in df.columns if c.startswith("Miss")]
        if miss_cols:  # drop badly incomplete years, as the scorer does
            df = df[df[miss_cols].max(axis=1) <= MAX_MISSING_DAYS]
        CURATED.parent.mkdir(exist_ok=True)
        df.to_csv(CURATED, index=False)
        print(f"Saved curated data to {CURATED}")
    assert df["Year"].max() <= 2018, "Weather input dated after 2018: data rule"
    return df


def national_shift(df, last_year, years, window=WINDOW):
    """Warming (deg F) expected in `years` relative to the 30-year baseline mean."""
    d = df[(df["Year"] <= last_year) & (df["Year"] > last_year - TREND_WINDOW)]
    temp = d.pivot_table(index="Year", columns="ID", values="Avg Temp")
    anomaly = (temp - temp.mean()).mean(axis=1).dropna()
    slope, intercept = np.polyfit(anomaly.index.values, anomaly.values, 1)
    base_years = np.arange(last_year - window + 1, last_year + 1)
    ref = (intercept + slope * base_years).mean()
    return pd.Series(intercept + slope * np.asarray(years) - ref, index=years), slope


def city_slopes(df, last_year):
    """Each city's own warming slope (deg F per year) over the trend window."""
    d = df[(df["Year"] <= last_year) & (df["Year"] > last_year - TREND_WINDOW)]
    out = {}
    for city, g in d.groupby("ID"):
        g = g[["Year", "Avg Temp"]].dropna()
        out[city] = np.polyfit(g["Year"], g["Avg Temp"], 1)[0] if len(g) >= 20 else np.nan
    return pd.Series(out)


def cdd_sensitivity(df, last_year):
    """CDD change per deg F of annual average temperature, per city."""
    d = df[(df["Year"] <= last_year) & (df["Year"] > last_year - TREND_WINDOW)]
    out = {}
    for city, g in d.groupby("ID"):
        g = g[["Avg Temp", "cdd"]].dropna()
        out[city] = np.polyfit(g["Avg Temp"], g["cdd"], 1)[0] if len(g) >= 15 else np.nan
    s = pd.Series(out)
    return s.fillna(s.median())


def forecast(series: pd.Series, last_year: int, years, method: str,
             shift=None, sens=1.0, clip=False, window=WINDOW):
    """series: values indexed by Year, already cut at last_year."""
    full = series.dropna()
    if method[:3] in ("avg", "med") and method[3:].isdigit():
        window = int(method[3:])  # e.g. avg15 = mean of the last 15 years
    hist = full[full.index > last_year - window]
    if hist.empty:
        return pd.Series(np.nan, index=years)
    if method == "last":
        return pd.Series(hist.iloc[-1], index=years)
    if method.startswith("avg"):
        return pd.Series(hist.mean(), index=years)
    if method.startswith("med"):
        return pd.Series(hist.median(), index=years)
    if method == "pooled":
        p = hist.mean() + sens * shift.reindex(years).values
        return pd.Series(np.maximum(p, 0) if clip else p, index=years)
    if method == "trend30":
        hist = full[full.index > last_year - WINDOW]
        if len(hist) < 10:
            return pd.Series(hist.mean(), index=years)
        slope, intercept = np.polyfit(hist.index.values, hist.values, 1)
        return pd.Series(intercept + slope * np.asarray(years), index=years)
    raise ValueError(method)


def _dist_300km(ids):
    """0/1 matrix: which cities lie within 300 km of each other (self included)."""
    g = pd.read_csv(GEO_FEATURES).set_index("ID")
    W = np.eye(len(ids))
    known = [i for i, c in enumerate(ids) if c in g.index]
    lat = np.radians(g.loc[[ids[i] for i in known], "Lat"].values)
    lon = np.radians(g.loc[[ids[i] for i in known], "Lon"].values)
    a = np.sin((lat[:, None] - lat[None]) / 2) ** 2 + np.cos(lat)[:, None] * np.cos(lat)[None] * np.sin((lon[:, None] - lon[None]) / 2) ** 2
    near = (2 * 6371.0 * np.arcsin(np.sqrt(a)) < 300).astype(float)
    W[np.ix_(known, known)] = near
    return W


def persistence_adjust(df, last_year, years, col, gamma):
    """Faded carry-over of each city's latest temperature departure (deg F, or CDD via sensitivity).

    Departure = observed temperature minus (city mean + national warming line), split into a regional part
    (mean of cities within 300 km) and a local remainder. Each part decays by its own year-to-year persistence,
    estimated across all cities from data up to `last_year`. Idea from a public submission's README
    (two-scale decay of the recent temperature departure); implemented and backtested here from scratch.
    """
    d = df[(df["Year"] <= last_year) & (df["Year"] > last_year - TREND_WINDOW)]
    temp = d.pivot_table(index="Year", columns="ID", values="Avg Temp")
    anom = temp - temp.mean()
    nat = anom.mean(axis=1).dropna()
    slope, icpt = np.polyfit(nat.index.values, nat.values, 1)
    E = (anom.sub(icpt + slope * temp.index.values, axis=0)).values
    ok = ~np.isnan(E)
    W = _dist_300km(list(temp.columns))
    reg = (np.nan_to_num(E) @ W.T) / np.maximum(ok.astype(float) @ W.T, 1)
    loc = E - reg

    def phi(Z):
        z0, z1 = np.nan_to_num(Z[:-1]), np.nan_to_num(Z[1:])
        return float(np.clip((z0 * z1).sum() / max((z0 ** 2).sum(), 1e-9), 0, 0.9))

    p_reg, p_loc = phi(reg), phi(loc)
    last = temp.index[-1] == last_year
    r_reg = reg[-1] if last else np.zeros(E.shape[1])
    r_loc = np.nan_to_num(loc[-1]) if last else np.zeros(E.shape[1])
    sens = cdd_sensitivity(df, last_year) if col == "cdd" else None
    rows = []
    for j, city in enumerate(temp.columns):
        k = 1.0 if sens is None else sens.get(city, sens.median())
        for y in years:
            h = y - last_year
            rows.append((city, y, gamma * k * (r_reg[j] * p_reg ** h + r_loc[j] * p_loc ** h)))
    return pd.DataFrame(rows, columns=["ID", "Year", "adj"])


def predict_all(df, last_year, years, method, col):
    if method in PERSIST:  # base forecast + faded departure
        base, gamma = PERSIST[method]
        p = predict_all(df, last_year, years, base, col).merge(
            persistence_adjust(df, last_year, years, col, gamma), on=["ID", "Year"], how="left")
        p["pred"] = p["pred"] + p["adj"].fillna(0.0)
        if col == "cdd":
            p["pred"] = p["pred"].clip(lower=0)
        return p[["ID", "Year", "pred"]]
    ens = ENSEMBLES[COL_TO_CODE[col]].get(method)
    if ens:  # equal-weight average of the component forecasts
        parts = [predict_all(df, last_year, years, m, col).set_index(["ID", "Year"])["pred"]
                 for m in ens]
        return pd.concat(parts, axis=1).mean(axis=1).rename("pred").reset_index()
    if method in GEO_METHODS:
        return predict_geo(df, last_year, years, col, *GEO_METHODS[method])
    pooled = method in POOLED
    if pooled:
        window, w = POOLED[method]
        shift, nat_slope = national_shift(df, last_year, years, window)
        dev = (city_slopes(df, last_year) - nat_slope).fillna(0.0)
        sens = None if col == "Avg Temp" else cdd_sensitivity(df, last_year)
        t = np.asarray(years) - (last_year - (window - 1) / 2)
    out = []
    for city, g in df[df["Year"] <= last_year].groupby("ID"):
        s = g.set_index("Year")[col]
        if pooled:
            # national warming line, nudged toward the city's own slope
            city_shift = shift + w * dev.get(city, 0.0) * t
            k = 1.0 if sens is None else sens.get(city, sens.median())
            p = forecast(s, last_year, years, "pooled", shift=city_shift,
                         sens=k, clip=col == "cdd", window=window)
        else:
            p = forecast(s, last_year, years, method)
        out.append(pd.DataFrame({"ID": city, "Year": years, "pred": p.values}))
    return pd.concat(out, ignore_index=True)


def validate(df):
    """Mean skill vs the 30-year average over several cutoffs (higher is better)."""
    skill = {}
    for code, col in METRICS.items():
        for origin in ORIGINS:
            years = list(range(origin + 1, min(origin + HORIZON, 2018) + 1))
            actual = df[df["Year"].isin(years)][["ID", "Year", col]]
            mae = {}
            for method in METHODS[code]:
                pred = predict_all(df, origin, years, method, col)
                m = actual.merge(pred, on=["ID", "Year"]).dropna()
                mae[method] = (m[col] - m["pred"]).abs().mean()
            for method, v in mae.items():
                skill.setdefault((code, method), []).append(1 - v / mae["avg30"])
    table = pd.Series({k: np.mean(v) for k, v in skill.items()}).unstack()
    pd.set_option("display.width", 250)
    pd.set_option("display.max_columns", None)
    print(f"Backtest skill vs 30-year average (mean over cutoffs {ORIGINS}):")
    print(table.round(3))
    best = table.idxmax(axis=1).to_dict()
    print("Chosen:", best, "| mean skill x100:",
          round(100 * np.mean([table.loc[c, best[c]] for c in best]), 1))
    return best


def write_submission(df, best):
    sub = pd.read_csv(SUBMISSION)  # template: city_id, year, metric, predicted_value
    years = sorted(sub["year"].unique())
    preds = []
    for code, col in METRICS.items():
        p = predict_all(df, 2018, years, best[code], col)
        p["metric"] = code
        preds.append(p)
    preds = pd.concat(preds).rename(columns={"ID": "city_id", "Year": "year"})
    sub = sub.drop(columns="predicted_value").merge(
        preds, on=["city_id", "year", "metric"], how="left")
    missing = sub["pred"].isna().sum()
    if missing:
        print(f"Warning: {missing} rows had no history; filled with metric median")
        sub["pred"] = sub["pred"].fillna(sub.groupby("metric")["pred"].transform("median"))
    sub = sub.rename(columns={"pred": "predicted_value"})
    sub.to_csv(SUBMISSION, index=False)
    print(f"Wrote {SUBMISSION} ({len(sub)} rows). Methods used: {best}")


if __name__ == "__main__":
    ap = argparse.ArgumentParser()
    ap.add_argument("--validate", action="store_true")
    args = ap.parse_args()
    np.random.seed(42)
    data = load_annual()
    best = validate(data)
    if not args.validate:
        write_submission(data, best)