def get_smoothed_res(self, n, owa=False):
model = self.get_model(n)
fk_boot = ssm.Bootstrap(ssm=model, data=[np.array(self.series[n])])
alg_with_mom = particles.SMC(fk=fk_boot, N=100, moments=True)
alg_with_mom.run()
mu, sigma = model.avg_y, np.exp(alg_with_mom.summaries.moments[0]['mean']/2) # scale
res = np.mean(np.random.normal(mu, sigma, 100))
return res
def smoothing_trajectories(rho, sig2, N=100):
fk = ssms.Bootstrap(ssm=NeuroXp(rho=rho, sig2=sig2), data=data)
pf = particles.SMC(fk=fk, N=N, qmc=False, store_history=True)
pf.run()
(paths, ar) = pf.hist.backward_sampling(N,
return_ar=True,
linear_cost=True)
print('Acceptance rate (FFBS-reject): %.3f' % ar)
return (paths, pf.logLt)
def __call__(self, x):
rho, sig2 = x[0], x[1]
if rho > 1. or rho < 0. or sig2 <= 0:
return np.inf
fk = ssms.Bootstrap(ssm=NeuroXp(rho=rho, sig2=sig2), data=data)
pf = particles.SMC(fk=fk, N=self.N, qmc=True)
pf.run()
self.args.append(x)
self.lls.append(pf.logLt)
return -pf.logLt
def generate_aid_x(record_id, data, cir_args, tau, H, N=100000):
logger.info("Start to generate posterior mean used as benchmark.")
aid_ssm = CIR(tau=tau, H=H, **cir_args)
aid_alg = particles.SMC(ssm.Bootstrap(ssm=aid_ssm, data=data), **{
**default_args, 'N': N
})
aid_alg.run()
store = {
'aid_x': aid_alg.hist.X,
'aid_post_mean': aid_alg.summaries.moments
}
np.savez(file=f"./Records/CIR{record_id}/aid_x_boot", **store)
logger.info("Posterior mean successfully generated.")
cir_args = {
key: config['PARAMETERS'].getfloat(key)
for key in config['PARAMETERS'].keys()
}
logger.info(
"Data lodaded successfully. Shape of states x: {}; Shape of observations y: {}.",
real_x.shape, real_y.shape)
else:
config = CIR_config(record_id).load()
cir_args = config['MODEL']['PARAMS']
tau, H = config['MODEL']['OBS']['tau'], config['MODEL']['OBS']['H']
# Define Feynman-Kac models ======================================================================================
fk_list = {
"bootstrap_60k":
ssm.Bootstrap(ssm=CIR(tau=tau, H=H, **cir_args), data=real_y),
# "SMC" : ssm.GuidedPF(ssm=CIR(tau=tau, H=H, **cir_args), data=real_y),
# "SMCt" : ssm.GuidedPF(ssm=CIR(tau=tau, H=H, **cir_args, proposal='t', tdf=5), data=real_y),
# "SMC_mod" : ssm.GuidedPF(ssm=CIR_mod(tau=tau, H=H, s=50, proposal='boot', **cir_args), data=real_y),
# #
# "normal+q811.99": MultiPropPF.MultiPropFK(ssm=CIR(tau=tau, H=H, ptp=0.99, **cir_args), data=real_y,
# proposals={'normal': 0.8, 'normalq': 0.1, 'normalql': 0.1}),
# "normal+tq": MultiPropPF.MultiPropFK(ssm=CIR(tau=tau, H=H, tdf=3, **cir_args), data=real_y,
# proposals={'normal': 0.9, 'tq': 0.05, 'tql': 0.05}),
# 为normal插上t的翅膀
# "normal+q3" : MultiPropPF.MultiPropFK(ssm=CIR(tau=tau, H=H), data=real_y,
# proposals={'normal':0.8, 'normalq':0.1, 'normalql':0.1}),
# 2021-04-08 3:10 enlarge the proportion of right sided tail, expect better performance on extreme quantiles estimate
#
# "t5+q811.95": MultiPropPF.MultiPropFK(ssm=CIR(tau=tau, H=H, tdf=5, ptq=0.95, **cir_args), data=real_y,
from matplotlib import pyplot as plt
import numpy as np
# import seaborn as sb
import particles
from particles import distributions as dists
from particles import state_space_models as ssm
# set up models, simulate and save data
T = 100
mu0 = 0.
phi0 = 0.9
sigma0 = .5 # true parameters
my_ssm = ssm.DiscreteCox(mu=mu0, phi=phi0, sigma=sigma0)
true_states, data = my_ssm.simulate(T)
fkmod = ssm.Bootstrap(ssm=my_ssm, data=data)
# run particle filter, compute trajectories
N = 100
pf = particles.SMC(fk=fkmod, N=N, store_history=True)
pf.run()
pf.hist.compute_trajectories()
# PLOT
# ====
# sb.set_palette("dark")
plt.style.use('ggplot')
savefigs = False
plt.figure()
plt.xlabel('t')
def save_results(new_results):
all_results.update(new_results)
with open(results_file, 'wb') as f:
pickle.dump(all_results, f)
# Evaluate log-likelihood on a grid
###################################
ng = 50
rhos = np.linspace(0., 1., ng)
sig2s = np.linspace(1e-2, 25., ng) # for sigma=0., returns Nan
ijs = list(itertools.product(range(ng), range(ng)))
fks = {
ij: ssms.Bootstrap(ssm=NeuroXp(rho=rhos[ij[0]], sig2=sig2s[ij[1]]),
data=data)
for ij in ijs
}
outf = lambda pf: pf.logLt
nruns = 5
print('computing log-likelihood on a grid')
results = particles.multiSMC(fk=fks,
N=100,
qmc=True,
nruns=nruns,
nprocs=0,
out_func=outf)
save_results({'results': results})
# EM
#parameter values
alpha0 = 0.4
T = 50
dims = range(5, 21, 5)
# instantiate models
models = OrderedDict()
true_loglik, true_filt_means = {}, {}
for d in dims:
my_ssm = ssm.MVLinearGauss_Guarniero_etal(alpha=alpha0, dx=d)
_, data = my_ssm.simulate(T)
truth = my_ssm.kalman_filter(data)
true_loglik[d] = truth.logpyts.cumsum()
true_filt_means[d] = truth.filt.means
models['boot_%i' % d] = ssm.Bootstrap(ssm=my_ssm, data=data)
models['guided_%i' % d] = ssm.GuidedPF(ssm=my_ssm, data=data)
# Get results
N = 10**4
results = particles.multiSMC(fk=models,
qmc=[False, True],
N=N,
moments=True,
nruns=100,
nprocs=0)
# Format results
results_mse = []
for d in dims:
for t in range(T):
# parameters
dy = 80 # number of neurons
dx = 6 # 3 for position, 3 for velocity
T = 25
a0 = random.normal(loc=2.5, size=dy) # from Koyama et al
# the b's are generated uniformly on the unit sphere in R^6 (see Koyama et al)
b0 = random.normal(size=(dy, dx))
b0 = b0 / (linalg.norm(b0, axis=1)[:, np.newaxis])
delta0 = 0.03; tau0 = 1.
x0 = np.zeros(dx)
# models
chosen_ssm = NeuralDecoding(a=a0, b=b0, x0=x0, delta=delta0, tau=tau0)
_, data = chosen_ssm.simulate(T)
models = OrderedDict()
models['boot'] = ssms.Bootstrap(ssm=chosen_ssm, data=data)
models['guided'] = ssms.GuidedPF(ssm=chosen_ssm, data=data)
# models['apf'] = ssms.AuxiliaryPF(ssm=chosen_ssm, data=data)
# Uncomment this if you want to include the APF in the comparison
N = 10**4; nruns = 50
results = particles.multiSMC(fk=models, N=N, nruns=nruns, nprocs=1,
collect=[Moments], store_history=True)
## PLOTS
#########
savefigs = True # False if you don't want to save plots as pdfs
plt.style.use('ggplot')
# arbitrary time
t0 = 9
def fkmod(**kwargs):
return ssm.Bootstrap(ssm=ssm.StochVol(**kwargs), data=data)
from matplotlib import pyplot as plt
import numpy as np
# import seaborn as sb
import particles
from particles import distributions as dists
from particles import state_space_models
# set up models, simulate and save data
T = 100
mu0 = 0.
phi0 = 0.9
sigma0 = .5 # true parameters
ssm = state_space_models.DiscreteCox(mu=mu0, phi=phi0, sigma=sigma0)
true_states, data = ssm.simulate(T)
fkmod = state_space_models.Bootstrap(ssm=ssm, data=data)
# run particle filter, compute trajectories
N = 100
pf = particles.SMC(fk=fkmod, N=N, store_history=True)
pf.run()
Bs = pf.hist.compute_trajectories()
# PLOT
# ====
# sb.set_palette("dark")
plt.style.use('ggplot')
savefigs = True # False if you don't want to save plots as pdfs
plt.figure()
plt.xlabel('t')
scale=self.sigma)
def PY(self, t, xp,
x): # Distribution of Y_t given X_t=x (and possibly X_{t-1}=xp)
return dists.Normal(loc=0., scale=np.exp(x))
my_model = StochVol(mu=-1., rho=.9, sigma=.1) # actual model
true_states, data = my_model.simulate(
100) # we simulate from the model 100 data points
plt.style.use('ggplot')
plt.figure()
plt.plot(data)
fk_model = ssm.Bootstrap(ssm=my_model, data=data)
pf = particles.SMC(fk=fk_model,
N=100,
resampling='stratified',
moments=True,
store_history=True)
pf.run()
plt.figure()
plt.plot([yt**2 for yt in data], label='data-squared')
plt.plot([m['mean'] for m in pf.summaries.moments],
label='filtered volatility')
plt.legend()
#results=particles.multiSMC(fk=fk_model,N=100,nruns=30,qmc={'SMC':False,'SQMC':True})
#results = particles.multiSMC(fk=fk_model, N=100, nruns=30, qmc={'SMC':False, 'SQMC':True})
#plt.figure()
def fk_mod(T):
"FeynmanKac object, given T"
return ssm.Bootstrap(ssm=my_ssm, data=data[:T])
"""
from __future__ import division, print_function
from matplotlib import pyplot as plt
import numpy as np
from scipy import stats
import particles
from particles import state_space_models as ssms
# instantiate model
T = 100
model = ssms.Gordon()
_, data = model.simulate(T)
fk = ssms.Bootstrap(ssm=model, data=data)
# Get results
Ns = [2**k for k in range(6, 21)]
of = lambda pf: {
'll': pf.logLt,
'EXt': [m['mean'] for m in pf.summaries.moments]
}
results = particles.multiSMC(fk=fk,
qmc={
'smc': False,
'sqmc': True
},
N=Ns,
moments=True,
nruns=200,
def fkmod(theta, T):
return ssms.Bootstrap(ssm=ssmod(theta), data=data[:T])
def log_gamma(x, mu, phi, sigma):
return stats.norm.logpdf(x, loc=mu, scale=sigma / np.sqrt(1. - phi**2))
if __name__ == '__main__':
# set up model, simulate data
T = 100
mu0 = 0.
phi0 = .9
sigma0 = .5 # true parameters
my_ssm = DiscreteCox_with_add_f(mu=mu0, phi=phi0, sigma=sigma0)
_, data = my_ssm.simulate(T)
# FK models
fkmod = ssms.Bootstrap(ssm=my_ssm, data=data)
# FK model for information filter: same model with data in reverse
fk_info = ssms.Bootstrap(ssm=my_ssm, data=data[::-1])
nruns = 100 # run each algo 100 times
Ns = [50, 200, 800, 3200, 12800]
methods = [
'FFBS_ON', 'FFBS_ON2', 'two-filter_ON', 'two-filter_ON_prop',
'two-filter_ON2'
]
add_func = partial(psit, mu=mu0, phi=phi0, sigma=sigma0)
log_gamma_func = partial(log_gamma, mu=mu0, phi=phi0, sigma=sigma0)
results = utils.multiplexer(f=smoothing_worker,
method=methods,
N=Ns,
'sigma': dists.Gamma(a=2., b=2.),
'rho': dists.Beta(a=9., b=1.)
}
prior = dists.StructDist(dict_prior)
mu0, sigma0, rho0 = -1.02, 0.178, 0.9702
theta0 = np.array([(mu0, rho0, sigma0)],
dtype=[('mu', float), ('rho', float), ('sigma', float)])
ssm_cls = ssm.StochVol
ssmod = ssm_cls(mu=mu0, sigma=sigma0, rho=rho0)
# (QMC-)FFBS as a reference
N = 3000
tic = time.time()
pf = particles.SMC(fk=ssm.Bootstrap(ssm=ssmod, data=data), N=N, qmc=True,
store_history=True)
pf.run()
smth_traj = pf.hist.backward_sampling_qmc(M=N)
cpu_time_fbbs = time.time() - tic
print('FFBS-QMC: run completed, took %f min' % (cpu_time_fbbs / 60.))
def reject_sv(m, s, y):
""" Sample from N(m, s^2) times SV likelihood using rejection.
SV likelihood (in x) corresponds to y ~ N(0, exp(x)).
"""
mp = m + 0.5 * s**2 * (-1. + y**2 * np.exp(-m))
ntries = 0
while True:
def fk_mod(self):
if self.auxiliary_bootstrap:
return ssm.AuxiliaryBootstrap(ssm=self.ss_mod, data=self.data)
else:
# AuxiliaryBootstrap seems to perform better
return ssm.Bootstrap(ssm=self.ss_mod, data=self.data)
def fkmod(theta):
mu = theta[0]
rho = theta[1]
sigma = theta[2]
return ssms.Bootstrap(ssm=ssms.StochVol(mu=mu, rho=rho, sigma=sigma),
data=data)
Nx=Nx, niter=niter, adaptive=False, rw_cov=rw_cov,
verbose=10)
# Run the algorithms
####################
for alg_name, alg in algos.items():
print('\nRunning ' + alg_name)
alg.run()
print('CPU time: %.2f min' % (alg.cpu_time / 60))
# Compute variances
###################
thin = int(niter / 100) # compute average (of variances) over 100 points
thetas = algos['mh'].chain.theta[(burnin - 1)::thin]
fks = {k: ssm.Bootstrap(ssm=ReparamLinGauss(**smc_samplers.rec_to_dict(th)), data=data)
for k, th in enumerate(thetas)}
outf = lambda pf: pf.logLt
print('Computing variances of log-lik estimates as a function of N')
results = particles.multiSMC(fk=fks, N=Nxs, nruns=4, nprocs=0, out_func=outf)
df = pandas.DataFrame(results)
df_var = df.groupby(['fk', 'N']).var() # variance as a function of fk and N
df_var = df_var.reset_index()
df_var_mean = df_var.groupby('N').mean() # mean variance as function of N
# Plots
#######
savefigs = False
plt.style.use('ggplot')
def msjd(theta):
return 10 + 5 * ap**2
mu0 = [8.5e-11, 2.7, 10]
sigma0 = np.diag([7e-13**2, 0.005**2, 1])
my_model = ParisLaw(mu=mu0,
sigma=sigma0) # actual model, theta = [mu, rho, sigma]
true_states, data = my_model.simulate(
10) # we simulate from the model 100 data points
plt.style.use('ggplot')
plt.figure()
plt.scatter(range(len(data)), data)
data = np.array(data).flatten()
fk_model = ssm.Bootstrap(ssm=my_model,
data=data) # we use the Bootstrap filter
pf = particles.SMC(fk=fk_model,
N=1000,
resampling='stratified',
moments=False,
store_history=True) # the algorithm
pf.run() # actual computation
# plot
#plt.figure()
#plt.plot([yt**2 for yt in data], label='data-squared')
#plt.plot([m['mean'] for m in pf.summaries.moments], label='filtered volatility')
#plt.legend()
# prior_dict = {'mu':dists.Normal(),
# 'sigma': dists.Gamma(a=1., b=1.),
def fk_mod(T):
"FeynmanKac object, given T"
return state_space_models.Bootstrap(ssm=ssm, data=data[:T])
#parameter values
alpha0 = 0.3
T = 50
dims = range(5, 21, 5)
# instantiate models
models = OrderedDict()
true_loglik, true_filt_means = {}, {}
for d in dims:
ssm = kalman.MVLinearGauss_Guarniero_etal(alpha=alpha0, dx=d)
_, data = ssm.simulate(T)
kf = kalman.Kalman(ssm=ssm, data=data)
kf.filter()
true_loglik[d] = np.cumsum(kf.logpyt)
true_filt_means[d] = [f.mean for f in kf.filt]
models['boot_%i' % d] = ssms.Bootstrap(ssm=ssm, data=data)
models['guided_%i' % d] = ssms.GuidedPF(ssm=ssm, data=data)
# Get results
N = 10**4
results = particles.multiSMC(fk=models, qmc=[False, True], N=N, moments=True,
nruns=100, nprocs=1)
# Format results
results_mse = []
for d in dims:
for t in range(T):
# this returns the estimate of E[X_t(1)|Y_{0:t}]
estimate = lambda r: r['output'].summaries.moments[t]['mean'][0]
for type_fk in ['guided', 'boot']:
for qmc in [False, True]:
dy = 80 # number of neurons
dx = 6 # 3 for position, 3 for velocity
T = 25
a0 = random.normal(loc=2.5, size=dy) # from Kass' paper
# the b's are generated uniformly on the unit sphere in R^6 (see Kass' paper)
b0 = random.normal(size=(dy, dx))
b0 = b0 / (linalg.norm(b0, axis=1)[:, np.newaxis])
delta0 = 0.03
tau0 = 1.
x0 = np.zeros(dx) # TODO
# models
chosen_ssm = NeuralDecoding(a=a0, b=b0, x0=x0, delta=delta0, tau=tau0)
_, data = chosen_ssm.simulate(T)
models = OrderedDict()
models['boot'] = state_space_models.Bootstrap(ssm=chosen_ssm, data=data)
models['guided'] = state_space_models.GuidedPF(ssm=chosen_ssm, data=data)
# models['apf'] = state_space_models.AuxiliaryPF(ssm=chosen_ssm, data=data)
# Uncomment this if you want to include the APF in the comparison
N = 10**4
nruns = 50
results = particles.multiSMC(fk=models,
N=N,
nruns=nruns,
nprocs=1,
moments=True,
store_history=True)
## PLOTS
#########
import particles
from particles import state_space_models as ssm
# Data and parameter values from Pitt & Shephard
raw_data = np.loadtxt('../../datasets/GBP_vs_USD_9798.txt',
skiprows=2,
usecols=(3, ),
comments='(C)')
T = 201
data = 100. * np.diff(np.log(raw_data[:(T + 1)]))
my_ssm = ssm.StochVol(mu=2 * np.log(.5992), sigma=0.178, rho=0.9702)
# FK models
models = OrderedDict()
models['bootstrap'] = ssm.Bootstrap(ssm=my_ssm, data=data)
models['guided'] = ssm.GuidedPF(ssm=my_ssm, data=data)
models['apf'] = ssm.AuxiliaryPF(ssm=my_ssm, data=data)
# Get results
results = particles.multiSMC(fk=models, N=10**3, nruns=250, moments=True)
# Golden standard
bigN = 10**5
bigpf = particles.SMC(fk=models['bootstrap'], N=bigN, qmc=True, moments=True)
print('One SQMC run with N=%i' % bigN)
bigpf.run()
# PLOTS
# =====
plt.style.use('ggplot')
'mu': dists.Normal(scale=2.),
'sigma': dists.Gamma(a=2., b=2.),
'rho': dists.Beta(a=9., b=1.)
}
prior = dists.StructDist(dict_prior)
mu0, sigma0, rho0 = -1.02, 0.178, 0.9702
theta0 = np.array([(mu0, rho0, sigma0)],
dtype=[('mu', float), ('rho', float), ('sigma', float)])
ssm_cls = state_space_models.StochVol
ssm = ssm_cls(mu=mu0, sigma=sigma0, rho=rho0)
# (QMC-)FFBS as a reference
N = 3000
tic = time.time()
pf = particles.SMC(fk=state_space_models.Bootstrap(ssm=ssm, data=data),
N=N,
qmc=True,
store_history=True)
pf.run()
smth_traj = pf.hist.backward_sampling_qmc(M=N)
cpu_time_fbbs = time.time() - tic
print('FFBS-QMC: run completed, took %f min' % (cpu_time_fbbs / 60.))
def reject_sv(m, s, y):
""" Sample from N(m, s^2) times SV likelihood using rejection.
SV likelihood (in x) corresponds to y ~ N(0, exp(x)).
"""
mp = m + 0.5 * s**2 * (-1. + y**2 * np.exp(-m))
