def magcal_residual(X, a, mb): """ residual from all observations given magnetometer eccentricity, bias, gyro bias, and gyro scale""" # (x-c)T A^T A (x-c) = 1 # x^T Ax - 2x^T Ac + c^T Ac = 1 # a b c | x' = ax + by + cz # 0 d e | y' = dy + ez # 0 0 f | z' = fz # z = 1/f z' # y = 1/d (y' - e/f z') # x = 1/a (x' - b/d(y' - e/f z') - c/f z') # = 1/a (x' - b/d y' - (be/df - c/f) z') # (x-c) A^T A (x-c) # [(A x) - (A c)]^2 - 1 = 0 # y = A(x-c) # y /= ||y|| # q(x; A, c) = (A^-1 (y+c) - x)^2 Y = np.dot(X - mb, Ainv(a)).T Y /= np.linalg.norm(Y, axis=0) # Y /= np.sqrt(np.sum(np.square(Y), axis=0)) Y = np.dot(Y.T, Amatrix(a)) + mb return np.mean(np.sum(np.square(X - Y), axis=1))
def log_loss_regression(self, W_vect, X, Y): log_prior = -self.L2_reg * np.dot(W_vect, W_vect) Yhat = self.predicted_regression(W_vect, X) Y = np.ravel(Y) Yhat = np.ravel(Yhat) N = X.shape[0] log_lik = -0.5*np.sum(np.square(Y - Yhat))/N return - log_prior - log_lik
def fit(self, target_airfoil): target = target_airfoil - self.airfoil0 # N/2 x 2 target = target.T.reshape(-1, 1) # N x 1 alpha = np.linalg.pinv(self.u_truncated) @ target # dim x 1 alpha = np.squeeze(alpha) fitted_airfoil = self.synthesize(alpha) error = np.mean( np.sum(np.square(fitted_airfoil - target_airfoil), axis=1)) return alpha, fitted_airfoil, error
def K(p): """ Calculates the kinetic energy of some given momentum values and returns a float. Arguments: - p: Numpy array of momentum values """ return ag_np.sum(ag_np.square(p)) / 2
def response(params, inputs=None, targets=None, channels=None, hps=None): if np.any(targets) == None: targets = inputs return np.argmin(np.sum(np.square( np.subtract( targets, forward(params, inputs=inputs, channels=channels, hps=hps)[-1])), axis=2, keepdims=True), axis=0)[:, 0]
def final_cost(self, state): ''' if len(state.shape) >= 2: goal = np.repeat(self.goal[np.newaxis, :], repeats=state.shape[0], axis=0) achieved_goal = np.transpose(self.forward_dynamics(state[:, 0], state[:, 2]), [1, 0]) cost = self.a1 * np.sum(np.square(goal - achieved_goal), axis=1) + self.a2 * np.square(state[:, 1]) + \ self.a3 * np.square(state[:, 3]) else: cost = self.a1 * np.sum(np.square(self.goal - self.forward_dynamics(state[0], state[2]))) + \ self.a2 * np.square(state[1]) + self.a3 * np.square(state[3]) ''' if len(state.shape) >= 2: cost = 0.5 * (np.square(1.0 - np.cos(state[:, 2])) + np.square(state[:, 1]) + np.square(state[:, 3])) else: cost = 0.5 * (np.square(1.0 - np.cos(state[2])) + np.square(state[1]) + np.square(state[3])) return cost
def objective(eps_space): F.eps_r *= eps_space measured = [] for t_index in range(steps): fields = F.forward(Jz=source(t_index)) measured.append(npa.sum(fields['Ez'] * measure_pos)) measured_f = my_fft(npa.array(measured)) spectral_power = npa.square(npa.abs(measured_f)) return spectral_power
def loss(params, inputs=None, targets=None, hps=None): ## Cross-Entropy (i think); usually explodes # o = forward(params, inputs = inputs, hps = hps)[-1] # c = o * targets + (1 - o) * (1 - targets) # return -np.sum(np.log(c)) ## SSE return np.sum( np.square( np.subtract(forward(params, inputs=inputs, hps=hps)[-1], targets)))
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(params, inputs = None, targets = None, hps = None): return np.sum( np.square( np.subtract( forward(params, inputs = inputs, hps = hps)[-1], targets ) ) )
def loss(w): lossVal = 0 for wi, aH in zip(w, alphaHats): den = (1 / np.dot(wi, n)) aXw = np.multiply(a, wi) dot = np.dot(aXw, n) tilde = den * dot lossVal = lossVal + .5 * np.square(aH - tilde) return lossVal
def loss(params, X=None, Y=None, init_cell_state=None, init_hidden_state=None): output = forward_seq(params, X=X, init_cell_state=init_cell_state, init_hidden_state=init_hidden_state) return np.sum( np.square(np.subtract(output, Y)) ) # + np.sum(np.abs([np.sum(params[layer]['w']) for layer in params])) * .1 # <-- weight size regularization?
def loss(self, A, B, X, y, prob): ''' y is a matrix of size len(X), 50''' assert y.ndim == 2 assert y.shape[1] == 50 k = self.get_bin_size(X) prediction = np.dot(1. / 12. * A, np.matmul(X.values[:, 2:], np.exp(B * k))) loss = np.mean(np.square(prediction - np.multiply(y, prob).T)) return loss
def PrintPerf(Params, iter, _): if iter == 0: print(" Epoch | Train cost ") if iter % 5 == 0: Cost = ObjectiveFunWrap(Params, iter) Gradient = flatten(ObjectiveGrad(Params, iter)) print( str(iter) + ' ' + str(np.round(Cost, 6)) + ' ' + str(np.square(Gradient[0]).sum()))
def fnorm(matrix): """ get the F norm. """ U, S, V = np.linalg.svd(matrix) S = np.diag(S) fnorm_s = np.sqrt(np.trace(np.square(S))) return fnorm_s
def loss(params, inputs = None, targets = None, channels = None, labels_indexed = None, hps = None): return np.sum( np.square( np.subtract( forward(params, inputs = inputs, hps = hps)[-1], targets ) ) )
def ba_objective(cams, X, w, obs, feats): p = obs.shape[0] reproj_err = np.empty((p,2)) for i in range(p): reproj_err[i] = compute_reproj_err(cams[obs[i,0]],X[obs[i,1]],w[i],feats[i]) w_err = 1. - np.square(w) return (reproj_err, w_err)
def square_corrcoeff_full_cost(V, X, grad=True): ''' The cost function for the correlation analysis. This effectively measures the square difference in correlation coefficients after transforming to an orthonormal basis given by V. Args: V: 2D array of shape (N, K) with V.T * V = I X: 2D array of shape (P, N) containing centers of P manifolds in an N=P-1 dimensional orthonormal basis ''' # Verify that the shapes are correct P, N = X.shape N_v, K = V.shape assert N_v == N # Calculate the cost C = np.matmul(X, X.T) c = np.matmul(X, V) c0 = np.diagonal(C).reshape(P, 1) - np.sum( np.square(c), axis=1, keepdims=True) Fmn = np.square(C - np.matmul(c, c.T)) / np.matmul(c0, c0.T) cost = np.sum(Fmn) / 2 if grad is False: # skip gradient calc since not needed, or autograd is used gradient = None else: # Calculate the gradient X1 = np.reshape(X, [1, P, N, 1]) X2 = np.reshape(X, [P, 1, N, 1]) C1 = np.reshape(c, [P, 1, 1, K]) C2 = np.reshape(c, [1, P, 1, K]) # Sum the terms in the gradient PF1 = ((C - np.matmul(c, c.T)) / np.matmul(c0, c0.T)).reshape( P, P, 1, 1) PF2 = (np.square(C - np.matmul(c, c.T)) / np.square(np.matmul(c0, c0.T))).reshape(P, P, 1, 1) Gmni = -PF1 * C1 * X1 Gmni += -PF1 * C2 * X2 Gmni += PF2 * c0.reshape(P, 1, 1, 1) * C2 * X1 Gmni += PF2 * (c0.T).reshape(1, P, 1, 1) * C1 * X2 gradient = np.sum(Gmni, axis=(0, 1)) return cost, gradient
def gen_toy_ca_GP(N, D, CA_struct, Pois_noise = True,scale_pois = 1): ''' This function will generate some data with GP statistics with variance 'rh', and length scale 'len_sc'. Data will be generated of length N, with batch size D. Default function will add Gaussian noise with marginal variance 'add_noise_var'. Defaults sing_GP = False indicates a new GP draw with the same statistics for each Batch Pois_noise = False indicates Gaussian noise is added to the GP. ''' #=X = tf.constant(np.tile(np.arange(N),(D,1)),dtype = tf.float32) #x = rbf_op(X,D,rh,len_sc) M1 = np.array([range(N)])- np.transpose(np.array([range(N)])) K = rh*np.exp(-(np.square(M1)/(2*np.square(len_sc)))) x = np.array(np.random.multivariate_normal(np.zeros(N), K)) x= [np.log(1 + np.exp(x)) for batch in range(D)]/np.asarray(scale_pois) #x = [np.exp(x)/10 for batch in range(D)] y = np.random.poisson(x) #poisson spikes from GP x = x[0] logsprate = np.log(rate)*np.ones(int(np.floor(Xstruct['T']/Xstruct['dtSp']))) #constant (for now) spcounts = np.random.poisson(Xstruct['dtSp']*np.exp(logsprate)) # poisson spike counts ##### Optional Model ##### #AR2 if Xstruct['AR2'] is True: #AR2 q = [exp(-par.dt_spk/par.calc_ts),exp(-par.dt_spk/par.calc_ts_b)]; a_true = poly(q); z = filter(1,a_true,spcounts); else: #AR1 z= lfilter([Xstruct['a']],[1,-np.exp(-Xstruct['dtSp']/Xstruct['calc_ts'])],spcounts) #convolve with exp filter trace = z + np.sqrt(Xstruct['Gauss_sigma'])*np.random.randn(np.size(z))#add noise return trace
def forward(params, inputs = None, hps = None): hidden1_activations = np.array([ hps['hidden1_activation']( np.add( np.matmul( inputs, params['input']['hidden1']['weights'][c,:,:], ), params['input']['hidden1']['bias'][c,:,:], ) ) for c in range(params['input']['hidden1']['weights'].shape[0]) ]) hidden2_activations = np.array([ hps['hidden2_activation']( np.add( np.matmul( hidden1_activations[c,:,:], params['hidden1']['hidden2']['weights'][c,:,:], ), params['hidden1']['hidden2']['bias'][c,:,:], ) ) for c in range(params['hidden1']['hidden2']['weights'].shape[0]) ]) channel_activations = np.array([ hps['channel_activation']( np.add( np.matmul( hidden2_activations[c,:,:], params['hidden2']['output']['weights'][c,:,:], ), params['hidden2']['output']['bias'][c,:,:], ) ) for c in range(params['hidden2']['output']['weights'].shape[0]) ]) ## reconstructive error output_activation = np.sum( np.square( np.subtract( inputs, channel_activations, ) ), axis = 2 ).T output_activation = 1 - hps['classifier_activation']( output_activation / output_activation.sum(axis=1, keepdims = True) ) return [hidden1_activations, hidden2_activations, channel_activations, output_activation]
def _LOOCrossValidation(self, hyperparameters): # scales, nuggets): self._CalculateNecessaryMatrices(scales=hyperparameters[1:], nuggets=hyperparameters[0]) Kinv_diag = np.diag(np.linalg.inv(self.cov_matrix)).reshape(-1, 1) LOO_mean_minus_target = self.alpha / Kinv_diag LOO_sigma = np.reciprocal(Kinv_diag) log_CV = -0.5 * (np.log(LOO_sigma) + np.square(LOO_mean_minus_target) * Kinv_diag + np.log(2 * np.pi)) # print(self.alpha.shape, self.cholesky.shape, self.cov_matrix.shape, Kinv_diag.shape) return log_CV.sum()
def intensity(eps_arr): eps_r = eps_arr.reshape((Nx, Ny)) # set the permittivity of the FDFD and solve the fields F.eps_r = eps_r Ex, Ey, Hz = F.solve(source) # compute the gradient and normalize if you want I = npa.sum(npa.square(npa.abs(Hz * probe))) return -I / I_H0
def ba_objective(cams, X, w, obs, feats): p = obs.shape[0] reproj_err = np.empty((p, 2)) for i in range(p): reproj_err[i] = compute_reproj_err(cams[obs[i, 0]], X[obs[i, 1]], w[i], feats[i]) w_err = 1. - np.square(w) return (reproj_err, w_err)
def compKphig_2d(self, z, R, eps): """ Compute spatial cross-cov between CSD and LFP (fwd model applied to the x part). :param z: vector (nz, 2) of 2D CSD locations :param R: fwd model param value :param eps: spacing in front of array to assume zero charge :return: cross-covariance matrix """ ell1 = self.params['ell1']['value'] ell2 = self.params['ell2']['value'] Ks = np.exp(-0.5 * np.square( (self.gl_x_grid[:, 0][:, None] - z[:, 0][None, :]) / ell1)) * np.exp(-0.5 * np.square( (self.gl_x_grid[:, 1][:, None] - z[:, 1][None, :]) / ell2)) fwd_wts = b_fwd_2d(None, None, R, eps, self.delta_w) # (nx1*nx2, ngl1*ngl2) A = self.gl_w_prod.T * fwd_wts res = np.dot(A, Ks) return res
def cost(coef): X_coef = -1 * np.matmul(X_, coef) z = 1 / (1 + np.exp(X_coef)) epsilon = 1e-5 class1 = np.multiply(y_, np.log(z + epsilon)) class2 = np.multiply(1 - y_, np.log(1 - z + epsilon)) ans = -(1 / y_.size) * (np.sum(class1 + class2)) if self.penalty == "l1": return ans + self.val * np.sum(np.absolute(coef)) else: return ans + self.val * np.sum(np.square(coef))
def loss(self, A, B, X, y, prob): ''' y is a matrix of size len(X), 50''' assert y.ndim == 2 assert y.shape[1] == 50 k = self.get_bin_size(X) prediction = np.dot( 1. / 12. * A, np.matmul(X[[str(i) for i in range(34)]].values, np.exp(B * k))) loss = np.mean(np.multiply(np.square(prediction - y.values.T), prob.T)) return loss
def cost_fraction(H, A, T, E_np_masked, case): HAT = multiply_case(H, A, T, case) num_appliances = len(A)-1 c = 0 for appliance_num in range(1, num_appliances + 1): gt_appliance_fr = E_np_masked[:, appliance_num, :] / E_np_masked[:, 0, :] pred_appliance_fr = HAT[:, appliance_num, :] / E_np_masked[:, 0, :] diff_appliance_fr = (pred_appliance_fr - gt_appliance_fr).flatten() diff_appliance_fr = diff_appliance_fr[~np.isnan(diff_appliance_fr)] c = c + np.sqrt(np.square(diff_appliance_fr).mean()) return c
def diagonal(self, X): alpha, mean_lam, gamma, delta = self._get_params(X) cfg, res, kappa, kr_pref, _ = self._compute_terms( X, alpha, mean_lam, gamma, delta) kappa2 = self._compute_kappa(res * 2, alpha, mean_lam) kdiag_res = anp.subtract(kappa2, anp.square(kappa)) kdiag_res = anp.reshape(anp.multiply(kdiag_res, anp.square(kr_pref)), (-1, )) kdiag_x = self.kernel_x.diagonal(cfg) if self.encoding_delta is None: if delta > 0.0: tmpvec = anp.subtract(kappa * 2, kappa2 * delta) tmpvec = anp.reshape(tmpvec * (-delta) + 1.0, (-1, )) else: tmpvec = 1.0 else: tmpvec = anp.subtract(kappa * 2, anp.multiply(kappa2, delta)) tmpvec = anp.reshape(anp.multiply(tmpvec, -delta) + 1.0, (-1, )) return kdiag_x * tmpvec + kdiag_res
def fit(self, target_airfoil): target = target_airfoil - self.airfoil0 # n_points x 2 target = target[:-1] # (n_points-1) x 2 target = target.T.reshape(2, -1, 1) # 2 x (n_points-1) x 1 alpha = np.linalg.pinv(self.v_truncated) @ target # 2 x dim/2 x 1 alpha = np.squeeze(alpha) # 2 x dim/2 alpha = alpha.T.flatten() fitted_airfoil = self.synthesize(alpha) error = np.mean( np.sum(np.square(fitted_airfoil - target_airfoil), axis=1)) return alpha, fitted_airfoil, error
def prediction_loss_full(X, Y, W, V, b, c, l): WX = np.matmul(W, np.transpose(X)) b = np.array([ b, ] * X.shape[0]).transpose() c = np.array([ c, ] * X.shape[0]).transpose() b_plus_WX = np.add(b, WX) sigma = np.tanh(b_plus_WX) f = np.add(c, np.matmul(V, sigma)) L = 0 for i in range(Y.shape[0]): softmax = np.log(np.sum(np.exp(f[:, i]))) y = Y[i] L += -f[y][i] + softmax L += l * (np.sum(np.square(V)) + np.sum(np.square(W))) return L
def intensity(eps_arr): # reshape the design variables eps_r = eps_arr.reshape((Nx, Ny)) # linear simulation F_lin.eps_r = eps_r _, _, Ez = F_lin.solve(source) # nonlinear simulation density = (eps_max - eps_r) / (eps_max - 1) F_nl.eps_r = lambda E: eps_r + density * 3 * chi3 * npa.square(npa.abs(Ez)) _, _, Ez_nl = F_nl.solve(source) # compute the intesnities of both simulations I_lin = npa.sum(npa.square(npa.abs(Ez * probe))) I_nl = npa.sum(npa.square(npa.abs(Ez_nl * probe))) # maximize linear intensity, minimize nonlinear return -(I_lin - I_nl) / I_E0
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 area_wetted(self): # Returns the wetted area of a wing. area = 0 for i in range(len(self.xsecs) - 1): chord_eff = (self.xsecs[i].chord + self.xsecs[i + 1].chord) / 2 this_xyz_te = self.xsecs[i].xyz_te() that_xyz_te = self.xsecs[i + 1].xyz_te() span_le_eff = np.sqrt( np.square(self.xsecs[i].xyz_le[1] - self.xsecs[i + 1].xyz_le[1]) + np.square(self.xsecs[i].xyz_le[2] - self.xsecs[i + 1].xyz_le[2])) span_te_eff = np.sqrt( np.square(this_xyz_te[1] - that_xyz_te[1]) + np.square(this_xyz_te[2] - that_xyz_te[2])) span_eff = (span_le_eff + span_te_eff) / 2 area += chord_eff * span_eff if self.symmetric: area *= 2 return area
def dKdu(u, v): """ compute the grads of a given K w.r.t. u you can just switch order of args to compute it for v """ anorm = np.sqrt(np.sum(u*u)) bnorm = np.sqrt(np.sum(v*v)) den2 = (anorm * bnorm) + 1e-20 a = v / den2 b = u / np.sum(np.square(u)) c = cosine_sim(u,v) return a - b*c
def NLL(self, W_vect, X, Y): '''Negative log likelihood. For classification, we assume Y is a N*C one-hot matrix.''' if self.output_type == 'classification': log_lik = np.sum(self.predictions(W_vect, X) * Y) else: log_lik = 0 Yhat = self.predictions(W_vect, X) Y = np.ravel(Y) Yhat = np.ravel(Yhat) log_lik = -0.5*np.sum(np.square(Y - Yhat)) B = X.shape[0] # batch size log_lik = (log_lik / B ) * self.Ntrain return -log_lik
def rodrigues_rotate_point(rot,X): sqtheta = np.sum(np.square(rot)) if sqtheta != 0.: theta = np.sqrt(sqtheta) costheta = np.cos(theta) sintheta = np.sin(theta) theta_inverse = 1. / theta w = theta_inverse * rot w_cross_X = cross(w,X) tmp = np.dot(w,X) * (1. - costheta) return X*costheta + w_cross_X * sintheta + w * tmp else: return X + cross(rot,X)
def NLL(self, W_vect, X, Y, N=None): '''Negative log likelihood. For classification, we assume Y is a N*C one-hot matrix.''' if self.output_type == 'classification': log_lik = np.sum(self.predictions(W_vect, X) * Y) else: log_lik = 0 Yhat = self.predictions(W_vect, X) Y = np.ravel(Y) Yhat = np.ravel(Yhat) log_lik = -0.5*np.sum(np.square(Y - Yhat)) if N is not None: # Compensate for this being a minibatch B = X.shape[0] # batch size log_lik = (log_lik / B ) * N return -log_lik
def magcal_residual_old(X, a, mb): mag = np.dot(X - mb, Ainv(a)) return np.mean(np.square(1 - np.sum(mag*mag, axis=1)))
def radial_distort(rad_params,proj): rsq = np.sum(np.square(proj)) L = 1. + rad_params[0]*rsq + rad_params[1]*rsq*rsq return proj*L
def squared_loss(y_pred, y): '''y is N*1, y_pred is N*1. Returns scalar''' N = y.shape[0] return sum(np.square(y - y_pred))/N
def sqsum(x): return (np.square(x)).sum()
def dist(x1, x2): """ Compute squared euclidean distance between samples (autograd) """ x1p2 = np.sum(np.square(x1), 1) x2p2 = np.sum(np.square(x2), 1) return x1p2.reshape((-1, 1)) + x2p2.reshape((1, -1)) - 2 * np.dot(x1, x2.T)
def cost(theta): return np.square(theta)
def squared_loss(y_pred, y): N = y.shape[0] return 0.5*np.sum(np.square(y - y_pred))/N
print cosine_sim(u,v) # compute deltas automatically # just with respect to u cs_grad = grad(cosine_sim, argnum=0) auto_deltas = cs_grad(u,v) # compute deltas manually manual_deltas = np.zeros_like(auto_deltas) # compute the denominator anorm = np.sqrt(np.sum(u*u)) bnorm = np.sqrt(np.sum(v*v)) den2 = (anorm * bnorm) + 1e-5 a = v / den2 b = u / np.sum(np.square(u)) c = cosine_sim(u,v) manual_deltas = a - b*c print "auto deltas" print auto_deltas print "manual deltas" print manual_deltas """ manual_deltas gives us dk_i / dK_j """
def rmse(predictions, targets): assert(canSum(predictions, targets)) return np.sqrt(np.mean(np.square(predictions-targets)))