def __init__(self,Gamma): ''' Approximate the equilibrium policies given z_i ''' self.Gamma = Gamma self.ss = steadystate.steadystate(Gamma.T) #x = [] #for i in range(nz): # x.append(np.linspace(min(Gamma[:,i])-0.05,0.05+max(Gamma[:,i]),20)) #self.zgrid = Spline.makeGrid(x) #Mu = np.zeros(nz) #Sigma = np.zeros((nz,nz)) #for i in range(nz): # xmin,xmax = min(Gamma[:,i])-0.001,max(Gamma[:,i])+0.001 # Mu[i] = (xmin+xmax)/2 # Sigma[i,i] = (xmax-xmin)/2 self.interpolate = utilities.interpolator_factory(nz,3,Gamma) self.zgrid = self.interpolate.X #precompute Jacobians and Hessians self.DF = dict_fun(lambda z_i:utilities.ad_Jacobian(F,self.get_w(z_i))) self.HF = dict_fun(lambda z_i:utilities.ad_Hessian(F,self.get_w(z_i))) self.DG = dict_fun(lambda z_i:utilities.ad_Jacobian(G,self.get_w(z_i))) self.HG = dict_fun(lambda z_i:utilities.ad_Hessian(G,self.get_w(z_i))) self.df = dict_fun(lambda z_i:utilities.ad_Jacobian(f,self.get_w(z_i)[y])) self.Hf = dict_fun(lambda z_i:utilities.ad_Hessian(f,self.get_w(z_i)[y])) #linearize self.linearize() self.quadratic()
def compute_x(mu,rho,Kgrid,PRf): ''' Computes x given the policy rules ''' I,S = len(alpha),len(P) interpolate1d = interpolator_factory(['spline'],[len(Kgrid)],[3]) c1f,cif,n1f,nif,Kf,phif,xif,etaf = getQuantities(PRf) xf = [] for s in range(S): xf.append(interpolate1d(Kgrid,np.zeros((len(Kgrid),I-1))).reshape(((I-1),1))) xnew_old = [np.zeros((len(Kgrid),(I-1)))]*S diff = 1 while diff > 1e-5: xnew = [] for s_ in range(S): def xprime(k): xprime = np.zeros((I-1,S)) for s in range(S): Kprime = np.atleast_1d(Kf[s](k)) xprime[:,s] = xf[s](Kprime).flatten() return xprime xnew.append(np.zeros((len(Kgrid),I-1))) for ik in range(len(Kgrid)): k = np.array([Kgrid[ik]]) c1,ci,n1,ni = c1f(k),cif(k),n1f(k),nif(k) xnew[-1][ik,:] = beta*(Uc(ci,ni)*ci+Un(ci,ni)*ni-rho*(Uc(c1,n1)*c1+Un(c1,n1)*n1)+xprime(k)).dot(P[s_,:]) diff = 0. xf = [] for s_ in range(S): diff = max(np.amax(np.abs(xnew[s_]-xnew_old[s_])),diff) xf.append(interpolate1d(Kgrid,xnew[s_]).reshape(((I-1),1))) xnew_old = xnew return xf,xnew
def solveProblem(mu,rho,Kgrid): ''' Solves the problem for a given mu,rho using Kgrid ''' print mu,rho Kbar = [Kgrid[0],Kgrid[-1]] I,S = len(alpha),len(P) interpolate1d = interpolator_factory(['spline'],[len(Kgrid)],[3]) PRnew = iterate_on_policies(mu,rho,None,Kbar) PRs = np.vstack(map(PRnew,Kgrid)) PRf = interpolate1d(Kgrid,PRs) diff = 1. while diff >1e-5: PRnew = iterate_on_policies(mu,rho,PRf,Kbar) PRs = np.vstack(map(lambda k:PRnew(np.array([k])),Kgrid)) diff = np.amax(abs(PRs-PRf(Kgrid.reshape(-1,1)).T)) PRf = interpolate1d(Kgrid,PRs) xf,xs = compute_x(mu,rho,Kgrid,PRf) DV = compute_DV(mu,rho,Kgrid,PRf) PRCM = [] for s_ in range(S): PRCM.append([]) for ik in range(len(Kgrid)): c1,ci,n1,ni,K,phi,xi,eta = getQuantities(PRs[ik]) N = pi1*n1*theta1 + np.sum(pii*ni*thetai,0) Rk = FK(Kgrid[ik],N) PRCM[s_].append(np.hstack(( c1,ci.flatten(),n1,ni.flatten(),Rk,xs[s_][ik],np.zeros(I-1),(rho*np.ones(S)).flatten(), K,(mu*np.ones(S)).flatten(),phi.flatten(),np.zeros(I-1),np.zeros(I-1),np.zeros(S),xi,eta.flatten(), DV[s_][ik] ))) PRCM[s_] = np.vstack(PRCM[s_]) return PRCM
def solve_time1_bellman(self): ''' Solve the time 1 Bellman equation for calibration Para and initial grid mugrid0 ''' Para, mugrid0 = self.Para, self.mugrid Pi = Para.Pi S = len(Para.Pi) #First get initial fit from lucas stockey solution. #Need to change things to be ex_ante PP = LS.Planners_Allocation_Sequential(Para) interp = utilities.interpolator_factory(2, None) def incomplete_allocation(mu_, s_): c, n, x, V = PP.time1_value(mu_) return c, n, Pi[s_].dot(x), Pi[s_].dot(V) cf, nf, xgrid, Vf, xprimef = [], [], [], [], [] for s_ in range(S): c, n, x, V = zip( *map(lambda mu: incomplete_allocation(mu, s_), mugrid0)) c, n = np.vstack(c).T, np.vstack(n).T x, V = np.hstack(x), np.hstack(V) xprimes = np.vstack([x] * S) cf.append(interp(x, c)) nf.append(interp(x, n)) Vf.append(interp(x, V)) xgrid.append(x) xprimef.append(interp(x, xprimes)) cf, nf, xprimef = utilities.fun_vstack(cf), utilities.fun_vstack( nf), utilities.fun_vstack(xprimef) Vf = utilities.fun_hstack(Vf) policies = [cf, nf, xprimef] #create xgrid x = np.vstack(xgrid).T xbar = [x.min(0).max(), x.max(0).min()] xgrid = np.linspace(xbar[0], xbar[1], len(mugrid0)) self.xgrid = xgrid #Now iterate on Bellman equation T = BellmanEquation(Para, xgrid, policies) diff = 1. while diff > 1e-6: PF = T(Vf) Vfnew, policies = self.fit_policy_function(PF) diff = np.abs((Vf(xgrid) - Vfnew(xgrid)) / Vf(xgrid)).max() print diff Vf = Vfnew #store value function policies and Bellman Equations self.Vf = Vf self.policies = policies self.T = T
def solve_time1_bellman(self): ''' Solve the time 1 Bellman equation for calibration Para and initial grid mugrid0 ''' Para,mugrid0 = self.Para,self.mugrid Pi = Para.Pi S = len(Para.Pi) #First get initial fit from lucas stockey solution. #Need to change things to be ex_ante PP = LS.Planners_Allocation_Sequential(Para) interp = utilities.interpolator_factory(2,None) def incomplete_allocation(mu_,s_): c,n,x,V = PP.time1_value(mu_) return c,n,Pi[s_].dot(x),Pi[s_].dot(V) cf,nf,xgrid,Vf,xprimef = [],[],[],[],[] for s_ in range(S): c,n,x,V = zip(*map(lambda mu: incomplete_allocation(mu,s_),mugrid0)) c,n = np.vstack(c).T,np.vstack(n).T x,V = np.hstack(x),np.hstack(V) xprimes = np.vstack([x]*S) cf.append(interp(x,c)) nf.append(interp(x,n)) Vf.append(interp(x,V)) xgrid.append(x) xprimef.append(interp(x,xprimes)) cf,nf,xprimef = utilities.fun_vstack(cf), utilities.fun_vstack(nf),utilities.fun_vstack(xprimef) Vf = utilities.fun_hstack(Vf) policies = [cf,nf,xprimef] #create xgrid x = np.vstack(xgrid).T xbar = [x.min(0).max(),x.max(0).min()] xgrid = np.linspace(xbar[0],xbar[1],len(mugrid0)) self.xgrid = xgrid #Now iterate on Bellman equation T = BellmanEquation(Para,xgrid,policies) diff = 1. while diff > 1e-6: PF = T(Vf) Vfnew,policies = self.fit_policy_function(PF) diff = np.abs((Vf(xgrid)-Vfnew(xgrid))/Vf(xgrid)).max() print diff Vf = Vfnew #store value function policies and Bellman Equations self.Vf = Vf self.policies = policies self.T = T
def fit_policy_function(self,PF): ''' Fits the policy functions ''' S,xgrid = len(self.Pi),self.xgrid interp = utilities.interpolator_factory(3,0) cf,nf,xprimef,Tf,Vf = [],[],[],[],[] for s_ in range(S): PFvec = np.vstack([PF(x,s_) for x in self.xgrid]).T Vf.append(interp(xgrid,PFvec[0,:])) cf.append(interp(xgrid,PFvec[1:1+S])) nf.append(interp(xgrid,PFvec[1+S:1+2*S])) xprimef.append(interp(xgrid,PFvec[1+2*S:1+3*S])) Tf.append(interp(xgrid,PFvec[1+3*S:])) policies = utilities.fun_vstack(cf), utilities.fun_vstack(nf),utilities.fun_vstack(xprimef),utilities.fun_vstack(Tf) Vf = utilities.fun_hstack(Vf) return Vf,policies
def compute_DV(mu,rho,Kgrid,PRf): ''' Computes x given the policy rules ''' I,S = len(alpha),len(P) interpolate1d = interpolator_factory(['spline'],[len(Kgrid)],[3]) c1f,cif,n1f,nif,Kf,phif,xif,etaf = getQuantities(PRf) Vrhof = [] for s in range(S): Vrhof.append(interpolate1d(Kgrid,np.zeros((len(Kgrid),I-1))).reshape(((I-1),1))) Vrho_old = [np.zeros((len(Kgrid),(I-1)))]*S diff = 1 while diff > 1e-5: Vrho_new = [] for s_ in range(S): def Vrho_prime(k): Vrho_prime = np.zeros((I-1,S)) for s in range(S): Kprime = np.atleast_1d(Kf[s](k)) Vrho_prime[:,s] = (Vrhof[s](Kprime)).flatten() return Vrho_prime Vrho_new.append(np.zeros((len(Kgrid),I-1))) for ik in range(len(Kgrid)): k = np.array([Kgrid[ik]]) c1,n1,phi,eta = c1f(k),n1f(k),phif(k),etaf(k) Uc1,Un1 = Uc(c1,n1),Un(c1,n1) Vrho_new[-1][ik,:] = (phi*thetai*Un1 + eta*Uc1+beta*Vrho_prime(k)).dot(P[s_,:]) diff = 0. Vrhof = [] for s_ in range(S): diff = max(np.amax(np.abs(Vrho_new[s_]-Vrho_old[s_])),diff) Vrhof.append(interpolate1d(Kgrid,Vrho_new[s_]).reshape(((I-1),1))) Vrho_old = Vrho_new VK = [] for s_ in range(S): VK.append(np.zeros((len(Kgrid),1))) for ik in range(len(Kgrid)): K_ = np.array([Kgrid[ik]]) N = pi1*n1f(K_)*theta1+np.sum(pii*nif(K_)*thetai,0) VK[-1][ik] = P[s_,:].dot(FK(K_,N)*xif(K_)) DV = [] for s_ in range(S): DV.append(np.hstack((Vrho_new[s_],VK[s_]))) return DV
def solvePlannersProblemIID_parallel(PF,Para,X,mubar,rhobar,c): ''' Solves the planners problem using IPython parallel. ''' #sets up some parrallel stuff v_lb = c.load_balanced_view() v = c[:] v.block = True #calibrate model calibrateFromParaStruct(Para) v.apply(calibrateFromParaStruct,Para) interpolate3d = interpolator_factory(['spline']*3,[10,10,10],[3]*3) S = len(P) #get old policy rules PRs_old = [] for s in range(S): PRs_old.append(PF[s](X).T) #Do policy iteration diff = 1. while diff > 1e-5: PRnew = iterate_on_policies(PF,mubar,rhobar) v['PRnew'] = PRnew rPRnew = Reference('PRnew') #create a reference to the remote object PRs = [] domain = itertools.izip(X,[0]*len(X)) i_policies = v_lb.imap(rPRnew,domain) policies = [] for i,pol in enumerate(i_policies): policies.append(pol) try: PRs = [np.vstack(policies)]*S except: findFailedRoots(PRnew,policies,X,0) PRs = [np.vstack(policies)]*S diff = np.amax(np.abs((PRs[0]-PRs_old[0]))) print "diff: ",diff PF = [] for s_ in range(S): PF.append(interpolate3d(X,PRs[s_])) PRs_old[s_] = PRs[s_] return PF
def solvePlannersProblem_parallel(PF,Para,X,mubar,rhobar): ''' Solves the planners problem using IPython parallel. ''' #sets up some parrallel stuff from IPython.parallel import Client from IPython.parallel import Reference c = Client() v_lb = c.load_balanced_view() v = c[:] v.block = True #calibrate model calibrateFromParaStruct(Para) v.apply(calibrateFromParaStruct,Para) interpolate3d = interpolator_factory(['spline']*3,[10,10,10],[3]*3) S = len(P) #get old policy rules PRs_old = [] for s in range(S): PRs_old.append(PF[s](X).T) #Do policy iteration diff = 1. while diff > 1e-5: v['PRnew'] = iterate_on_policies(PF,mubar,rhobar) PRnew = Reference('PRnew') #create a reference to the remote object PRs = [] for s_ in range(S): domain = itertools.izip(X,[s_]*len(X)) policies = v_lb.imap(PRnew,domain) temp = [] for i,pr in enumerate(policies): temp.append(pr) print i PRs.append(np.vstack(temp)) diff = max(diff,np.amax(np.abs(PRs[s_]-PRs_old[s_]))) print diff PRf = [] for s_ in range(S): PRf.append(interpolate3d(X,PRs[s_])) PRs_old[s_] = PRs[s_] return PRf
def solvePlannersProblemIID(PF,Para,X,mubar,rhobar): ''' Solves the planners problem using IPython parallel. ''' #calibrate model calibrateFromParaStruct(Para) interpolate3d = interpolator_factory(['spline']*3,[10,10,10],[3]*3) S = len(P) #get old policy rules PRs_old = [] for s in range(S): PRs_old.append(PF[s](X).T) #Do policy iteration diff = 1. while diff > 1e-5: PRnew = iterate_on_policies(PF,mubar,rhobar) PRs = [] domain = itertools.izip(X,[0]*len(X)) i_policies = itertools.imap(PRnew,domain) policies = [] for i,pol in enumerate(i_policies): policies.append(pol) if i%20 == 0: print i try: PRs = [np.vstack(policies)]*S except: findFailedRoots(PRnew,policies,X,0) PRs = [np.vstack(policies)]*S diff = np.amax(np.abs((PRs[0]-PRs_old[0])/PRs[0])) print "diff: ",diff PF = [] for s_ in range(S): PF.append(interpolate3d(X,PRs[s_])) PRs_old[s_] = PRs[s_] return PF,PRs
# -*- coding: utf-8 -*- """ Created on Thu Jan 9 10:13:46 2014 @author: dgevans """ from numpy import * import cPickle import itertools import WerningProblem as WP import PlannersProblem as PP import utilities import calibration PRs,Para = cPickle.load(file('CMFlipped.dat','r')) WP.calibrateFromParaStruct(Para) PP.calibrateFromParaStruct(Para) X = Para.X muGrid = unique(X[:,0]) rhoGrid = unique(X[:,1]) Kgrid = unique(X[:,2]) S = len(Para.P) interpolate3d = utilities.interpolator_factory(['spline']*3,[10,10,10],[3]*3) PF = [interpolate3d(X,PRs[0])]*S