Datasets:
File size: 8,272 Bytes
993d9a6 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 | """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()
|