def model_to_fg(model, solve_systems=False, compiler='numpy', order=None): sgm = simple_global_representation(model, solve_systems=solve_systems) controls = sgm['controls'] states = sgm['states'] parameters = sgm['parameters'] shocks = sgm['shocks'] f_eqs = sgm['f_eqs'] g_eqs = sgm['g_eqs'] controls_f = [c(1) for c in controls] states_f = [c(1) for c in states] controls_p = [c(-1) for c in controls] states_p = [c(-1) for c in states] shocks_f = [c(1) for c in shocks] args_g = [states_p, controls_p, shocks] args_f = [states, controls, states_f, controls_f, shocks_f] if order is not None: from dolo.compiler.function_compiler import compile_function g_fun = compile_function(g_eqs, sum(args_g, []), parameters, order) f_fun = compile_function( f_eqs, sum([states, controls, states_f, controls_f], []), parameters, order) return [g_fun, f_fun] keep_auxiliary = 'a_eqs' in sgm if keep_auxiliary: # auxiliaries = sgm['auxiliaries'] a_eqs = sgm['a_eqs'] args_a = [states, controls] if compiler == 'numpy': from dolo.compiler.function_compiler import compile_multiargument_function elif compiler == 'theano': from dolo.compiler.function_compiler_theano import compile_multiargument_function elif compiler == 'numexpr': from dolo.compiler.function_compiler_numexpr import compile_multiargument_function elif compiler == 'numba': from dolo.compiler.function_compiler_numba import compile_multiargument_function elif compiler == 'numba_gpu': from dolo.compiler.function_compiler_numba_gpu import compile_multiargument_function else: raise Exception('Unknown compiler type : {}'.format(compiler)) g = compile_multiargument_function(g_eqs, args_g, ['s', 'x', 'e'], parameters, 'g') f = compile_multiargument_function(f_eqs, args_f, ['s', 'x', 'snext', 'xnext', 'e'], parameters, 'f') if keep_auxiliary: a = compile_multiargument_function(a_eqs, args_a, ['s', 'x'], parameters, 'a') return [f, g, a] else: return [f, g]
def model_to_fg(model, solve_systems=False, compiler='numpy', order=None): sgm = simple_global_representation(model, solve_systems=solve_systems) controls = sgm['controls'] states = sgm['states'] parameters = sgm['parameters'] shocks = sgm['shocks'] f_eqs = sgm['f_eqs'] g_eqs = sgm['g_eqs'] controls_f = [c(1) for c in controls] states_f = [c(1) for c in states] controls_p = [c(-1) for c in controls] states_p = [c(-1) for c in states] shocks_f = [c(1) for c in shocks] args_g = [states_p, controls_p, shocks] args_f = [states, controls, states_f, controls_f, shocks_f] if order is not None: from dolo.compiler.function_compiler import compile_function g_fun = compile_function( g_eqs, sum(args_g, []), parameters, order ) f_fun = compile_function( f_eqs, sum([states, controls, states_f, controls_f], []), parameters, order ) return [g_fun, f_fun] keep_auxiliary = 'a_eqs' in sgm if keep_auxiliary: # auxiliaries = sgm['auxiliaries'] a_eqs = sgm['a_eqs'] args_a = [states, controls] if compiler=='numpy': from dolo.compiler.function_compiler import compile_multiargument_function elif compiler == 'theano': from dolo.compiler.function_compiler_theano import compile_multiargument_function elif compiler == 'numexpr': from dolo.compiler.function_compiler_numexpr import compile_multiargument_function elif compiler == 'numba': from dolo.compiler.function_compiler_numba import compile_multiargument_function elif compiler == 'numba_gpu': from dolo.compiler.function_compiler_numba_gpu import compile_multiargument_function else: raise Exception('Unknown compiler type : {}'.format(compiler)) g = compile_multiargument_function(g_eqs, args_g, ['s','x','e'], parameters, 'g' ) f = compile_multiargument_function(f_eqs, args_f, ['s','x','snext','xnext','e'], parameters, 'f' ) if keep_auxiliary: a = compile_multiargument_function(a_eqs, args_a, ['s','x'], parameters, 'a' ) return [f,g,a] else: return [f,g]
def model_to_fg(model, solve_systems=False, compiler='numpy', order=None): sgm = simple_global_representation(model, solve_systems=solve_systems) controls = sgm['controls'] states = sgm['states'] parameters = sgm['parameters'] shocks = sgm['shocks'] f_eqs = sgm['f_eqs'] g_eqs = sgm['g_eqs'] controls_f = [c(1) for c in controls] states_f = [c(1) for c in states] controls_p = [c(-1) for c in controls] states_p = [c(-1) for c in states] shocks_f = [c(1) for c in shocks] args_g = [states_p, controls_p, shocks] args_f = [states, controls, states_f, controls_f, shocks_f] if order is not None: from dolo.compiler.function_compiler import compile_function g_fun = compile_function( g_eqs, sum(args_g, []), parameters, order ) f_fun = compile_function( f_eqs, sum([states, controls, states_f, controls_f], []), parameters, order ) return [g_fun, f_fun] keep_auxiliary = 'a_eqs' in sgm if keep_auxiliary: # auxiliaries = sgm['auxiliaries'] a_eqs = sgm['a_eqs'] args_a = [states, controls] if compiler=='numpy': from dolo.compiler.function_compiler import compile_multiargument_function elif compiler == 'theano': from dolo.compiler.function_compiler_theano import compile_multiargument_function elif compiler == 'numexpr': from dolo.compiler.function_compiler_numexpr import compile_multiargument_function else: raise Exception('Unknown compiler type : {}'.format(compiler)) g = compile_multiargument_function(g_eqs, args_g, ['s','x','e'], parameters, 'g' ) f = compile_multiargument_function(f_eqs, args_f, ['s','x','snext','xnext','e'], parameters, 'f' ) if keep_auxiliary: a = compile_multiargument_function(a_eqs, args_a, ['s','x'], parameters, 'a' ) return [f,g,a] else: return [f,g] # #def model_to_fga(model, compiler='numpy'): # # from dolo.misc.triangular_solver import solve_triangular_system # # from dolo.misc.misc import timeshift # # eq_g = model['equations_groups'] # v_g = model['variables_groups'] # # f_eqs = [eq.gap for eq in eq_g['arbitrage']] # g_eqs = [eq for eq in eq_g['transition']] # a_eqs = [eq for eq in eq_g['auxiliary']] # # # auxiliaries_2 are simply replaced in all other types of equations # a2_dict = {} # a2_dict_g = {} # # if 'auxiliary_2' in eq_g: # aux2_eqs = eq_g['auxiliary_2'] # dd = {eq.lhs: eq.rhs for eq in aux2_eqs} # dd.update( { eq.lhs(1): timeshift(eq.rhs,1) for eq in aux2_eqs } ) # dd.update( { eq.lhs(-1): timeshift(eq.rhs,-1) for eq in aux2_eqs } ) # ds = solve_triangular_system(dd) # # f_eqs = [eq.subs(ds) for eq in f_eqs] # a_eqs = [eq.subs(ds) for eq in a_eqs] # g_eqs = [eq.subs(ds) for eq in g_eqs] # # controls = v_g['controls'] # auxiliaries = v_g['auxiliary'] # states = v_g['states'] # # parameters = model.parameters # shocks = model.shocks # # dd = {eq.lhs: eq.rhs for eq in g_eqs} # ds = solve_triangular_system(dd) # g_eqs = [ds[eq.lhs] for eq in g_eqs] # # dd = {eq.lhs: eq.rhs for eq in a_eqs} # ds = solve_triangular_system(dd) # a_eqs = [ds[eq.lhs] for eq in a_eqs] # # # auxiliaries_f = [c(1) for c in auxiliaries] # auxiliaries_p = [c(-1) for c in auxiliaries] # # controls_f = [c(1) for c in controls] # states_f = [c(1) for c in states] # controls_p = [c(-1) for c in controls] # states_p = [c(-1) for c in states] # shocks_f = [c(1) for c in shocks] # # args_g = [states_p, controls_p, auxiliaries_p, shocks] # args_f = [states, controls, states_f, controls_f, auxiliaries, auxiliaries_f, shocks_f] # args_a = [states, controls] # # # if compiler=='numpy': # from dolo.compiler.compiling import compile_multiargument_function # compile_multiargument_function # elif compiler == 'theano': # from dolo.compiler.compiling_theano import compile_multiargument_function # elif compiler == 'numexpr': # from dolo.compiler.compiling_numexpr import compile_multiargument_function # # g = compile_multiargument_function(g_eqs, args_g, ['s','x','y','e'], parameters, 'g' ) # f = compile_multiargument_function(f_eqs, args_f, ['s','x','snext','xnext','y','ynext','e'], parameters, 'f' ) # a = compile_multiargument_function(a_eqs, args_a, ['s','x'], parameters, 'a' ) # # return [f,a,g]
def solve_risky_ss(model, X_bar, X_s, verbose=False): import numpy from dolo.compiler.function_compiler import compile_function import time from dolo.compiler.compiler_functions import simple_global_representation parms = model.calibration['parameters'] sigma = model.calibration['covariances'] sgm = simple_global_representation(model) states = sgm['states'] controls = sgm['controls'] shocks = sgm['shocks'] parameters = sgm['parameters'] f_eqs = sgm['f_eqs'] g_eqs = sgm['g_eqs'] g_args = [s(-1) for s in states] + [c(-1) for c in controls] + shocks f_args = states + controls + [v(1) for v in states] + [v(1) for v in controls] p_args = parameters g_fun = compile_function(g_eqs, g_args, p_args, 2) f_fun = compile_function(f_eqs, f_args, p_args, 3) epsilons_0 = np.zeros((sigma.shape[0])) from numpy import dot from dolo.numeric.tensor import sdot, mdot def residuals(X, sigma, parms, g_fun, f_fun): import numpy dummy_x = X[0:1, 0] X_bar = X[1:, 0] S_bar = X[0, 1:] X_s = X[1:, 1:] [n_x, n_s] = X_s.shape n_e = sigma.shape[0] xx = np.concatenate([S_bar, X_bar, epsilons_0]) [g_0, g_1, g_2] = g_fun(xx, parms) [f_0, f_1, f_2, f_3] = f_fun(np.concatenate([S_bar, X_bar, S_bar, X_bar]), parms) res_g = g_0 - S_bar # g is a first order function g_s = g_1[:, :n_s] g_x = g_1[:, n_s:n_s + n_x] g_e = g_1[:, n_s + n_x:] g_se = g_2[:, :n_s, n_s + n_x:] g_xe = g_2[:, n_s:n_s + n_x, n_s + n_x:] # S(s,e) = g(s,x,e) S_s = g_s + dot(g_x, X_s) S_e = g_e S_se = g_se + mdot(g_xe, [X_s, numpy.eye(n_e)]) # V(s,e) = [ g(s,x,e) ; x( g(s,x,e) ) ] V_s = np.row_stack([S_s, dot(X_s, S_s)]) # *** V_e = np.row_stack([S_e, dot(X_s, S_e)]) V_se = np.row_stack([S_se, dot(X_s, S_se)]) # v(s) = [s, x(s)] v_s = np.row_stack([numpy.eye(n_s), X_s]) # W(s,e) = [xx(s,e); yy(s,e)] W_s = np.row_stack([v_s, V_s]) #return nn = n_s + n_x f_v = f_1[:, :nn] f_V = f_1[:, nn:] f_1V = f_2[:, :, nn:] f_VV = f_2[:, nn:, nn:] f_1VV = f_3[:, :, nn:, nn:] # E = lambda v: np.tensordot(v, sigma, axes=((2,3),(0,1)) ) # expectation operator F = f_0 + 0.5 * np.tensordot( mdot(f_VV, [V_e, V_e]), sigma, axes=((1, 2), (0, 1))) F_s = sdot(f_1, W_s) f_see = mdot(f_1VV, [W_s, V_e, V_e]) + 2 * mdot(f_VV, [V_se, V_e]) F_s += 0.5 * np.tensordot(f_see, sigma, axes=( (2, 3), (0, 1))) # second order correction resp = np.row_stack( [np.concatenate([dummy_x, res_g]), np.column_stack([F, F_s])]) return resp # S_bar = s_fun_init( numpy.atleast_2d(X_bar).T ,parms).flatten() # S_bar = S_bar.flatten() S_bar = model.calibration['states'] S_bar = np.array(S_bar) X0 = np.row_stack( [np.concatenate([np.zeros(1), S_bar]), np.column_stack([X_bar, X_s])]) fobj = lambda X: residuals(X, sigma, parms, g_fun, f_fun) if verbose: val = fobj(X0) print('val') print(val) # exit() t = time.time() sol = solver(fobj, X0, method='lmmcp', verbose=verbose, options={ 'preprocess': False, 'eps1': 1e-15, 'eps2': 1e-15 }) if verbose: print('initial guess') print(X0) print('solution') print sol print('initial residuals') print(fobj(X0)) print('residuals') print fobj(sol) s = time.time() if verbose: print('Elapsed : {0}'.format(s - t)) #sol = solver(fobj,X0, method='fsolve', verbose=True, options={'preprocessor':False}) norm = lambda x: numpy.linalg.norm(x, numpy.inf) if verbose: print("Initial error: {0}".format(norm(fobj(X0)))) print("Final error: {0}".format(norm(fobj(sol)))) print("Solution") print(sol) X_bar = sol[1:, 0] S_bar = sol[0, 1:] X_s = sol[1:, 1:] # compute transitions n_s = len(states) n_x = len(controls) [g, dg, junk] = g_fun(np.concatenate([S_bar, X_bar, epsilons_0]), parms) g_s = dg[:, :n_s] g_x = dg[:, n_s:n_s + n_x] P = g_s + dot(g_x, X_s) if verbose: eigenvalues = numpy.linalg.eigvals(P) print eigenvalues eigenvalues = [abs(e) for e in eigenvalues] eigenvalues.sort() print(eigenvalues) return [S_bar, X_bar, X_s, P]
def solve_risky_ss(model, X_bar, X_s, verbose=False): import numpy from dolo.compiler.function_compiler import compile_function import time from dolo.compiler.compiler_functions import simple_global_representation parms = model.calibration['parameters'] sigma = model.calibration['covariances'] sgm = simple_global_representation(model) states = sgm['states'] controls = sgm['controls'] shocks = sgm['shocks'] parameters = sgm['parameters'] f_eqs = sgm['f_eqs'] g_eqs = sgm['g_eqs'] g_args = [s(-1) for s in states] + [c(-1) for c in controls] + shocks f_args = states + controls + [v(1) for v in states] + [v(1) for v in controls] p_args = parameters g_fun = compile_function(g_eqs, g_args, p_args, 2) f_fun = compile_function(f_eqs, f_args, p_args, 3) epsilons_0 = np.zeros((sigma.shape[0])) from numpy import dot from dolo.numeric.tensor import sdot,mdot def residuals(X, sigma, parms, g_fun, f_fun): import numpy dummy_x = X[0:1,0] X_bar = X[1:,0] S_bar = X[0,1:] X_s = X[1:,1:] [n_x,n_s] = X_s.shape n_e = sigma.shape[0] xx = np.concatenate([S_bar, X_bar, epsilons_0]) [g_0, g_1, g_2] = g_fun(xx, parms) [f_0,f_1,f_2,f_3] = f_fun( np.concatenate([S_bar, X_bar, S_bar, X_bar]), parms) res_g = g_0 - S_bar # g is a first order function g_s = g_1[:,:n_s] g_x = g_1[:,n_s:n_s+n_x] g_e = g_1[:,n_s+n_x:] g_se = g_2[:,:n_s,n_s+n_x:] g_xe = g_2[:, n_s:n_s+n_x, n_s+n_x:] # S(s,e) = g(s,x,e) S_s = g_s + dot(g_x, X_s) S_e = g_e S_se = g_se + mdot(g_xe,[X_s, numpy.eye(n_e)]) # V(s,e) = [ g(s,x,e) ; x( g(s,x,e) ) ] V_s = np.row_stack([ S_s, dot( X_s, S_s ) ]) # *** V_e = np.row_stack([ S_e, dot( X_s, S_e ) ]) V_se = np.row_stack([ S_se, dot( X_s, S_se ) ]) # v(s) = [s, x(s)] v_s = np.row_stack([ numpy.eye(n_s), X_s ]) # W(s,e) = [xx(s,e); yy(s,e)] W_s = np.row_stack([ v_s, V_s ]) #return nn = n_s + n_x f_v = f_1[:,:nn] f_V = f_1[:,nn:] f_1V = f_2[:,:,nn:] f_VV = f_2[:,nn:,nn:] f_1VV = f_3[:,:,nn:,nn:] # E = lambda v: np.tensordot(v, sigma, axes=((2,3),(0,1)) ) # expectation operator F = f_0 + 0.5*np.tensordot( mdot(f_VV,[V_e,V_e]), sigma, axes=((1,2),(0,1)) ) F_s = sdot(f_1, W_s) f_see = mdot(f_1VV, [W_s, V_e, V_e]) + 2*mdot(f_VV, [V_se, V_e]) F_s += 0.5 * np.tensordot(f_see, sigma, axes=((2,3),(0,1)) ) # second order correction resp = np.row_stack([ np.concatenate([dummy_x,res_g]), np.column_stack([F,F_s]) ]) return resp # S_bar = s_fun_init( numpy.atleast_2d(X_bar).T ,parms).flatten() # S_bar = S_bar.flatten() S_bar = model.calibration['states'] S_bar = np.array(S_bar) X0 = np.row_stack([ np.concatenate([np.zeros(1),S_bar]), np.column_stack([X_bar,X_s]) ]) fobj = lambda X: residuals(X, sigma, parms, g_fun, f_fun) if verbose: val = fobj(X0) print('val') print(val) # exit() t = time.time() sol = solver(fobj,X0, method='lmmcp', verbose=verbose, options={'preprocess':False, 'eps1':1e-15, 'eps2': 1e-15}) if verbose: print('initial guess') print(X0) print('solution') print sol print('initial residuals') print(fobj(X0)) print('residuals') print fobj(sol) s = time.time() if verbose: print('Elapsed : {0}'.format(s-t)) #sol = solver(fobj,X0, method='fsolve', verbose=True, options={'preprocessor':False}) norm = lambda x: numpy.linalg.norm(x,numpy.inf) if verbose: print( "Initial error: {0}".format( norm( fobj(X0)) ) ) print( "Final error: {0}".format( norm( fobj(sol) ) ) ) print("Solution") print(sol) X_bar = sol[1:,0] S_bar = sol[0,1:] X_s = sol[1:,1:] # compute transitions n_s = len(states) n_x = len(controls) [g, dg, junk] = g_fun( np.concatenate( [S_bar, X_bar, epsilons_0] ), parms) g_s = dg[:,:n_s] g_x = dg[:,n_s:n_s+n_x] P = g_s + dot(g_x, X_s) if verbose: eigenvalues = numpy.linalg.eigvals(P) print eigenvalues eigenvalues = [abs(e) for e in eigenvalues] eigenvalues.sort() print(eigenvalues) return [S_bar, X_bar, X_s, P]