def __discretize_gh__(self, N=5): # Gauss-Hermite
# Maybe we can avoid that one by inheriting from mvNormal
from dolo.numeric.discretization.quadrature import gauss_hermite_nodes
[x, w] = gauss_hermite_nodes(N, np.array([[self.σ**2]]), mu=self.μ)
x += np.array([self.μ])[:, None]
return FiniteDistribution(x, w, origin=self)
def discretize(self, orders=None):
if orders is None:
orders = self.orders
from dolo.numeric.discretization.quadrature import gauss_hermite_nodes
[x, w] = gauss_hermite_nodes(orders, self.Sigma, mu=self.mu)
x = np.row_stack([(e + self.mu) for e in x])
return DiscretizedIIDProcess(x, w)
def discretize(self, to='iid', orders=None):
if to != "iid":
raise Exception("Not Implemented")
if orders is None:
orders = self.orders
from dolo.numeric.discretization.quadrature import gauss_hermite_nodes
[x, w] = gauss_hermite_nodes(orders, self.Sigma, mu=self.mu)
x = np.row_stack([(e + self.mu) for e in x])
return DiscretizedIIDProcess(x, w)
def denhaanerrors(model,
dr,
s0=None,
horizon=100,
n_sims=10,
seed=0,
integration_orders=None):
assert (model.model_type == 'dtcscc')
n_x = len(model.symbols['controls'])
n_s = len(model.symbols['states'])
distrib = model.get_distribution()
sigma = distrib.sigma
mean = sigma[0, :] * 0
if integration_orders is None:
integration_orders = [5] * len(mean)
[nodes, weights] = gauss_hermite_nodes(integration_orders, sigma)
if s0 is None:
s0 = model.calibration['states']
# standard simulation
simul = simulate(model,
dr,
s0,
horizon=horizon,
n_exp=n_sims,
seed=seed,
solve_expectations=False,
return_array=True)
simul_se = simulate(model,
dr,
s0,
horizon=horizon,
n_exp=n_sims,
seed=seed,
solve_expectations=True,
nodes=nodes,
weights=weights,
return_array=True)
x_simul = simul[:, n_s:n_s + n_x, :]
x_simul_se = simul_se[:, n_s:n_s + n_x, :]
diff = abs(x_simul_se - x_simul)
error_1 = (diff).max(axis=0).mean(axis=1)
error_2 = (diff).mean(axis=0).mean(axis=1)
d = dict(max_errors=error_1,
mean_errors=error_2,
horizon=horizon,
n_sims=n_sims)
return DenHaanErrors(d)
def discretize(self, N=None) -> FiniteDistribution:
if N is None:
N = 5
if isinstance(N, int):
N = [N] * self.d
from dolo.numeric.discretization.quadrature import gauss_hermite_nodes # type: ignore
[x, w] = gauss_hermite_nodes(N, self.Σ, mu=self.Μ)
x = np.row_stack([(e + self.Μ) for e in x])
return FiniteDistribution(x, w, origin=self)
def discretize(self, to='iid', N=None):
if to != "iid":
raise Exception("Not Implemented")
if N is None:
N = 5
if isinstance(N, int):
N = [N] * self.d
from dolo.numeric.discretization.quadrature import gauss_hermite_nodes
[x, w] = gauss_hermite_nodes(N, self.Σ, mu=self.μ)
x = np.row_stack([(e + self.μ) for e in x])
return DiscretizedIIDProcess(x, w)
def discretize(self, to="iid", N=None) -> FiniteDistribution:
if to == "iid":
if N is None:
N = 5
if isinstance(N, int):
N = [N] * self.d
from dolo.numeric.discretization.quadrature import gauss_hermite_nodes # type: ignore
[x, w] = gauss_hermite_nodes(N, self.Σ, mu=self.Μ)
x = np.row_stack([(e + self.Μ) for e in x])
return FiniteDistribution(x, w, origin=self)
elif to == "mc":
discr_iid = self.discretize(to="iid")
return discr_iid.discretize(to="mc")
else:
raise Exception("Not implemented.")
def discretize_gdp(self, N=3):
Σ = self.Sigma
ρ = self.rho
n_nodes = N
n_std = 2.5
n_integration_nodes = 5
try:
assert (Σ.shape[0] == 1)
except:
raise Exception("Not implemented.")
try:
assert (ρ.shape[0] == ρ.shape[1] == 1)
except:
raise Exception("Not implemented.")
ρ = ρ[0, 0]
σ = np.sqrt(Σ[0, 0])
from dolo.numeric.discretization import gauss_hermite_nodes
epsilons, weights = gauss_hermite_nodes([n_integration_nodes], Σ)
min = -n_std * (σ / (np.sqrt(1 - ρ**2)))
max = n_std * (σ / (np.sqrt(1 - ρ**2)))
from .grids import CartesianGrid
grid = CartesianGrid([min], [max], [n_nodes])
nodes = np.linspace(min, max, n_nodes)[:, None]
iweights = weights[None, :].repeat(n_nodes, axis=0)
integration_nodes = np.zeros((n_nodes, n_integration_nodes))[:, :,
None]
for i in range(n_nodes):
for j in range(n_integration_nodes):
integration_nodes[i, j, :] = ρ * nodes[i, :] + epsilons[j]
return GDP(nodes, integration_nodes, iweights, grid=grid)
def denhaanerrors(model, dr, s0=None, horizon=100, n_sims=10, seed=0,
integration_orders=None):
assert(model.model_type == 'dtcscc')
n_x = len(model.symbols['controls'])
n_s = len(model.symbols['states'])
distrib = model.get_distribution()
sigma = distrib.sigma
mean = sigma[0, :]*0
if integration_orders is None:
integration_orders = [5]*len(mean)
[nodes, weights] = gauss_hermite_nodes(integration_orders, sigma)
if s0 is None:
s0 = model.calibration['states']
# standard simulation
simul = simulate(model, dr, s0, horizon=horizon, n_exp=n_sims, seed=seed,
solve_expectations=False, return_array=True)
simul_se = simulate(model, dr, s0, horizon=horizon, n_exp=n_sims,
seed=seed, solve_expectations=True, nodes=nodes,
weights=weights, return_array=True)
x_simul = simul[:, n_s:n_s+n_x, :]
x_simul_se = simul_se[:, n_s:n_s+n_x, :]
diff = abs(x_simul_se - x_simul)
error_1 = (diff).max(axis=0).mean(axis=1)
error_2 = (diff).mean(axis=0).mean(axis=1)
d = dict(
max_errors=error_1,
mean_errors=error_2,
horizon=horizon,
n_sims=n_sims
)
return DenHaanErrors(d)
def denhaanerrors( model, dr, s0=None, horizon=100, n_sims=10, seed=0, integration_orders=None):
assert(model.model_type in ('fg', 'fga'))
from dolo.numeric.discretization.quadrature import gauss_hermite_nodes
from dolo.algos.simulations import simulate
n_x = len(model.symbols['controls'])
n_s = len(model.symbols['states'])
sigma = model.covariances
mean = sigma[0,:]*0
if integration_orders is None:
integration_orders = [5]*len(mean)
[nodes, weights] = gauss_hermite_nodes(integration_orders, sigma)
if s0 is None:
s0 = model.calibration['states']
# standard simulation
simul = simulate(model, dr, s0, horizon=horizon, n_exp=n_sims, seed=seed, solve_expectations=False)
simul_se = simulate(model, dr, s0, horizon=horizon, n_exp=n_sims, seed=seed, solve_expectations=True, nodes=nodes, weights=weights)
x_simul = simul[:,n_s:n_s+n_x,:]
x_simul_se = simul_se[:,n_s:n_s+n_x,:]
diff = abs( x_simul_se - x_simul )
error_1 = (diff).max(axis=0).mean(axis=1)
error_2 = (diff).mean(axis=0).mean(axis=1)
d = dict(
max_errors=error_1,
mean_errors=error_2,
horizon=horizon,
n_sims=n_sims
)
return DenHaanErrors(d)
def __discretize_gh__(self, N=5): # Gauss-Hermite
from dolo.numeric.discretization.quadrature import gauss_hermite_nodes
[x, w] = gauss_hermite_nodes(N, np.array([[self.σ**2]]), mu=self.μ)
x = np.row_stack( [(e + self.μ) for e in x] )
return DiscretizedIIDProcess(x, w)
def discretize(self, orders=None):
if orders is None:
orders = self.orders
from dolo.numeric.discretization.quadrature import gauss_hermite_nodes
[x, w] = gauss_hermite_nodes(orders, self.sigma, mu=self.mu)
return [x, w]
def discretize(self, orders=None):
if orders is None:
orders = self.orders
from dolo.numeric.discretization.quadrature import gauss_hermite_nodes
[x, w] = gauss_hermite_nodes(orders, self.sigma, mu=self.mu)
return [x, w]
