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()