def test_time_iteration_spline():
import time
from dolo import yaml_import, time_iteration
filename = 'examples/models/rbc.yaml'
model = yaml_import(filename)
print(model.__class__)
dr = time_iteration(model, pert_order=1, maxit=5, interp_type='spline', verbose=True)
dr = time_iteration(model, pert_order=1, maxit=5, interp_type='spline', verbose=True, interp_orders=[100,100])
def test_custom_dr():
from dolo import yaml_import, simulate, time_iteration
import numpy as np
from dolo.numeric.decision_rule import CustomDR
model = yaml_import('examples/models/rbc.yaml')
values = {'n': '0.33 + z*0.01', 'i': 'delta*k-0.07*(k-9.35497829)'}
edr = CustomDR(values, model)
m0, s0 = model.calibration['exogenous', 'controls']
edr(m0, s0)
sim = simulate(model, edr, s0=np.array([0.0, 8.0]))
time_iteration(model, initial_guess=edr)
def test_custom_dr():
from dolo import yaml_import, simulate, time_iteration
import numpy as np
from dolo.numeric.decision_rule import CustomDR
model = yaml_import("examples/models/rbc.yaml")
values = {"n": "0.33 + z*0.01", "i": "delta*k-0.07*(k-9.35497829)"}
edr = CustomDR(values, model)
m0, s0 = model.calibration["exogenous", "controls"]
edr(m0, s0)
sim = simulate(model, edr, s0=np.array([0.0, 8.0]))
time_iteration(model, dr0=edr)
def test_time_iteration_smolyak():
from dolo import yaml_import, time_iteration
filename = 'examples/models/rbc.yaml'
model = yaml_import(filename)
import time
dr = time_iteration(model, pert_order=1, maxit=500, verbose=True)
def equilibrium(
hmodel,
m0: "vector",
S0=None,
X0: "vector" = None,
p=None,
dr0=None,
grids=None,
verbose=False,
return_equilibrium=True,
):
if p is None:
p = hmodel.calibration["parameters"]
if S0 is None:
q0 = hmodel.projection(m0, X0, p)
else:
q0 = hmodel.projection(m0, S0, X0, p)
dp = inject_process(q0, hmodel.model.exogenous)
sol = time_iteration(hmodel.model,
dr0=dr0,
dprocess=dp,
maxit=10,
verbose=verbose)
sol = improved_time_iteration(hmodel.model,
dr0=sol,
dprocess=dp,
verbose=verbose)
dr = sol.dr
if grids is None:
exg, edg = grids = dr.exo_grid, dr.endo_grid
else:
exg, edg = grids
Π0, μ0 = ergodic_distribution(hmodel.model, dr, exg, edg, dp)
s = edg.nodes
if exg.n_nodes == 0:
nn = 1
μμ0 = μ0.data[None, :]
else:
nn = exg.n_nodes
μμ0 = μ0.data
xx0 = np.concatenate(
[e[None, :, :] for e in [dr(i, s) for i in range(nn)]], axis=0)
res = hmodel.𝒜(grids, m0, μμ0, xx0, X0, m0, X0, p, S0=S0, S1=S0)
if return_equilibrium:
return (res, sol, μ0, Π0)
else:
return res
def test_time_iteration_smolyak():
from dolo import yaml_import, time_iteration
filename = 'examples/models/rbc.yaml'
model = yaml_import(filename)
import time
dr = time_iteration(model, pert_order=1, maxit=500, smolyak_order=3, verbose=True)
def test_time_iteration_spline():
import time
from dolo import yaml_import, time_iteration
filename = 'examples/models/compat/rbc.yaml'
model = yaml_import(filename)
print(model.__class__)
dr = time_iteration(model, pert_order=1, maxit=5, verbose=True)
def get_starting_rule(self, method="improved_time_iteration", **kwargs):
# provides initial guess for d.r. by solving agent's problem
dp = self.model.exogenous.discretize()
# dr0 = time_iteration(self.model, dprocess=mc)
if method == "improved_time_iteration":
sol = improved_time_iteration(self.model, dprocess=dp, **kwargs)
elif method == "time_iteration":
sol = time_iteration(self.model, dprocess=dp, **kwargs)
dr0 = sol.dr
return dr0
def test_global_solution(self):
from dolo import yaml_import, time_iteration
filename = 'examples/models/rbc.yaml'
model = yaml_import(filename)
import time
t1 = time.time()
dr = time_iteration(model, pert_order=1, maxit=5, verbose=True)
def test_time_iteration_spline():
import time
from dolo import yaml_import, time_iteration
filename = 'examples/models/compat/rbc.yaml'
model = yaml_import(filename)
print(model.__class__)
dr = time_iteration(model, pert_order=1, maxit=5, verbose=True)
def get_starting_rule(self, method='improved_time_iteration', **kwargs):
# provides initial guess for d.r. by solving agent's problem
mc = self.model.exogenous.discretize(
to='mc', options=[{}, self.discretization_options])
# dr0 = time_iteration(self.model, dprocess=mc)
if method == 'improved_time_iteration':
sol = improved_time_iteration(self.model, dprocess=mc, **kwargs)
elif method == 'time_iteration':
sol = time_iteration(self.model, dprocess=mc, **kwargs)
dr0 = sol.dr
return dr0
def finite_time_iteration():
from dolo import yaml_import, time_iteration
from dolo.numeric.decision_rule import CustomDR
import matplotlib.pyplot as plt
model = yaml_import("examples/models/consumption_savings_iid.yaml")
# in the near future this will become:
# """c[t] = w[t]"""
values = {"c": "w"}
edr = CustomDR(values, model)
sol = time_iteration(model, dr0=edr, maxit=5, trace=True)
def test_global_solution(self):
from dolo import yaml_import, time_iteration
filename = 'examples/models/rbc.yaml'
model = yaml_import(filename)
import time
t1 = time.time()
dr = time_iteration(model, pert_order=1, maxit=5, interp_type='spline', verbose=True)
def test_eval_formula():
from dolo.compiler.eval_formula import eval_formula
from dolo import yaml_import, time_iteration, simulate
model = yaml_import('examples/models/rbc.yaml')
dr = time_iteration(model)
sim = simulate(model, dr)
sim = sim.sel(N=0)
sim = sim.to_pandas()
rr = eval_formula("delta*k-i", sim, context=model.calibration)
rr = eval_formula("y(1) - y", sim, context=model.calibration)
sim['diff'] = model.eval_formula("delta*k-i", sim)
model.eval_formula("y(1) - y", sim)
sim['ddiff'] = model.eval_formula("diff(1)-diff(-1)", sim)
# see what can be done
aggmodel.features
# %%
# %% [markdown]
# First we can check whether the one-agent sub-part of it works, or whether we will need to find better initial guess.
# %%
from dolo import time_iteration
i_opts = {
"N": 2
} # discretization options, consistent, with current implementation of aggregate perturbation
model = aggmodel.model
mc = model.exogenous.discretize(to='mc', options=[{}, i_opts])
sol0 = time_iteration(model, details=True, dprocess=mc)
# %%
# We can now solve for the aggregate equilibrium
eq = find_steady_state(aggmodel)
eq
# %%
# lot's look at the aggregate equilibrium
for i in range(eq.μ.shape[0]):
s = eq.dr.endo_grid.nodes() # grid for states (temporary)
plt.plot(s,
eq.μ[i, :] * (eq.μ[i, :].sum()),
label=f"y={eq.dr.exo_grid.node(i)[2]: .2f}")
plt.plot(s, eq.μ.sum(axis=0), label='total', color='black')
plt.grid()
dis_iids.append(hmodel.agent.exogenous.processes[i].discretize(to='iid'))
df1 = pd.DataFrame([[w, x[0]] for w, x in dis_iids[0].iteritems(0)],
columns=['w', 'x']) #constant
df2 = pd.DataFrame([[w, x[0]] for w, x in dis_iids[1].iteritems(0)],
columns=['w', 'x'])
df3 = pd.DataFrame([[w, x[0]] for w, x in dis_iids[2].iteritems(0)],
columns=['w', 'x'])
alt.Chart(df2, title='Ψ').mark_bar().encode(x='x', y='w') & alt.Chart(
df3, title="Ξ").mark_bar().encode(x='x', y='w')
# Agents' decision rule is not correct yet
from dolo import time_iteration, improved_time_iteration
dr = time_iteration(hmodel.agent)
# # %time dr = improved_time_iteration(hmodel.model, dr0=dr, verbose=True, details=False)
from dolo import tabulate
tab = tabulate(hmodel.agent, dr, 'm')
plt.plot(tab['m'], tab['c'])
# ergodic distribution (premature)
Π, μ = ergodic_distribution(hmodel.model, dr)
df_μ = μ.to_dataframe('μ').reset_index()
ch = alt.Chart(tab)
g1 = ch.mark_line(color='black',strokeDash=[1,1]).encode(x='m', y='m') + \
# we sum all agents of a given type across the exogenous dimension
plt.plot(s, dens, label=f"β={dist[i][1]['β']:.3f}")
i += 1
plt.grid()
# Looked like the patient agents were diverging but that was because the k grid was not large enough.
# They are rich, but looks like not diverging. (This reminds me: What is assumed about the distribution of assets beyond the upper cutoff?) If we can recover the equilibrium interest rate, we can be sure: without growth, the impatience condition is R β < 1
# ### we can do the same by hand
from tqdm import tqdm_notebook as tqdm
import numpy as np
from dolo import time_iteration
dp = hmodel2.model.exogenous.discretize(to='mc')
dr0 = time_iteration(hmodel2.model, dprocess=dp, verbose=False)
from dolark.equilibrium import equilibrium as equilibrium_fun
m0 = hmodel2.calibration['exogenous']
kvec = np.linspace(30, 40, 20)
resids = []
# we compute market residual by agent
for w, kwargs in tqdm(dist):
hmodel2.model.set_calibration(**kwargs)
res = [
equilibrium_fun(hmodel2,
m0,
np.array([k]),
dr0=dr0,
return_equilibrium=False) for k in kvec
]