예제 #1
0
    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)
예제 #2
0
 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)
예제 #3
0
 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)
예제 #4
0
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)
예제 #5
0
    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)
예제 #6
0
 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)
예제 #7
0
    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.")
예제 #8
0
    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)
예제 #9
0
파일: accuracy.py 프로젝트: EconForge/dolo
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)
예제 #10
0
파일: accuracy.py 프로젝트: sglyon/dolo
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)
예제 #11
0
    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)
예제 #12
0
파일: objects.py 프로젝트: jagman88/dolo
 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]
예제 #13
0
 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]