def jac_prelim(self, ss, save=False, use_saved=False):
"""Helper that does preliminary processing of steady state for fake news algorithm.
Parameters
----------
ss : dict, all steady-state info, intended to be from .ss()
save : [optional] bool, whether to store results in .prelim_saved attribute
use_saved : [optional] bool, whether to use already-stored results in .prelim_saved
Returns
----------
ssin_dict : dict, ss vals of exactly the inputs needed by self.back_step_fun for backward step
Pi : array (S*S), Markov matrix for exogenous state
ssout_list : tuple, what self.back_step_fun returns when given ssin_dict (not exactly the same
as steady-state numerically since SS convergence was to some tolerance threshold)
ss_for_hetinput : dict, ss vals of exactly the inputs needed by self.hetinput (if it exists)
sspol_i : dict, indices on lower bracketing gridpoint for all in self.policy
sspol_pi : dict, weights on lower bracketing gridpoint for all in self.policy
sspol_space : dict, space between lower and upper bracketing gridpoints for all in self.policy
"""
output_names = ('ssin_dict', 'Pi', 'ssout_list',
'ss_for_hetinput', 'sspol_i', 'sspol_pi', 'sspol_space')
if use_saved:
if self.prelim_saved:
return tuple(self.prelim_saved[k] for k in output_names)
else:
raise ValueError('Nothing saved to be used by jac_prelim!')
# preliminary a: obtain ss inputs and other info, run once to get baseline for numerical differentiation
ssin_dict = self.make_inputs(ss)
Pi = ss[self.exogenous]
grid = {k: ss[k+'_grid'] for k in self.policy}
ssout_list = self.back_step_fun(**ssin_dict)
ss_for_hetinput = None
if self.hetinput is not None:
ss_for_hetinput = {k: ss[k] for k in self.hetinput_inputs if k in ss}
# preliminary b: get sparse representations of policy rules, and distance between neighboring policy gridpoints
sspol_i = {}
sspol_pi = {}
sspol_space = {}
for pol in self.policy:
# use robust binary-search-based method that only requires grids to be monotonic
sspol_i[pol], sspol_pi[pol] = utils.interpolate_coord_robust(grid[pol], ss[pol])
sspol_space[pol] = grid[pol][sspol_i[pol]+1] - grid[pol][sspol_i[pol]]
toreturn = (ssin_dict, Pi, ssout_list, ss_for_hetinput, sspol_i, sspol_pi, sspol_space)
if save:
self.prelim_saved = {k: v for (k, v) in zip(output_names, toreturn)}
return toreturn
def td(self, ss, monotonic=False, returnindividual=False, **kwargs):
"""Evaluate transitional dynamics for HetBlock given dynamic paths for inputs in kwargs,
assuming that we start and end in steady state ss, and that all inputs not specified in
kwargs are constant at their ss values. Analog to SimpleBlock.td.
CANNOT provide time-varying paths of grid or Markov transition matrix for now.
Parameters
----------
ss : dict
all steady-state info, intended to be from .ss()
monotonic : [optional] bool
flag indicating date-t policies are monotonic in same date-(t-1) policies, allows us
to use faster interpolation routines, otherwise use slower robust to nonmonotonicity
returnindividual : [optional] bool
return distribution and full outputs on grid
kwargs : dict of {str : array(T, ...)}
all time-varying inputs here, with first dimension being time
this must have same length T for all entries (all outputs will be calculated up to T)
Returns
----------
td : dict
if returnindividual = False, time paths for aggregates (uppercase) for all outputs
of self.back_step_fun except self.backward
if returnindividual = True, additionally time paths for distribution and for all outputs
of self.back_Step_fun on the full grid
"""
# infer T from kwargs, check that all shocks have same length
shock_lengths = [x.shape[0] for x in kwargs.values()]
if shock_lengths[1:] != shock_lengths[:-1]:
raise ValueError('Not all shocks in kwargs are same length!')
T = shock_lengths[0]
# copy from ss info
Pi_T = ss[self.exogenous].T.copy()
grid = {k: ss[k+'_grid'] for k in self.policy}
D = ss['D']
# allocate empty arrays to store result, assume all like D
individual_paths = {k: np.empty((T,) + D.shape) for k in self.non_back_outputs}
# backward iteration
backdict = ss.copy()
for t in reversed(range(T)):
# be careful: if you include vars from self.backward variables in kwargs, agents will use them!
backdict.update({k: v[t,...] for k, v in kwargs.items()})
individual = {k: v for k, v in zip(self.all_outputs_order,
self.back_step_fun(**self.make_inputs(backdict)))}
backdict.update({k: individual[k] for k in self.backward})
for k in self.non_back_outputs:
individual_paths[k][t, ...] = individual[k]
D_path = np.empty((T,) + D.shape)
D_path[0, ...] = D
for t in range(T-1):
# have to interpolate policy separately for each t to get sparse transition matrices
sspol_i = {}
sspol_pi = {}
for pol in self.policy:
if monotonic:
# TODO: change for two-asset case so assumption is monotonicity in own asset, not anything else
sspol_i[pol], sspol_pi[pol] = utils.interpolate_coord(grid[pol], individual_paths[pol][t, ...])
else:
sspol_i[pol], sspol_pi[pol] = utils.interpolate_coord_robust(grid[pol], individual_paths[pol][t, ...])
# step forward
D_path[t+1, ...]= self.forward_step(D_path[t, ...], Pi_T, sspol_i, sspol_pi)
# obtain aggregates of all outputs, made uppercase
aggregates = {k.upper(): utils.fast_aggregate(D_path, individual_paths[k]) for k in self.non_back_outputs}
# return either this, or also include distributional information
if returnindividual:
return {**aggregates, **individual_paths, 'D': D_path}
else:
return aggregates
if D_seed is None:
# compute stationary distribution for exogenous variable
pi = utils.stationary(Pi, pi_seed)
# now initialize full distribution with this, assuming uniform distribution on endogenous vars
endogenous_dims = [grid[k].shape[0] for k in self.policy]
D = np.tile(pi, endogenous_dims[::-1] + [1]).T / np.prod(endogenous_dims)
else:
D = D_seed
# obtain interpolated policy rule for each dimension of endogenous policy
sspol_i = {}
sspol_pi = {}
for pol in self.policy:
# use robust binary search-based method that only requires grids, not policies, to be monotonic
sspol_i[pol], sspol_pi[pol] = utils.interpolate_coord_robust(grid[pol], sspol[pol])
# iterate until convergence by tol, or maxit
Pi_T = Pi.T.copy()
for it in range(maxit):
Dnew = self.forward_step(D, Pi_T, sspol_i, sspol_pi)
# only check convergence every 10 iterations for efficiency
if it % 10 == 0 and utils.within_tolerance(D, Dnew, tol):
break
D = Dnew
else:
print(f'No convergence after {maxit} forward iterations!')
return D