sanvicpatel's picture
Upload reproducible Protostar climate forecasts
993d9a6 verified
Raw History Blame Contribute Delete
8.27 kB
"""Choose metric-specific convex ensembles using exclusively pre-2019 backtests."""
import argparse
import json
from pathlib import Path
import numpy as np
import pandas as pd
from inputs import Panel, ROOT, METRICS
from experiments import info
from models import kernel
PREFIX=('core','adv','climate','direct','tele')
def read_folds(prefix=PREFIX):
all_years=[{int(p.stem.rsplit('_',1)[1]) for p in (ROOT/'reports').glob(f'{tag}_*.npz')} for tag in prefix]
common=sorted(set.intersection(*all_years)); folds={}; names=None
for y in common:
items=[]; fields=[]
for tag in prefix:
with np.load(ROOT/'reports'/f'{tag}_{y}.npz') as f:
items.append(f['pred']); fields.extend(map(str,f['models']))
a,b=f['actual'],f['base']
if names is None: names=fields
if names!=fields: raise ValueError('Inconsistent experiment candidate definitions')
if y>2018 or (y!=2018 and y+len(a)>2018) or (y==2018 and np.isfinite(a).any()):
raise ValueError('Cannot score after 2018')
folds[y]=(np.concatenate(items),a,b)
return np.array(names),folds
def metric_training(folds,origins,m,half,ref,lead=None,city_weight=None):
f=[]; ys=[]; ws=[]
# Normalize per origin by the contest baseline and give recent folds more weight.
for year in origins:
p,a,b=folds[year]; h=len(a)
leads=np.arange(h) if lead is None else np.arange(h)[slice(*lead)]
a=a[leads,:,m]; b=b[leads,:,m]; p=p[:,:,:,m][:,leads,:]
ok=np.isfinite(a)&np.isfinite(b)
cw=np.ones(ok.shape)[ok] if city_weight is None else np.broadcast_to(city_weight,ok.shape)[ok]
d=np.sum(cw*np.abs(a[ok]-b[ok]))
f.append(p[:,ok]); ys.append(a[ok]); ws.append(cw*2**((year-ref)/half)/d)
target=np.concatenate(ys); w=np.concatenate(ws); X=np.concatenate(f,axis=1)
w/=sum(2**((yr-ref)/half) for yr in origins)
return X,target,w
def fit(names,folds,origins,m,half=13,shortlist=5,steps=18,shrink=.18,lead=None,city_weight=None):
ref=max(origins); X,y,w=metric_training(folds,origins,m,half,ref,lead,city_weight)
scores=np.abs(X-y)@w; order=np.argsort(scores,kind='stable')
f=np.array([k.split(':')[0] for k in names]); top=set(order[:25]); families=set(f[order[:100]])
for k in families:
arr=order[f[order]==k][:shortlist]; top.update(arr)
take=np.array(sorted(top)); X=X[take]; P=np.zeros(len(take)); fit=np.zeros(len(y)); n=0
# Blend using repeated choices, with a small cost for a model that only wins in one combination.
cost=.12*np.maximum(0,scores[take]-scores[order[0]])
for i in range(steps):
e=np.abs((i*fit+X)/(i+1)-y)@w+cost/(i+1)
k=int(np.argmin(e)); fit=(fit*i+X[k])/(i+1); P[k]+=1/steps
best=take[P>1e-8]; wts=P[P>1e-8]
# Use near-best diverse candidates as a modest prior against tuning to a few anomalous years.
prior={}; chosen=set()
for k in order:
if f[k] in chosen:continue
chosen.add(f[k]); prior[k]=1. if not prior else .65
if len(prior)==4:break
alpha=sum(prior.values()); fit={k:(1-shrink)*q for k,q in zip(best,wts)}
for k,q in prior.items():fit[k]=fit.get(k,0)+shrink*q/alpha
return {str(names[k]):float(q) for k,q in fit.items()},str(names[order[0]])
def mix_portfolios(a,b,weight):
out={k:(1-weight)*v for k,v in a.items()}
for k,v in b.items():out[k]=out.get(k,0.)+weight*v
return out
def estimate(names,folds,origins,mode='balanced'):
if len(origins)<3:raise ValueError('Need three historical origins')
out={}; recent=[y for y in origins if y>=1995]
for m,metric in enumerate(METRICS):
if mode=='historical':
full,best=fit(names,folds,origins,m,half=20)
elif mode=='recent':
full,best=fit(names,folds,recent if len(recent)>=3 else origins,m,half=8)
else:
full,best=fit(names,folds,origins,m,half=15)
if len(recent)>=3:
r,_=fit(names,folds,recent,m,half=8)
full=mix_portfolios(full,r,.5 if m in [0,3] else .3)
out[metric]={k:v for k,v in full.items() if v>1e-8}
return out
CENTERS=[[47,-122],[34,-119],[40,-104],[32,-97],[44,-88],[34,-83],[42,-74]]
def membership(p):
lat=np.r_[p.lat,[x[0] for x in CENTERS]]
lon=np.r_[p.lon,[x[1] for x in CENTERS]]
k=kernel(lat,lon,700)[:-len(CENTERS),-len(CENTERS):]
out=k/np.maximum(k.sum(axis=1,keepdims=True),1e-12)
reliability=np.clip(k.max(axis=1)*2,0,1)
return out*reliability[:,None]
def estimate_regional(names,folds,origins,p,mode='balanced',fraction=.35):
glob=estimate(names,folds,origins,mode)
if not fraction: return glob
k=membership(p)
regional=[]
for i in range(k.shape[1]):
d={}
for m,metric in enumerate(METRICS):
d[metric],_=fit(names,folds,origins,m,half=10,shortlist=4,steps=12,shrink=.26,city_weight=k[:,i]+.025)
regional.append(d)
return dict(global_weights=glob,regional_weights=regional,regional_fraction=fraction)
def combine(names,preds,weights,regions=None):
index={k:i for i,k in enumerate(names)}
def apply(w):
a=np.empty(preds.shape[1:],dtype='float64')
for m,k in enumerate(METRICS):
a[:,:,m]=sum(v*preds[index[n],:,:,m].astype('float64') for n,v in w[k].items())
return a
if 'global_weights' in weights:
if regions is None: raise ValueError('Regional weights require city memberships')
frac=weights['regional_fraction']; w=regions*frac
a=apply(weights['global_weights'])*(1-w.sum(axis=1))[None,:,None]
for i,z in enumerate(weights['regional_weights']): a+=apply(z)*w[None,:,i,None]
else: a=apply(weights)
a[:,:,1]=a[:,:,1].clip(min=0);a[:,:,3]=a[:,:,3].clip(min=0)
return a
def score_report(names,folds,year,weights,regions=None):
p,a,b=folds[year]
result=info(a,b,combine(names,p,weights,regions)); result['origin']=year; result['end']=year+len(a)
return result
def report_table(report):
for r in report:
print(r['origin'],r.get('mode',''),f"{r['score']:.2f}",np.round(r['skill'],2),np.round(r['mae'],2))
def main():
ap=argparse.ArgumentParser();ap.add_argument('--prefix',default=','.join(PREFIX));ap.add_argument('--mode',default='balanced',choices=['balanced','historical','recent']);ap.add_argument('--write',action='store_true');ap.add_argument('--regional',type=float,default=0.);args=ap.parse_args()
names,folds=read_folds(tuple(args.prefix.split(',')))
origins=[y for y in folds if y<=2011]; print('candidate count',len(names),'origins',origins)
p=Panel(); regions=membership(p); replay=[]
for year in [1997,2004,2009,2010,2011]:
if year not in folds:continue
train=[y for y in origins if y+folds[y][1].shape[0]<=year]
if len(train)<3:continue
for mode in ['balanced','historical','recent']+(['regional'] if args.regional else []):
weight=estimate_regional(names,folds,train,p,args.mode,args.regional) if mode=='regional' else estimate(names,folds,train,mode)
r=score_report(names,folds,year,weight,regions); r['mode']=mode;r['fit_origins']=train
replay.append(r)
print('Origin-by-origin replay: blend weights only use completed earlier folds')
report_table(replay)
weight=estimate_regional(names,folds,origins,p,args.mode,args.regional)
print('Final fit weights'); print(json.dumps(weight,indent=2))
fit=[score_report(names,folds,y,weight,regions) for y in origins]
print('Tuning-set scores (descriptive, not holdouts)');report_table(fit)
if args.write:
result={'mode':args.mode,'fit_origins':origins,'candidate_count':len(names),'weights':weight}
(ROOT/'code'/'ensemble.json').write_text(json.dumps(result,indent=2)+'\n')
(ROOT/'reports'/'validation.json').write_text(json.dumps({'model':result,'rolling_replay':replay,'tuning_folds':fit},indent=2)+'\n')
# The complete model produces only forecast output labels after 2018.
if 2018 in folds:
pr=combine(names,folds[2018][0],weight,regions)
print('Forecast min/max by metric',pr.min(axis=(0,1)),pr.max(axis=(0,1)))
if __name__=='__main__':main()