Datasets:
Download code/selection.py from sanvicpatel/protostar-climate-ensemble: direct link, hf CLI and curl.
- Browser
- Download file 8.27 kB
-
https://huggingface.co/datasets/sanvicpatel/protostar-climate-ensemble/resolve/main/code/selection.py
- Command line
-
hf download hf://datasets/sanvicpatel/protostar-climate-ensemble/code/selection.py
-
curl -L -o selection.py https://huggingface.co/datasets/sanvicpatel/protostar-climate-ensemble/resolve/main/code/selection.py
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() | |