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 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 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
