def lqapprox(self, s0, x0): """ Solves discrete time continuous state/action dynamic programming model using a linear quadratic approximation Args: s0: steady-state state x0: steady-state action Returns: A LQmodel object """ assert (self.dims.ni * self.dims.nj < 2), 'Linear-Quadratic not implemented for models with discrete state or choice' s0, x0 = np.atleast_1d(s0, x0) assert s0.size == self.dims.ds, 's0 must have %d values' % self.dims.ds assert x0.size == self.dims.dx, 'x0 must have %d values' % self.dims.dx s0, x0 = s0.astype(float), x0.astype(float) s0.shape = -1, 1 x0.shape = -1, 1 delta = self.time.discount # Fix shock at mean estar = self.random.w @ self.random.e.T estar.shape = -1, 1 # Get derivatives f0, fx, fxx = self.reward(s0, x0, None, None, True) g0, gx, gxx = self.transition(s0, x0, None, None, None, estar, derivative=True) fs = jacobian(lambda y: self.reward(y.reshape((-1, 1)), x0, None, None), s0) fxs = jacobian(lambda y: self.reward(y.reshape((-1, 1)), x0, None, None, True)[1], s0) fss = hessian(lambda y: self.reward(y.reshape((-1, 1)), x0, None, None), s0) gs = jacobian(lambda y: self.transition(y.reshape((-1, 1)), x0, None, None, None, estar), s0) # Reshape to ensure conformability ds, dx = self.dims['ds', 'dx'] f0.shape = 1, 1 s0.shape = ds, 1 x0.shape = dx, 1 fs.shape = 1, ds fx.shape = 1, dx fss.shape = ds, ds fxs.shape = dx, ds fxx.shape = dx, dx g0.shape = ds, 1 gx.shape = ds, dx gs.shape = ds, ds fsx = fxs.T f0 += - fs @ s0 - fx @ x0 + 0.5 * s0.T @ fss @ s0 + s0.T @ fsx @ x0 + 0.5 * x0.T @ fxx @ x0 fs += - s0.T @ fss - x0.T @ fxs fx += - s0.T @ fsx - x0.T @ fxx g0 += - gs @ s0 - gx @ x0 return LQmodel(f0, fs, fx, fss, fsx, fxx, g0, gs, gx, delta,self.labels.s, self.labels.x)
def check_derivatives(self): ni, nj, ds, ns = self.dims['ni', 'nj', 'ds', 'ns'] nij = ni * nj idx = pd.MultiIndex.from_product([np.arange(ni), np.arange(nj)], names=['i', 'j']) F = pd.DataFrame({ 'fx': np.zeros(nij) + np.nan, 'fxx': np.zeros(nij) + np.nan}, index=idx) idy = pd.MultiIndex.from_product([['gx', 'gxx'], np.arange(ds)], names=['func', 's']) G = pd.DataFrame(np.zeros((nij,2 * ds)), index=idx, columns=idy) s = self.Value.nodes e = np.tile(self.random.e[:, 0], ns) for k, (i, j) in enumerate(indices(ni,nj).T): xl, xu = self.bounds(s, i , j) xlinf = np.isinf(xl) xuinf = np.isinf(xu) xm = (xl + xu) / 2 xm[xlinf] = xu[xlinf] xm[xuinf] = xl[xuinf] xm[xuinf & xlinf] = 0.0 f, fx, fxx = self.reward(s,xm,i,j, derivative=True) fxa = jacobian(lambda z: self.reward(s, z, i, j), xm) fxxa = hessian(lambda z: self.reward(s, z, i, j), xm) #FIXME: HESSIAN SEEMS TO BE THROWING WRONG DIMENSIONS!! F.values[k, 0] = np.linalg.norm(fx - fxa, np.inf) F.values[k, 1] = np.linalg.norm(fxx - fxxa, np.inf)
def ss2(x, r, tau): tmp = lambda x: ss(x, r, tau) return jacobian(tmp, x)[0]
def ss2(x, r, tau): tmp = lambda x: ss(x, r, tau) return jacobian(tmp, x)[0]
def lqapprox(self, s0, x0, steady=False): assert ( self.dims.ni * self.dims.nj < 2 ), 'Linear-Quadratic not implemented for models with discrete state or choice' s0, x0 = np.atleast_1d(s0, x0) assert s0.size == self.dims.ds, 's0 must have %d values' % self.dims.ds assert x0.size == self.dims.dx, 'x0 must have %d values' % self.dims.dx s0, x0 = s0.astype(float), x0.astype(float) s0.shape = -1, 1 x0.shape = -1, 1 delta = self.time.discount # Fix shock at mean estar = self.random.w @ self.random.e.T estar.shape = -1, 1 # Get derivatives f0, fx, fxx = self.reward(s0, x0, None, None, True) g0, gx, gxx = self.transition(s0, x0, None, None, None, estar, derivative=True) fs = jacobian( lambda y: self.reward(y.reshape((-1, 1)), x0, None, None), s0) fxs = jacobian( lambda y: self.reward(y.reshape((-1, 1)), x0, None, None, True)[1], s0) fss = hessian( lambda y: self.reward(y.reshape((-1, 1)), x0, None, None), s0) gs = jacobian( lambda y: self.transition(y.reshape( (-1, 1)), x0, None, None, None, estar), s0) # Reshape to ensure conformability ds, dx = self.dims['ds', 'dx'] f0.shape = 1, 1 s0.shape = ds, 1 x0.shape = dx, 1 fs.shape = 1, ds fx.shape = 1, dx fss.shape = ds, ds fxs.shape = dx, ds fxx.shape = dx, dx g0.shape = ds, 1 gx.shape = ds, dx gs.shape = ds, ds fsx = fxs.T f0 += -fs @ s0 - fx @ x0 + 0.5 * s0.T @ fss @ s0 + s0.T @ fsx @ x0 + 0.5 * x0.T @ fxx @ x0 fs += -s0.T @ fss - x0.T @ fxs fx += -s0.T @ fsx - x0.T @ fxx g0 += -gs @ s0 - gx @ x0 # Solve Riccati equation using QZ decomposition dx2ds = dx + 2 * ds A = np.zeros((dx2ds, dx2ds)) A[:ds, :ds] = np.identity(ds) A[ds:-ds, -ds:] = -delta * gx.T A[-ds:, -ds:] = delta * gs.T B = np.zeros_like(A) B[:ds, :-ds] = np.c_[gs, gx] B[ds:-ds, :-ds] = np.c_[fsx.T, fxx] B[-ds:] = np.c_[-fss, -fsx, np.identity(ds)] S, T, Q, Z = qzordered(A, B) C = np.real(np.linalg.solve(Z[:ds, :ds].T, Z[ds:, :ds].T)).T X = C[:dx] P = C[dx:, :] # Compute steady-state state, action, and shadow price t0 = np.r_[np.c_[fsx.T, fxx, delta * gx.T], np.c_[fss, fsx, delta * gs.T - np.eye(ds)], np.c_[gs - np.eye(ds), gx, np.zeros((ds, ds))]] t1 = np.r_[-fx.T, -fs.T, -g0] t = np.linalg.solve(t0, t1) sstar, xstar, pstar = np.split(t, [ds, ds + dx]) vstar = (f0 + fs @ sstar + fx @ xstar + 0.5 * sstar.T @ fss @ sstar + sstar.T @ fsx @ xstar + 0.5 * xstar.T @ fxx @ xstar) / (1 - delta) # Compute lq-approximation optimal policy and shadow price functions at state nodes s = self.Value.nodes.T.copy() sstar = sstar.T xstar = xstar.T pstar = pstar.T s -= sstar # hopefully broadcasting works here (np.ones(ns,1),:) #todo make sure!! xlq = xstar + s @ X.T #(np.ones(1,ns),:) plq = pstar + s @ P.T #(np.ones(1,ns),:) vlq = vstar + s @ pstar.T + 0.5 * np.sum( s * (s @ P.T), axis=1, keepdims=True) self.Value[:] = vlq.T[:] self.Value_j[:] = vlq.T[:] self.Policy[:] = xlq.T[:] self.Policy_j[:] = xlq.T[:] #MAKE PANDAS DATAFRAME ni, nj, dx = self.dims['ni', 'nj', 'dx'] sr = self.Value.nodes.copy() discrete_indices = np.indices(vlq.shape)[:2].reshape(2, -1) data = np.vstack((discrete_indices, np.tile(sr, ni * nj), vlq.T.flatten())) columns = ["i", "j" ] + self.labels.s + ['value_j' if nj > 1 else 'value'] # Add continuous action if dx: xlq = np.rollaxis(xlq, -2) xlq.shape = (dx, -1) data = np.vstack((data, xlq)) columns = columns + list(self.labels.x) data = pd.DataFrame(data.T, columns=columns) # Add value if nj > 1: data['value'] = np.nan data.value[data.j == 0] = vlq.flatten() # eliminate singleton dimensions, label non-singleton dimensions if ni > 1: data['i'] = self.__as_categorical(data.i, True) else: del data['i'] if nj > 1: data['j'] = self.__as_categorical(data.j, False) else: del data['j'] if steady: ss0 = {a: b for a, b in zip(self.labels.s, sstar)} ss0.update({a: b for a, b in zip(self.labels.x, xstar)}) ss0['value'] = vstar ss0['shadow'] = pstar return (data, ss0) if steady else data