def __update_from_symbolic__(self): import numpy # updates calibration according to the symbolic definitions system = self.symbolic.calibration_dict from dolo.compiler.triangular_solver import solve_triangular_system self.calibration_dict = solve_triangular_system( system ) from dolo.compiler.misc import CalibrationDict, calibration_to_vector calib = calibration_to_vector(self.symbols, self.calibration_dict) self.calibration = CalibrationDict(self.symbols, calib) from .symbolic_eval import NumericEval evaluator = NumericEval(self.calibration_dict) # read symbolic structure self.options = evaluator.eval(self.symbolic.options) distribution = evaluator.eval(self.symbolic.distribution) discrete_transition = evaluator.eval(self.symbolic.discrete_transition) covariances = distribution if distribution is None: self.covariances = None else: self.covariances = numpy.atleast_2d(numpy.array(covariances, dtype=float)) markov_chain = discrete_transition if markov_chain is None: self.markov_chain = None else: self.markov_chain = [numpy.atleast_2d(numpy.array(tab, dtype=float)) for tab in markov_chain]
def __update_from_symbolic__(self): import numpy # updates calibration according to the symbolic definitions system = self.symbolic.calibration_dict from dolo.compiler.triangular_solver import solve_triangular_system self.calibration_dict = solve_triangular_system( system ) from dolo.compiler.misc import calibration_to_vector self.calibration = calibration_to_vector(self.symbols, self.calibration_dict) from symbolic_eval import NumericEval evaluator = NumericEval(self.calibration_dict) # read symbolic structure covariances = evaluator.eval(self.symbolic.covariances) if covariances is None: self.covariances = covariances else: self.covariances = numpy.atleast_2d(numpy.array(covariances, dtype=float)) markov_chain = evaluator.eval(self.symbolic.markov_chain) if markov_chain is None: self.markov_chain = None else: self.markov_chain = [numpy.atleast_2d(numpy.array(tab, dtype=float)) for tab in markov_chain] self.options = evaluator.eval(self.symbolic.options)
def calibration_to_vector(symbols, calibration_dict): from dolo.compiler.triangular_solver import solve_triangular_system sol = solve_triangular_system(calibration_dict) calibration = OrderedDict() for group in symbols: calibration[group] = numpy.array([sol[s] for s in symbols[group]], dtype=float) return calibration
def calibration_to_vector(symbols, calibration_dict): from dolo.compiler.triangular_solver import solve_triangular_system from numpy import nan sol = solve_triangular_system(calibration_dict) calibration = OrderedDict() for group in symbols: t = numpy.array([sol.get(s, nan) for s in symbols[group]], dtype=float) calibration[group] = t return calibration
def calibration_to_vector(symbols, calibration_dict): from dolo.compiler.triangular_solver import solve_triangular_system from numpy import nan sol = solve_triangular_system(calibration_dict) calibration = dict() for group in symbols: t = numpy.array([sol.get(s, nan) for s in symbols[group]], dtype=float) calibration[group] = t return calibration
def test_solve_symbolic_system(self): from dolo.compiler.triangular_solver import solve_triangular_system [w, x, y, z, t] = vars = ['w', 'x', 'y', 'z', 't'] eqs = ['x + y + z + t', 'y + z', 'z', '1', '1'] sdict = {s: eqs[i] for i, s in enumerate(vars)} solution = solve_triangular_system(sdict) assert (solution['z'] == 1) assert (solution['t'] == 1) assert (solution['y'] == 1) assert (solution['x'] == 2) assert (solution['w'] == 5)
def __update_from_symbolic__(self): import numpy # updates calibration according to the symbolic definitions system = self.symbolic.calibration_dict from dolo.compiler.triangular_solver import solve_triangular_system self.calibration_dict = solve_triangular_system(system) from dolo.compiler.misc import CalibrationDict, calibration_to_vector calib = calibration_to_vector(self.symbols, self.calibration_dict) self.calibration = CalibrationDict(self.symbols, calib) from .symbolic_eval import NumericEval evaluator = NumericEval(self.calibration_dict) # read symbolic structure self.options = evaluator.eval(self.symbolic.options) self.exogenous = self.get_exogenous() self.domain = self.get_domain()
def __update_from_symbolic__(self): import numpy # updates calibration according to the symbolic definitions system = self.symbolic.calibration_dict from dolo.compiler.triangular_solver import solve_triangular_system self.calibration_dict = solve_triangular_system( system ) from dolo.compiler.misc import CalibrationDict, calibration_to_vector calib = calibration_to_vector(self.symbols, self.calibration_dict) self.calibration = CalibrationDict(self.symbols, calib) from .symbolic_eval import NumericEval evaluator = NumericEval(self.calibration_dict) # read symbolic structure self.options = evaluator.eval(self.symbolic.options) # # distribution = evaluator.eval(self.symbolic.options.get('distribution')) # discrete_transition = evaluator.eval(self.symbolic.options.get('discrete_transition')) distribution = self.options.get('distribution') discrete_transition = self.options.get('discrete_transition') self.distribution = distribution self.discrete_transition = discrete_transition if distribution is None: self.covariances = None else: self.covariances = numpy.atleast_2d(numpy.array(distribution.sigma, dtype=float)) markov_chain = discrete_transition if markov_chain is None: self.markov_chain = None else: markov_chain = [markov_chain.P, markov_chain.Q] self.markov_chain = [numpy.atleast_2d(numpy.array(tab, dtype=float)) for tab in markov_chain]
def test_solve_symbolic_system(self): from dolo.compiler.triangular_solver import solve_triangular_system [w,x,y,z,t] = vars = ['w', 'x', 'y', 'z', 't'] eqs = [ 'x + y + z + t', 'y + z', 'z', '1', '1' ] sdict = {s:eqs[i] for i,s in enumerate(vars) } solution = solve_triangular_system(sdict) assert(solution['z']==1) assert(solution['t']==1) assert(solution['y']==1) assert(solution['x']==2) assert(solution['w']==5)
def get_calibration(self): symbols = self.symbols calibration = self.data.get("calibration", {}) definitions = self.definitions initial_values = { 'exogenous': 0, 'expectations': 0, 'values': 0, 'controls': float('nan'), 'states': float('nan') } # variables defined by a model equation default to using these definitions initialized_from_model = { 'values': 'value', 'expectations': 'expectation', 'direct_responses': 'direct_response' } for k, v in definitions.items(): if k not in calibration: calibration[k] = v for symbol_group in symbols: if symbol_group not in initialized_from_model.keys(): if symbol_group in initial_values: default = initial_values[symbol_group] else: default = float('nan') for s in symbols[symbol_group]: if s not in calibration: calibration[s] = default from dolo.compiler.triangular_solver import solve_triangular_system return solve_triangular_system(calibration)
def __get_calibration__(self): calibration = self.data.get("calibration", {}) from dolo.compiler.triangular_solver import solve_triangular_system return solve_triangular_system(calibration)
# from dolo.compiler.import_dynare import import_dynare # model = import_dynare("/home/pablo/Downloads/EA_QUEST3.mod", output_type='json') # txt = json.dumps(model) # model['calibration'] # with open("EA_QUEST3.json",'w') as f: # json.dump(model,f) with timeit('Load json'): with open("EA_QUEST3.json") as f: model = json.load(f) with timeit("Solve triangular system"): calibration = model['calibration'] sol = solve_triangular_system(calibration) with timeit("Parse and normalize equations"): equations = model['equations'] compat = lambda s: s.replace("^", "**").replace('==','=').replace('=','==') equations = [compat(eq) for eq in equations] equations = ['{} - ({})'.format(*str.split(eq,'==')) for eq in equations] equations = [to_expr(e) for e in equations] all_symbols = sum(model['symbols'].values(), []) sds = StandardizeDatesSimple(all_symbols) equations_normalized = [sds.visit(e) for e in equations] equations_normalized_strings = [to_source(e) for e in equations_normalized]