def find_weights(self): #trains the model on the neural network i = 1 while i < self.tp.iter + 1: self.randomize_batches() for batchdata in self.make_batch(): self.w1 = np.squeeze(self.w1) self.w2 = np.squeeze(self.w2) gn1 = self.grad_func_w1(self.w1, self.w2, batchdata) #generate gradient gn2 = self.grad_func_w2(self.w1, self.w2, batchdata) #generate gradient (self.w1, self.tp.mn1, self.tp.vn1) = self.update_weights(self.w1, self.tp.mn1, self.tp.vn1, gn1, i) #Update weight, mn, vn (self.w2, self.tp.mn2, self.tp.vn2) = self.update_weights(self.w2, self.tp.mn2, self.tp.vn2, gn2, i) #Update weight, mn, vn self.loss_array = np.concatenate( (self.loss_array, [self.loss_func(self.w1, self.w2, self.data)]), axis=0) #store value of loss at iteration # #print(self.loss_func(self.params,self.data)) i = i + 1 if i % 100 == 0: print(i)
def figure_subspace_update(self, T, x_true=None): self._fig_subspace.clf() if x_true: X_true = np.array([x_true[k] for k in range(0, T + 1)]) X_true = X_true.squeeze().T X_pred = np.array([self._mu[k] for k in range(0, T + 1)]) X_pred = X_pred.squeeze().T X_pred = X_pred.reshape(self._r, T + 1) used = set() for l in range(self._r): ax = self._fig_subspace.add_subplot(2, int((self._r + 1) / 2), l + 1) if x_true: pl = np.argmin([ np.linalg.norm(X_true[l] - X_pred[m]) if not m in used else np.inf for m in range(self._r) ]) ax.plot(np.squeeze(X_true[l, :]), color="#004488", alpha=0.7) ax.plot(np.squeeze(X_pred[pl, :]), "--", color="#bb5566") used.add(pl) else: ax.plot(np.squeeze(X_pred[l, :]), "--", color="#bb5566") ax.axis("off") plt.pause(0.01)
def fwd_model_2d(arr, x1, x2, z, R, eps, varsigma=1): """ Apply fwd model to space-time array arr (must be on grid of spatial locs); predicts at same time points as input. (Note: want dense input within integral bounds to get good results!) Output can be requested on non-grid. :param arr: matrix (nx1, nx2, nt) :param x1: x1 (nx1, 1) vector of observation spatial locations :param x2: x2 (nx2, 1) vector of observation spatial locations :param z: z (nz, 2) matrix of predicted spatial locations :param R: forward model parameter :param eps: forward model singularity parameter :param varsigma: scalar conductivity :return: matrix (nz, nt) """ nt = arr.shape[2] nz = z.shape[0] res = np.zeros((nz, nt)) for t in range(nt): arr_tmp = np.squeeze(arr[:, :, t]) # (nx1, nx2) for i in range(nz): deltax1 = z[i,0] - x1 # (nx1, 1) deltax2 = z[i,1] - x2.T # (1, nx2) wt = b_fwd_2d(deltax1, deltax2, R, eps) toint = wt * arr_tmp # (nx1, nx2) res[i, t] = scipy.integrate.trapz(scipy.integrate.trapz(toint, x=np.squeeze(x1), axis=0), x=np.squeeze(x2), axis=0) return res #/(4*np.pi*varsigma)
def backward(self, x_seq, u_seq): self.v[-1] = self.lf(x_seq[-1]) self.v_x[-1] = self.lf_x(x_seq[-1]) self.v_xx[-1] = self.lf_xx(x_seq[-1]) k_seq = [] kk_seq = [] for t in range(self.pred_time - 1, -1, -1): f_x_t = self.f_x(x_seq[t], u_seq[t]) f_u_t = self.f_u(x_seq[t], u_seq[t]) q_x = self.l_x(x_seq[t], u_seq[t]) + np.matmul(f_x_t.T, self.v_x[t + 1]) q_u = self.l_u(x_seq[t], u_seq[t]) + np.matmul(f_u_t.T, self.v_x[t + 1]) q_xx = self.l_xx(x_seq[t], u_seq[t]) + \ np.matmul(np.matmul(f_x_t.T, self.v_xx[t + 1]), f_x_t) + \ np.dot(self.v_x[t + 1], np.squeeze(self.f_xx(x_seq[t], u_seq[t]))) tmp = np.matmul(f_u_t.T, self.v_xx[t + 1]) q_uu = self.l_uu(x_seq[t], u_seq[t]) + np.matmul(tmp, f_u_t) + \ np.dot(self.v_x[t + 1], np.squeeze(self.f_uu(x_seq[t], u_seq[t]))) q_ux = self.l_ux(x_seq[t], u_seq[t]) + np.matmul(tmp, f_x_t) + \ np.dot(self.v_x[t + 1], np.squeeze(self.f_ux(x_seq[t], u_seq[t]))) inv_q_uu = np.linalg.inv(q_uu) k = -np.matmul(inv_q_uu, q_u) kk = -np.matmul(inv_q_uu, q_ux) dv = 0.5 * np.matmul(q_u, k) self.v[t] += dv self.v_x[t] = q_x - np.matmul(np.matmul(q_u, inv_q_uu), q_ux) self.v_xx[t] = q_xx + np.matmul(q_ux.T, kk) k_seq.append(k) kk_seq.append(kk) k_seq.reverse() kk_seq.reverse() return k_seq, kk_seq
def gen_marg_poiss(y_train, params, n_latents, n_neurons, coeffs, a1, N, D): len_sc, W = unpack_params(params) Da2W = (D * coeffs.T[2]) * W quad = 2 * Da2W @ W.T #cdiag = gpf.mkcovs.mkcovdiag_ASD_wellcond(init_len_sc+0, np.ones(np.size(init_len_sc)), nxcirc, wwnrm = wwnrm,addition = 1e-7).T C = [make_cov(N, i) + 1e-7 * np.eye(N) for i in len_sc] #all_cdiag = np.reshape(cdiag.T,np.size(init_len_sc)*N_four,-1) Cinv = [np.linalg.inv(C[i]) for i in np.arange(n_latents)] if n_latents is 1: sigma_inv = 2 * D * a2W.T @ W + Cinv[0] else: sigma_inv = np.kron(quad, np.eye(N)) + block_diag(Cinv, n_latents) #sigma_inv = 2*D*a2W.T@W + block_diag(Cinv, n_latents) Wkron = np.kron(W, np.eye(N)) second = Wkron @ (y_train - D * a1.T) mutot = np.squeeze(np.linalg.solve(sigma_inv, second)) #sigma = np.linalg.inv(sigma_inv) #mutot = np.squeeze([email protected]@(y_train- D*a1.T)) logl = np.squeeze((1 / 2) * mutot.T @ (sigma_inv) @ mutot) logdetC = 0 for i in np.arange(n_latents): logdetC = logdetC - (1 / 2) * np.linalg.slogdet(C[i])[1] neglogpost = logdetC + -(1 / 2) * np.linalg.slogdet(sigma_inv)[1] return -(neglogpost + logl)
def create_job(kwargs): import warnings warnings.filterwarnings("ignore") # pendulum env env = gym.make('Pendulum-TO-v0') env._max_episode_steps = 10000 env.unwrapped.dt = 0.02 env.unwrapped.umax = np.array([2.5]) env.unwrapped.periodic = False dm_state = env.observation_space.shape[0] dm_act = env.action_space.shape[0] state = env.reset() init_state = tuple([state, 1e-4 * np.eye(dm_state)]) solver = MBGPS(env, init_state=init_state, init_action_sigma=25., nb_steps=300, kl_bound=.1, action_penalty=1e-3, activation={ 'shift': 250, 'mult': 0.5 }) solver.run(nb_iter=100, verbose=False) solver.ctl.sigma = np.dstack([1e-1 * np.eye(dm_act)] * 300) data = solver.rollout(nb_episodes=1, stoch=True, init=state) obs, act = np.squeeze(data['x'], axis=-1).T, np.squeeze(data['u'], axis=-1).T return obs, act
def search_step(self, obj_prev, min_obj, delta_alpha, step_size, max_it, t, opt_step): """ Executes one step of a backtracking line search Args: obj_prev (np.array): previous objective obj_search (np.array): current objective min_obj (np.array): current minimum objective delta_alpha (np.array): change in step size step_size (np.array): current step size max_it (int): maximum number of line search iterations t (np.array): current line search iteration opt_step (np.array): optimal step size until now Returns: updated parameters """ alpha_search = np.squeeze(self.alpha + step_size * delta_alpha) f_search = np.squeeze(kron_mvp(self.Ks, alpha_search)) + self.mu if self.k_diag is not None: f_search += np.multiply(self.k_diag, alpha_search) obj_search = self.log_joint(f_search, alpha_search) if min_obj > obj_search: opt_step = step_size min_obj = obj_search step_size = self.tau * step_size t = t + 1 return obj_prev, min_obj, delta_alpha,\ step_size, max_it, t, opt_step
def debug_scp_iteration_plot( tx_next, u_next, xbar, ubar, x0, T, i_iter): unl = u_next x_curr = x0 Xnl = [] Vnl_nlx = [] Vnl_lx = [] tV_nlx = [] tV_lx = [] for k,t in enumerate(T): x_next = x_curr + dynamics.get_dxdt( x_curr, unl[:,k], t) * param.get('dt') R_k, w_k = dynamics.get_linear_lyapunov( xbar[:,k], ubar[:,k], t) Vnl_nlx.append( dynamics.get_V( x_curr, t)) Vnl_lx.append( dynamics.get_V( tx_next[:,k],t)) tV_nlx.append( np.matmul( R_k, x_curr) + w_k ) tV_lx.append( np.matmul( R_k, tx_next[:,k]) + w_k) Xnl.append( x_curr) x_curr = x_next Xnl = np.asarray(Xnl) Vnl_nlx = np.asarray(Vnl_nlx) Vnl_lx = np.asarray(Vnl_lx) tV_nlx = np.asarray(tV_nlx) tV_lx = np.asarray(tV_lx) plot_scp_iteration_state( Xnl, np.transpose(tx_next,(1,0,2)), \ np.transpose(xbar,(1,0,2)), T, title = str(param.get('controller')) + ' State' + \ '\nIteration: ' + str(i_iter) + '\nTime: ' + str(T[0])) plot_scp_iteration_lyapunov( np.squeeze(Vnl_nlx), np.squeeze(Vnl_lx), np.squeeze( tV_nlx), \ np.squeeze( tV_lx), T, title = str(param.get('controller')) + ' Lyapunov' + \ '\nIteration: ' + str(i_iter) + '\nTime: ' + str(T[0]))
def sinkhorn(P): """Fit the diagonal matrices in Sinkhorn Knopp's algorithm """ N = P.shape[0] max_thresh = 1 + 1e-3 min_thresh = 1 - 1e-3 _iterations = 0 _max_iter = 100 # _stopping_condition = None # Initialize r and c, the diagonals of D1 and D2 # and warn if the matrix does not have support. r = np.ones((N, 1)) pdotr = np.dot(P.T, r) # total_support_warning_str = ( # "Matrix P must have total support. " # "See documentation" # ) # if not np.all(pdotr != 0): # warnings.warn(total_support_warning_str, UserWarning) # c = 1 / pdotr pdotc = np.dot(P, c) # if not np.all(pdotc != 0): # warnings.warn(total_support_warning_str, UserWarning) # r = 1 / pdotc # del pdotr, pdotc P_eps = P # infs = np.diag(N * [-np.inf]) # P_eps = np.exp(P+infs) # while np.any(np.sum(P_eps, axis=1) < min_thresh) \ # or np.any(np.sum(P_eps, axis=1) > max_thresh) \ # or np.any(np.sum(P_eps, axis=0) < min_thresh) \ # or np.any(np.sum(P_eps, axis=0) > max_thresh): for i in range(_max_iter): c = 1 / np.dot(P.T, r) r = 1 / np.dot(P, c) _D1 = np.diag(np.squeeze(r)) _D2 = np.diag(np.squeeze(c)) P_eps = np.dot(np.dot(_D1, P), _D2) # _iterations += 1 if _iterations >= _max_iter: _stopping_condition = "max_iter" break # if not _stopping_condition: # _stopping_condition = "epsilon" _D1 = np.diag(np.squeeze(r)) _D2 = np.diag(np.squeeze(c)) P_eps = np.dot(np.dot(_D1, P), _D2) return P_eps
def loss(theta, X, y): y_hat = self.sigmoid(np.dot(X, theta)) y_hat = np.squeeze(y_hat) y = np.squeeze(y) res = -np.sum( y.dot(np.log10(y_hat)) + (1 - y).dot(np.log10(1 - y_hat))) res = res / X.shape[0] return res
def lnpdf(theta): input = np.atleast_2d(theta) lnpdf.counter += len(input) output = np.empty((len(input))) grad_out = np.empty((len(input), input.shape[1])) for i in range(len(input)): output[i] = tmp_lnpdf(input[i]) grad_out[i, :] = grad(tmp_lnpdf)(input[i]) return np.squeeze(output), np.squeeze(grad_out)
def loss(theta, X, y): y_hat = self.sigmoid(np.dot(X, theta)) y_hat = np.squeeze(y_hat) y = np.squeeze(y) error = -np.sum( y.dot(np.log10(y_hat)) + (1 - y).dot(np.log10(1 - y_hat))) error = error / X.shape[0] error += self.l2_coef / (2 * X.shape[0]) * np.sum(np.square(theta)) return error
def loss_func(w1, w2, w3, data): xy = data[:, :-1] z = data[:, 2] w1 = np.squeeze(w1) w2 = np.squeeze(w2) w3 = np.squeeze(w3) z_pred = forward_pass(xy, w1, w2, w3) loss = np.sum((z_pred - z)**2) return loss
def plot_V(V,T,title = 'Lyapunov Convergence'): fig, ax = plt.subplots() Vdot = np.gradient(V, param.get('dt'), axis = 0) ax.plot(T,np.squeeze(V),label = 'V') ax.plot(T,np.squeeze(Vdot),label = 'Vdot') plt.title(title) plt.legend() ax.grid(True)
def predict(self, X): m = X.shape[0] if self.fit_intercept: X = np.concatenate((np.ones(m).reshape(-1, 1), X), axis=1) pred = self.predicition(self.coef_, X) pred = np.squeeze(pred) res = np.squeeze(pred >= 0.5).astype(int) # print(pd.DataFrame({0:pred,1:res,2:np.array(self.y).squeeze()})) return pd.Series(res)
def eq_constraint_elimination(func, eqConstraintsMat, optimizer, initialX, interval=[-1e15, 1e15], ftol=1e-6, maxIters=1e3, maxItersLS=200): fevals = 0 xLen = initialX.shape[0] # n bLen = eqConstraintsMat['b'].shape[0] # p F, x_hat = eq_constraint_elimination_composer(eqConstraintsMat) paramFunc = eq_constraint_elimination_func(func, F, x_hat) # Choose any initial Z initialZ = np.zeros((xLen - bLen, 1)) # Must be (n - p)x1 # Scipy optimizer # optimizer = spo.minimize(paramFunc, initialZ, method='BFGS', tol=ftol) # zOpt = optimizer.x # zFevals = optimizer.nfev # Debug # print("F: ", F.shape) # print("A:", eqConstraintsMat['A'].shape) # print("b:", eqConstraintsMat['b'].shape) # print("x_hat: ", x_hat.shape) # print("initialZ: ", initialZ.shape) # print("paramFunc(z0): ", paramFunc(initialZ)) # print("F@z + x_hat", (np.dot(F, initialZ) + x_hat).shape) # print((np.dot(F, initialZ) + x_hat)) # print("zOpt: ", zOpt.shape) # print("xOpt", xOpt.shape) # print("fOpt", fOpt.shape) # print("Restr check:\nAx* = b\n{} = {}".format( # np.squeeze(np.dot(eqConstraintsMat['A'], xOpt)), eqConstraintsMat['b'] # )) # input() # Find z* to minimize parametrized cost function algorithm = optimizer(paramFunc, initialZ, interval=interval, ftol=ftol, maxIters=maxIters, maxItersLS=maxItersLS) zOpt, _, zFevals = algorithm.optimize() zOpt.shape = (xLen - bLen, 1) fevals += zFevals xOpt = np.squeeze(np.dot(F, zOpt) + x_hat) fOpt = np.squeeze(func(xOpt)) return xOpt, fOpt, fevals
def loss(self, theta, x, y): assert (x.shape[0] == y.shape[0]) pred = self.predicition(theta, x) pred = np.squeeze(pred) y = np.squeeze(y) res = -np.sum(y.dot(np.log10(pred)) + (1 - y).dot(np.log10(1 - pred))) res = res / x.shape[0] res += self.l2_coef / (2 * x.shape[0]) * np.sum(np.square(theta)) res += self.l1_coef / (2 * x.shape[0]) * np.sum(np.abs(theta)) # print(res) return res
def make_model(model_name): if model_name == "baseball": # baseball model and data lnpdf_named = baseball.lnpdf lnpdf_flat = baseball.lnpdf_flat lnpdft = lambda z, t: np.squeeze(lnpdf_flat(z, t)) lnpdf = lambda z: np.squeeze(lnpdf_flat(z, 0)) D = baseball.D return lnpdf, D, None elif model_name == "frisk": lnpdf, unpack, D, sdf, pnames = frisk.make_model_funs(precinct_type=1) return lnpdf, D, pnames
def generate_mixture_data(num_obs, true_centroids, true_probs, x_covs): true_z = np.random.multinomial(1, true_probs, num_obs) true_z_ind = np.full(num_obs, -1) for row in np.argwhere(true_z): true_z_ind[row[0]] = row[1] x = np.array([ np.random.multivariate_normal( mean=np.squeeze(true_centroids[true_z_ind[n], :]), cov=np.squeeze(x_covs[n, :])) for n in range(num_obs) ]) return x, true_z, true_z_ind
def f(x): demo = demo_func(x) demo.set_mut_rate(1.0) configs = momi.build_config_list(demo.leafs, tuple(states), n_lins) #print(configs) # print demo.graph['cmd'] #sfs, branch_len = expected_sfs(demo.demo_hist, configs), expected_total_branch_len( # demo.demo_hist, sampled_pops=demo.pops, sampled_n=demo.n) sfs, branch_len = demo.expected_sfs( configs, length=1, return_dict=False), demo.expected_branchlen( dict(zip(configs.sampled_pops, configs.sampled_n))) if normalized: return np.squeeze(sfs / branch_len) return np.squeeze(sfs)
def plot_test( V, LgV, LfV, U, T): # currently testing lyapunov and derivatives Vdot_n = np.gradient(V, param.get('dt'), axis = 0) Vdot_a = [] for t in range(len(T)): Vdot_a.append( LfV[t] + np.matmul( LgV[t], U[t])) Vdot_a = np.asarray(Vdot_a) fig, ax = plt.subplots() plt.plot( T, np.squeeze(V), label = 'V') plt.plot( T, np.squeeze(Vdot_n), label = 'Vdot n') plt.plot( T, np.squeeze(Vdot_a), label = 'Vdot a') plt.legend() plt.title('Testing')
def initialize_local_meanfield(node_potentials): # TODO maybe i should initialize the hmm states instead of the lds states... def compute_stats(sampled_states): out = np.outer get_init_stats = lambda x0: (out(x0, x0), x0, 1., 1.) get_pair_stats = lambda x1, x2: (out(x1, x1), out(x1, x2), out(x2, x2), 1.) init_stats = get_init_stats(sampled_states[0]) pair_stats = map(get_pair_stats, sampled_states[:-1], sampled_states[1:]) return init_stats, map(np.array, zip(*pair_stats)) # construct random walk natparam N = node_potentials[0].shape[1] A = 0.9 * np.eye(N) init_params = -1. / 2 * np.eye(N), np.zeros(N), 0. pair_params = -1. / 2 * np.dot(A.T, A), A.T, -1. / 2 * np.eye(N), 0. natparam = init_params, pair_params sampled_states = np.squeeze( natural_lds_sample(natparam, node_potentials, num_samples=1)) init_stats, pair_stats = compute_stats(sampled_states) return init_stats, pair_stats
def linear_regression_online_update(m_km1, P_km1, H, m_obs, var_obs): # m_km1: Prior mean # P_km1: Prior cov # H: Link from latent to observed # m_obs: Mean of observation # var_obs: Variance of observation # We need to work with matrices here or the maths will be wrong assert all([len(x.shape) == 2 for x in [m_km1, H]]), \ 'm_km1 and H must have two dimensions each!' v_k = m_obs - H @ m_km1 S_k = H @ P_km1 @ H.T + var_obs K_k = P_km1 @ H.T * (1 / S_k) m_k = m_km1 + K_k * v_k P_k = P_km1 - (K_k * S_k) @ K_k.T # Calculate the log marginal likelihood here too # sign, logdet = np.linalg.slogdet(2 * np.pi * S_k) # logdet_a = sign * logdet # Do this another way # rel_chol = np.linalg.cholesky(2 * np.pi * S_k) # TODO: CHECK THIS logdet = logdet_via_cholesky(2 * np.pi * S_k) # Second part quadratic_term = 0.5 * v_k.T @ np.linalg.solve(S_k, v_k) energy_contrib = 0.5 * logdet + quadratic_term return m_k, P_k, np.squeeze(energy_contrib)
def _composite_log_likelihood(data, demo, mut_rate=None, truncate_probs=0.0, vector=False, p_missing=None, use_pairwise_diffs=False, **kwargs): try: sfs = data.sfs except AttributeError: sfs = data sfs_probs = np.maximum( expected_sfs(demo, sfs.configs, normalized=True, **kwargs), truncate_probs) log_lik = sfs._integrate_sfs(np.log(sfs_probs), vector=vector) # add on log likelihood of poisson distribution for total number of SNPs if mut_rate is not None: log_lik = log_lik + \ _mut_factor(sfs, demo, mut_rate, vector, p_missing, use_pairwise_diffs) if not vector: log_lik = np.squeeze(log_lik) return log_lik
def compute_MSE(self): """Used in fitting models lab to display MSE performance for hand-fitting exercises""" outputs = np.squeeze(self.funk(self.data_inputs)) squared_errors = np.square(self.correct_outputs - outputs) MSE = np.mean(squared_errors) return MSE
def setUp(self): np.seterr(all='raise') self.X = None self.cost = lambda X: np.exp(np.sum(X**2)) n = self.n = 15 Y = self.Y = rnd.randn(n) A = self.A = rnd.randn(n) # Calculate correct cost and grad... self.correct_cost = np.exp(np.sum(Y**2)) self.correct_grad = correct_grad = 2 * Y * np.exp(np.sum(Y**2)) # ... and hess # First form hessian matrix H # Convert Y and A into matrices (row vectors) Ymat = np.matrix(Y) Amat = np.matrix(A) diag = np.eye(n) H = np.exp(np.sum(Y**2)) * (4 * Ymat.T.dot(Ymat) + 2 * diag) # Then 'left multiply' H by A self.correct_hess = np.squeeze(np.array(Amat.dot(H))) self.backend = AutogradBackend()
def __init__(self, K, D, pi0=None, M=0): super(FixedInitialStateDistribution, self).__init__(K, D, M=M) if pi0 is not None: # Handle the case where user passes a numpy array of (K, 1) instead of (K,) pi0 = np.squeeze(np.array(pi0)) assert len(pi0) == K, "Array passed as pi0 is of the wrong length" self.log_pi0 = np.log(pi0 + 1e-16)
def get_spectra(self, T, mu, velocity): """ Return the Kurucz spectrum for a value of the temperature, astrocentric angle and velocity. It linearly interpolates on the set of computed spectra Args: T (float) : temperature in K mu (float) : astrocentric angle in the range [0,1] velocity (float) : velocity shift of the spectrum in km/s Returns: spectrum (float) : interpolated and shifted spectrum """ idT = np.searchsorted(self.T, T) - 1 idmu = np.searchsorted(self.mus, mu) - 1 # Simple bilinear interpolation xd = (T - self.T[idT]) / (self.T[idT+1] - self.T[idT]) yd = (mu - self.mus[idmu]) / (self.mus[idmu+1] - self.mus[idmu]) c0 = self.spectrum[idT,idmu,:] * (1.0 - xd) + self.spectrum[idT+1,idmu,:] * xd c1 = self.spectrum[idT,idmu+1,:] * (1.0 - xd) + self.spectrum[idT+1,idmu+1,:] * xd tmp = np.squeeze(c0 * (1.0 - yd) + c1 * yd) # Velocity shift in pixel units shift_in_pxl = velocity / self.velocity_per_pxl return self.shift_spectrum(tmp, shift_in_pxl) #nd.shift(tmp, shift_in_pxl)
def loss_func(parameters,data): parameters=np.squeeze(parameters) x=data[:,:-1] y=data[:,-1] ai=sigmoid(parameters,x) loss=-(np.sum(y*np.log(ai)+(1-y)*np.log(1-ai))) return loss
def _update_params(self, x, result): self.fevals = self.fevals + 1 # Autograd ArrayBox behaves differently from numpy, that fixes it. result_copy = remove_arraybox(result) x_copy = remove_arraybox(x) assert np.any(np.isnan(result_copy)) == False, "X out of domain" found_best = np.all(result_copy <= self.best_f) if self._has_eqc: if found_best: self.best_z = x_copy x_copy = np.squeeze( self._null_space_feasible_matrix @ np.reshape(x_copy, (-1, 1)) + self._feasible_vector) self.all_evals += [result_copy] self.all_x += [x_copy] if found_best: self._best_x = x_copy self._best_f = result_copy self.all_best_x += [self.best_x] self.all_best_f += [self.best_f] return result
def f_scp(self, x, u): # input: # x, nd array, (n,) # u, nd array, (m,1) # output # sp1, nd array, (n,) # parameters m_p = self.mass_pole m_c = self.mass_cart l = self.length_pole g = self.g # s = [q,qdot], q = [x,th] u = agnp.reshape(u, (self.m, 1)) q = agnp.reshape(x[0:2], (2, 1)) qdot = agnp.reshape(x[2:], (2, 1)) th = x[1] thdot = x[3] # EOM from learning+control@caltech # D = agnp.array([[m_c+m_p,m_p*l*agnp.cos(th)],[m_p*l*agnp.cos(th),m_p*(l**2)]]) a = m_c + m_p b = m_p * l * agnp.cos(th) c = m_p * l * agnp.cos(th) d = m_p * (l**2) Dinv = 1 / (a * d - b * c) * agnp.array([[d, -b], [-c, a]]) C = agnp.array([[0, -m_p * l * thdot * agnp.sin(th)], [0, 0]]) G = agnp.array([[0], [-m_p * g * l * agnp.sin(th)]]) B = agnp.array([[1], [0]]) qdotdot = agnp.dot(Dinv, agnp.dot(B, u) - agnp.dot(C, qdot) - G) res = agnp.vstack([qdot, qdotdot]) return agnp.squeeze(res)
def setUp(self): np.seterr(all='raise') self.X = None self.cost = lambda X: np.exp(np.sum(X**2)) n = self.n = 15 Y = self.Y = rnd.randn(n) A = self.A = rnd.randn(n) # Calculate correct cost and grad... self.correct_cost = np.exp(np.sum(Y ** 2)) self.correct_grad = 2 * Y * np.exp(np.sum(Y ** 2)) # ... and hess # First form hessian matrix H # Convert Y and A into matrices (row vectors) Ymat = np.matrix(Y) Amat = np.matrix(A) diag = np.eye(n) H = np.exp(np.sum(Y ** 2)) * (4 * Ymat.T.dot(Ymat) + 2 * diag) # Then 'left multiply' H by A self.correct_hess = np.squeeze(np.array(Amat.dot(H))) self.backend = AutogradBackend()
def test_elementwise_grad(): def simple_fun(a): return a + np.sin(a) + np.cosh(a) A = npr.randn(10) exact = elementwise_grad(simple_fun)(A) numeric = np.squeeze(np.array([nd(simple_fun, A[i]) for i in range(len(A))])) check_equivalent(exact, numeric)
def test_elementwise_grad_multiple_args(): def simple_fun(a, b): return a + np.sin(a) + np.cosh(b) A = 0.9 B = npr.randn(10) argnum = 1 exact = elementwise_grad(simple_fun, argnum=argnum)(A, B) numeric = np.squeeze(np.array([nd(simple_fun, A, B[i])[argnum] for i in range(len(B))])) check_equivalent(exact, numeric)
def mog_logmarglike(x, means, covs, pis, ind=0): """ marginal x or y (depending on ind) """ K = pis.shape[0] xx = np.atleast_2d(x) centered = xx.T - means[:,ind,np.newaxis].T logprobs = [] for kk in xrange(K): quadterm = centered[:,kk] * centered[:,kk] * (1./covs[kk,ind,ind]) logprobsk = -.5*quadterm - .5*np.log(2*np.pi) \ -.5*np.log(covs[kk,ind,ind]) + np.log(pis[kk]) logprobs.append(np.squeeze(logprobsk)) logprobs = np.array(logprobs) logprob = scpm.logsumexp(logprobs, axis=0) if np.isscalar(x): return logprob[0] else: return logprob
def rand_natparam(n, k): return np.squeeze(np.stack([rand_dirichlet(n) for _ in range(k)]))
def rand_natparam(n, k): return np.squeeze(np.stack([rand_gaussian(n) for _ in range(k)]))
def fun(x): return to_scalar(np.squeeze(x)) d_fun = lambda x : to_scalar(grad(fun)(x))