Download code/policy_check.py from Jessiter/Unicorns_final_submission: direct link, hf CLI and curl.
- Browser
- Download file 19.4 kB
-
https://huggingface.co/datasets/Jessiter/Unicorns_final_submission/resolve/main/code/policy_check.py
- Command line
-
hf download hf://datasets/Jessiter/Unicorns_final_submission/code/policy_check.py
-
curl -L -o policy_check.py https://huggingface.co/datasets/Jessiter/Unicorns_final_submission/resolve/main/code/policy_check.py
19.4 kB
| """Policy heuristic check: are older small mixed-use / small multifamily buildings in cities whose heat has moved | |
| past their design assumptions, and are they left out of the rules? (analysis only, not a forecast) | |
| Thesis, split into three claims per city (thresholds fixed in CONFIG and written to config.json BEFORE any result): | |
| H1 hazard : 2019-2025 heat has moved past the 1976-2005 design baseline | |
| H2 exposure : the city's county has an above-median share of older small multifamily housing (ACS proxy) | |
| H3 policy : no in-force (by 2025) rental cooling rule that covers small mixed-use buildings | |
| Supported if at least CONFIG["support_min_share"] of cities have all three. | |
| Weather input: by default the OBSERVED 2019-2025 NOAA data (obs_2018_2021.csv + obs_2021_2025.csv, user-approved | |
| stand-in, analysis only). Swap in the forecast with --weather submission.csv (same columns). | |
| Run from the repo root (after python code/census_acs.py and python code/policy_case_studies.py): | |
| python code/policy_check.py [--weather FILE] | |
| Outputs: outputs/policy_check/ (config.json first, then weather_input.csv, station_county.csv, city_flags.csv, | |
| sensitivity.csv, thesis_check.md, charts/flags_map.png) | |
| """ | |
| import argparse | |
| import calendar | |
| import concurrent.futures as cf | |
| import json | |
| import sys | |
| import urllib.request | |
| from datetime import datetime, timezone | |
| from pathlib import Path | |
| import numpy as np | |
| import pandas as pd | |
| sys.path.insert(0, str(Path(__file__).resolve().parent)) | |
| from shared import METRICS, load_train, valid_flags | |
| ROOT = Path(__file__).resolve().parent.parent | |
| OUT = ROOT / "outputs" / "policy_check" | |
| OBS_FILES = [ROOT / "obs_2018_2021.csv", ROOT / "obs_2021_2025.csv"] | |
| YEARS = list(range(2019, 2026)) | |
| CONFIG = { | |
| "baseline_years": [1976, 2005], # roughly the TMY3 period buildings were designed with | |
| "baseline_min_valid_years": 15, | |
| "weather_years": [2019, 2025], | |
| "weather_min_valid_years": 4, | |
| "max_missing_days": 10, # same validity rule as the challenge | |
| "indoor_limit_F": 80, # main indoor heat limit (Phoenix 82, Montgomery Co. MD 80, NYC 78) | |
| "indoor_limit_sensitivity_F": [78, 80, 82], | |
| "h1_cdd_increase_min": 0.10, # cdd at least 10% above baseline ... | |
| "h1_hottest_increase_min_F": 2.0, # ... AND hottest day at least 2 F above baseline | |
| "h1_shortfall_min": 0.10, # OR cooling capacity shortfall at least 10% | |
| "shortfall_min_design_gap_F": 5.0, # shortfall not computed if baseline hottest day < indoor limit + 5 F | |
| "h2_rule": "exposure = share of units in 2-19 unit buildings x share of units built before 1980 (county); " | |
| "flag if >= median across the cities", | |
| "h3_rule": "gap unless data/policy_rules.csv lists an in_force cooling rule with covers_small_mixed_use yes/partial", | |
| "support_min_share": 0.20, # thesis supported if >= 20% of cities have H1, H2 and H3 | |
| "shortfall_formula": "(T_hot_new - T_in) / (T_hot_design - T_in) - 1; steady-state, ignores sun, people, " | |
| "equipment and humidity", | |
| } | |
| # ------------------------------------------------------------------ weather | |
| def observed_weather(): | |
| """Observed 2019-2025 annual metrics in submission schema (city_id, year, metric, predicted_value), valid years only.""" | |
| obs = pd.concat([pd.read_csv(f) for f in OBS_FILES]).drop_duplicates(["ID", "DATE"]) | |
| obs = obs[obs.DATE.str[:4].astype(int).between(YEARS[0], YEARS[-1])].copy() | |
| obs["year"] = obs.DATE.str[:4].astype(int) | |
| f = lambda v: v / 10 * 9 / 5 + 32 # tenths of degC -> F (as code/truth.py) | |
| obs["tmax"], obs["tmin"] = f(obs.TMAX), f(obs.TMIN) | |
| obs["tavg"] = (obs.tmax + obs.tmin) / 2 | |
| obs["cddd"] = np.maximum(0, obs.tavg - 65) | |
| obs["prcp"] = obs.PRCP / 254.0 | |
| g = obs.groupby(["ID", "year"]) | |
| a = pd.DataFrame({"avg": g.tavg.mean(), "hot": g.tmax.max().round(), "cdd": g.cddd.sum(), "prcp": g.prcp.sum(), | |
| "n_tmax": g.tmax.count(), "n_tmin": g.tmin.count(), "n_both": g.tavg.count(), | |
| "n_prcp": g.prcp.count()}).reset_index() | |
| days = a.year.map(lambda y: 366 if calendar.isleap(y) else 365) | |
| lim = CONFIG["max_missing_days"] | |
| ok = {"annual_avg_temp": (days - np.minimum(a.n_tmax, a.n_tmin)) <= lim, "hottest_day_temp": (days - a.n_tmax) <= lim, | |
| "cdd": (days - a.n_both) <= lim, "total_precip_in": (days - a.n_prcp) <= lim} | |
| col = {"annual_avg_temp": "avg", "hottest_day_temp": "hot", "cdd": "cdd", "total_precip_in": "prcp"} | |
| rows = [pd.DataFrame({"city_id": a.ID[ok[m]], "year": a.year[ok[m]], "metric": m, "predicted_value": a[col[m]][ok[m]]}) | |
| for m in col] | |
| return pd.concat(rows, ignore_index=True).sort_values(["city_id", "metric", "year"]) | |
| def weather_means(w): | |
| """Mean over 2019-2025 per city and metric, requiring the minimum number of valid years.""" | |
| w = w[w.year.between(*CONFIG["weather_years"])] | |
| g = w.groupby(["city_id", "metric"]).predicted_value | |
| m = g.mean().where(g.count() >= CONFIG["weather_min_valid_years"]) | |
| return m.unstack("metric") | |
| def baseline(train_df, cov): | |
| lo, hi = CONFIG["baseline_years"] | |
| flags = valid_flags(train_df, cov) | |
| out = {} | |
| for metric, col in METRICS.items(): | |
| v = train_df[col].where(flags[metric] & train_df.Year.between(lo, hi)) | |
| g = v.groupby(train_df.ID) | |
| out[metric] = g.mean().where(g.count() >= CONFIG["baseline_min_valid_years"]) | |
| return pd.DataFrame(out) | |
| # ------------------------------------------------------------------ buildings | |
| def station_county(cities, path): | |
| if path.exists(): | |
| cached = pd.read_csv(path, dtype={"county_fips": str}) | |
| if set(cached.ID) == set(cities.index): | |
| return cached | |
| def one(item): | |
| i, (lat, lon) = item | |
| url = f"https://geo.fcc.gov/api/census/block/find?latitude={lat}&longitude={lon}&format=json" | |
| for attempt in range(4): | |
| try: | |
| with urllib.request.urlopen(url, timeout=30) as r: | |
| d = json.loads(r.read().decode()) | |
| break | |
| except (TimeoutError, OSError): | |
| if attempt == 3: | |
| raise | |
| return {"ID": i, "county_fips": d["County"]["FIPS"], "county_name": d["County"]["name"], "state": d["State"]["code"]} | |
| with cf.ThreadPoolExecutor(4) as ex: | |
| rows = list(ex.map(one, [(i, (r.Lat, r.Lon)) for i, r in cities.iterrows()])) | |
| df = pd.DataFrame(rows) | |
| df.to_csv(path, index=False) | |
| return df | |
| def acs_exposure(path): | |
| a = pd.read_csv(path, dtype={"county_fips": str}) | |
| tot_u, tot_y, tot_t = a.B25024_001E, a.B25034_001E, a.B25003_001E | |
| a["share_small_mf"] = a[["B25024_004E", "B25024_005E", "B25024_006E", "B25024_007E"]].sum(axis=1) / tot_u # 2-19 units | |
| a["share_pre1980"] = a[[f"B25034_{i:03d}E" for i in range(7, 12)]].sum(axis=1) / tot_y # built <1980 | |
| a["share_renter"] = a.B25003_003E / tot_t | |
| a["units_small_mf"] = a[["B25024_004E", "B25024_005E", "B25024_006E", "B25024_007E"]].sum(axis=1) | |
| a["exposure"] = a.share_small_mf * a.share_pre1980 | |
| return a[["county_fips", "NAME", "units_small_mf", "share_small_mf", "share_pre1980", "share_renter", "exposure"]] | |
| def policy_gap(names): | |
| r = pd.read_csv(ROOT / "data" / "policy_rules.csv") | |
| cool = r[(r.rule_type == "cooling") & (r.status_2025 == "in_force") & r.covers_small_mixed_use.isin(["yes", "partial"])] | |
| covered = set(cool.city_name) | |
| checked = set(r.city_name) | |
| status = names.map(lambda n: "covered" if n in covered else ("gap (checked)" if n in checked else "gap (not checked)")) | |
| return status | |
| # ------------------------------------------------------------------ flags | |
| def shortfall(hot_new, hot_base, t_in): | |
| gap = hot_base - t_in | |
| s = (hot_new - t_in) / gap - 1 | |
| s = s.where(gap >= CONFIG["shortfall_min_design_gap_F"]) | |
| return s.clip(lower=0) | |
| def flags(df, t_in): | |
| sf = shortfall(df.hot_new, df.hot_base, t_in) | |
| h1 = ((df.cdd_change >= CONFIG["h1_cdd_increase_min"]) & (df.hot_change >= CONFIG["h1_hottest_increase_min_F"])) \ | |
| | (sf >= CONFIG["h1_shortfall_min"]) | |
| h1 = h1.where(df.cdd_base.notna() & df.cdd_new.notna() & df.hot_base.notna() & df.hot_new.notna()) | |
| h2 = df.exposure >= df.exposure.median() | |
| h3 = df.policy_status != "covered" | |
| return sf, h1, h2, h3 | |
| def main(argv=None): | |
| ap = argparse.ArgumentParser() | |
| ap.add_argument("--weather", default=None, help="submission-schema CSV (default: observed NOAA 2019-2025)") | |
| a = ap.parse_args(argv) | |
| (OUT / "charts").mkdir(parents=True, exist_ok=True) | |
| weather_label = "forecast: " + a.weather if a.weather else "OBSERVED NOAA GHCN-Daily 2019-2025 (stand-in, analysis only)" | |
| (OUT / "config.json").write_text(json.dumps({**CONFIG, "weather_input": weather_label, | |
| "written_utc": datetime.now(timezone.utc).isoformat()}, indent=2)) | |
| train_df, cov = load_train() | |
| cities = train_df.groupby("ID")[["Name", "Lat", "Lon"]].first() | |
| if a.weather: | |
| w = pd.read_csv(a.weather) | |
| else: | |
| w = observed_weather() | |
| w.to_csv(OUT / "weather_input.csv", index=False) | |
| new, base = weather_means(w), baseline(train_df, cov) | |
| sc = station_county(cities, OUT / "station_county.csv") | |
| acs = acs_exposure(OUT / "acs_county_2023.csv") | |
| df = cities.join(base.add_suffix("_base")).join(new.add_suffix("_new")) | |
| df = df.rename(columns={"cdd_base": "cdd_base", "hottest_day_temp_base": "hot_base", "hottest_day_temp_new": "hot_new", | |
| "annual_avg_temp_base": "avg_base", "annual_avg_temp_new": "avg_new"}) | |
| df = df[["Name", "Lat", "Lon", "avg_base", "avg_new", "cdd_base", "cdd_new", "hot_base", "hot_new"]] | |
| df["cdd_change"] = df.cdd_new / df.cdd_base - 1 # ~ % change in cooling energy (degree-day method) | |
| df["hot_change"] = df.hot_new - df.hot_base | |
| df = df.join(sc.set_index("ID")).reset_index().merge(acs, on="county_fips", how="left").set_index("ID") | |
| df["policy_status"] = policy_gap(df.Name) | |
| sens = [] | |
| for t in CONFIG["indoor_limit_sensitivity_F"]: | |
| sf, h1, h2, h3 = flags(df, t) | |
| allf = (h1 == True) & h2 & h3 | |
| sens.append({"indoor_limit_F": t, "n_cities": len(df), "n_h1_evaluable": int(h1.notna().sum()), | |
| "n_h1": int((h1 == True).sum()), "n_h2": int(h2.sum()), "n_h3": int(h3.sum()), | |
| "n_all_three": int(allf.sum()), "share_all_three": allf.sum() / len(df), | |
| "supported": bool(allf.sum() / len(df) >= CONFIG["support_min_share"])}) | |
| if t == CONFIG["indoor_limit_F"]: | |
| df["shortfall"], df["H1"], df["H2"], df["H3"] = sf, h1, h2, h3 | |
| df["all_three"] = allf | |
| sens = pd.DataFrame(sens) | |
| df.round(4).to_csv(OUT / "city_flags.csv") | |
| sens.to_csv(OUT / "sensitivity.csv", index=False) | |
| write_report(df, sens, weather_label) | |
| chart(df) | |
| print(sens.to_string(index=False)) | |
| print("wrote", OUT) | |
| # ------------------------------------------------------------------ report | |
| def write_report(df, sens, weather_label): | |
| main = sens[sens.indoor_limit_F == CONFIG["indoor_limit_F"]].iloc[0] | |
| n = len(df) | |
| ev = df[df.H1.notna()] | |
| cs = pd.read_csv(OUT / "case_studies.csv") if (OUT / "case_studies.csv").exists() else None | |
| top = df[df.all_three].sort_values("cdd_change", ascending=False) | |
| h1_not_h2 = df[(df.H1 == True) & ~df.H2] | |
| h2_not_h1 = df[(df.H1 == False) & df.H2] | |
| fmt = lambda s: ", ".join(s) if len(s) else "none" | |
| L = [ | |
| "# Policy heuristic check", | |
| "", | |
| f"Weather input: **{weather_label}**. Thresholds were fixed in `config.json` before the results were computed.", | |
| "", | |
| "## Verdict", | |
| "", | |
| f"- Cities with all three flags (heat past design, older small multifamily stock, no cooling rule): " | |
| f"**{int(main.n_all_three)} of {n} ({main.share_all_three:.0%})**. Threshold for 'supported': " | |
| f"{CONFIG['support_min_share']:.0%}. **Thesis {'supported' if main.supported else 'NOT supported'}** " | |
| f"at an indoor limit of {CONFIG['indoor_limit_F']} F.", | |
| "- Indoor limit sensitivity: " + "; ".join(f"{int(r.indoor_limit_F)} F: {int(r.n_all_three)} cities " | |
| f"({'supported' if r.supported else 'not supported'})" | |
| for r in sens.itertuples()) + ".", | |
| "", | |
| "## The three claims", | |
| "", | |
| "| Claim | Cities flagged | Evaluable |", | |
| "|---|---|---|", | |
| f"| H1 heat past design (1976-2005 baseline) | {int(main.n_h1)} | {int(main.n_h1_evaluable)} |", | |
| f"| H2 above-median older small multifamily share (by construction about half) | {int(main.n_h2)} | {n} |", | |
| f"| H3 no in-force rental cooling rule covering small buildings | {int(main.n_h3)} | {n} (checked by hand for 9 cities) |", | |
| "", | |
| f"Across the {len(ev)} cities with enough data: median cdd change {ev.cdd_change.median():+.0%}, " | |
| f"median hottest-day change {ev.hot_change.median():+.1f} F; cdd rose in {(ev.cdd_change > 0).mean():.0%} of them " | |
| f"and the hottest day rose in {(ev.hot_change > 0).mean():.0%}.", | |
| "", | |
| "## Post-hoc breakdown (looked at after the verdict; does not change it)", | |
| "", | |
| f"- Cooling **energy** claim alone (cdd at least 10% above baseline, baseline cdd at least 100): " | |
| f"{int(((df.cdd_change >= 0.10) & (df.cdd_base >= 100)).sum())} cities; with H2 and H3 as well: " | |
| f"{int(((df.cdd_change >= 0.10) & (df.cdd_base >= 100) & df.H2 & df.H3).sum())}.", | |
| f"- **Peak** heat claim alone: hottest day at least 2 F above baseline in {int((df.hot_change >= 2).sum())} cities; " | |
| f"capacity shortfall at least 10% in {int((df.shortfall >= 0.10).sum())}.", | |
| f"- H1 rate among cities with above-median older small multifamily stock: {(ev[ev.H2].H1 == True).mean():.0%}; " | |
| f"among the rest: {(ev[~ev.H2].H1 == True).mean():.0%}.", | |
| "", | |
| "## Cities with all three flags (largest cooling-load increase first)", | |
| "", | |
| "| City | County | cdd 1976-2005 | cdd 2019-2025 | Cooling load change | Hottest day change F | Capacity shortfall | Small MF share | Pre-1980 share |", | |
| "|---|---|---|---|---|---|---|---|---|", | |
| ] | |
| for i, r in top.head(25).iterrows(): | |
| sf = "n/a" if pd.isna(r.shortfall) else f"{r.shortfall:.0%}" | |
| L.append(f"| {r.Name} | {r.county_name}, {r.state} | {r.cdd_base:.0f} | {r.cdd_new:.0f} | {r.cdd_change:+.0%} | " | |
| f"{r.hot_change:+.1f} | {sf} | {r.share_small_mf:.0%} | {r.share_pre1980:.0%} |") | |
| if len(top) > 25: | |
| L.append(f"| ... {len(top) - 25} more in `city_flags.csv` | | | | | | | | |") | |
| L += [ | |
| "", | |
| "## Evidence against the thesis", | |
| "", | |
| f"- Heat past design but **little** older small multifamily stock ({len(h1_not_h2)}): {fmt(h1_not_h2.Name.head(20).tolist())}" | |
| + (" ..." if len(h1_not_h2) > 20 else ""), | |
| f"- Lots of older small multifamily stock but heat **not** past design ({len(h2_not_h1)}): {fmt(h2_not_h1.Name.head(20).tolist())}" | |
| + (" ..." if len(h2_not_h1) > 20 else ""), | |
| f"- Cities with a cooling rule in force: {fmt(df[df.policy_status == 'covered'].Name.tolist())}", | |
| "", | |
| ] | |
| if cs is not None: | |
| L += ["## Case studies (actual mixed-use buildings)", "", | |
| "| City | Mixed-use buildings | Year built recorded | Built before 1980 | Below size limit of building rules | Central AC |", | |
| "|---|---|---|---|---|---|"] | |
| for r in cs.itertuples(): | |
| p = lambda x: "n/a" if pd.isna(x) else f"{x:.0%}" | |
| L.append(f"| {r.city_name} | {r.n_mixed_use:,} | {p(r.share_with_year_built)} | {p(r.share_pre1980_of_known)} | " | |
| f"{p(r.share_below_bps_size)} (limit {r.bps_size_threshold_sqft:,} sq ft) | {p(r.share_central_ac_of_known)} |") | |
| L.append("") | |
| for c in ["Pittsburgh", "NewYork", "Chicago"]: | |
| if c in set(df.Name): | |
| r = df[df.Name == c].iloc[0] | |
| L.append(f"- **{c}**: cdd {r.cdd_base:.0f} -> {r.cdd_new:.0f} ({r.cdd_change:+.0%}), hottest day " | |
| f"{r.hot_base:.1f} -> {r.hot_new:.1f} F; H1 {bool(r.H1 == True)}, H2 {bool(r.H2)}, H3 {r.policy_status}.") | |
| L.append("") | |
| L += [ | |
| "## Method limits (state these with any result)", | |
| "", | |
| "- H1 compares 2019-2025 with 1976-2005 at the station. Most stations are at airports, outside the dense " | |
| "centres where mixed-use buildings are, so heat there is probably understated (urban heat island).", | |
| f"- Capacity shortfall uses {CONFIG['shortfall_formula']}. The design temperature is approximated by the mean " | |
| "annual hottest day, not the ASHRAE 0.4%/1% design values (copyrighted).", | |
| "- Cooling load change uses the degree-day method: cooling energy taken as proportional to cdd.", | |
| "- H2 is a county proxy: ACS counts building size and age, not mixed use, and cannot cross them " | |
| "(exposure = product of the two shares). The station's county may differ from the city's.", | |
| "- H3 relies on reported rules (data/policy_rules.csv); most cities were not checked in their municipal code, " | |
| "so 'gap (not checked)' means no rule was found in national reporting, not that none exists.", | |
| "- The weather input is observed data used as a stand-in for the forecast; rerun with `--weather submission.csv`.", | |
| ] | |
| (OUT / "thesis_check.md").write_text("\n".join(L), encoding="utf-8") | |
| def chart(df): | |
| import matplotlib | |
| matplotlib.use("Agg") | |
| import matplotlib.pyplot as plt | |
| fig, ax = plt.subplots(figsize=(11, 6.5)) | |
| cats = [("No heat flag / no data", (df.H1 != True), "#c9c9c9", 18), | |
| ("Heat past design only", (df.H1 == True) & ~(df.H2 & df.H3), "#f2a65a", 30), | |
| ("Heat + older small multifamily + no cooling rule", df.all_three, "#c0392b", 46)] | |
| for label, m, c, s in cats: | |
| ax.scatter(df.Lon[m], df.Lat[m], s=s, c=c, label=f"{label} ({int(m.sum())})", edgecolors="white", linewidths=0.5) | |
| for c in ["Pittsburgh", "NewYork", "Chicago", "Phoenix", "Houston"]: | |
| r = df[df.Name == c] | |
| if len(r): | |
| ax.annotate(c, (r.Lon.iloc[0], r.Lat.iloc[0]), xytext=(4, 4), textcoords="offset points", fontsize=8) | |
| ax.set_xlabel("Longitude") | |
| ax.set_ylabel("Latitude") | |
| ax.set_title(f"Policy heuristic check, {len(df)} cities (indoor limit {CONFIG['indoor_limit_F']} F)") | |
| ax.legend(loc="lower left", fontsize=9, frameon=False) | |
| ax.set_aspect(1.25) | |
| for s in ("top", "right"): | |
| ax.spines[s].set_visible(False) | |
| fig.tight_layout() | |
| fig.savefig(OUT / "charts" / "flags_map.png", dpi=150) | |
| if __name__ == "__main__": | |
| main() | |