def locallogisticHessian(self, theta, weights, reg_param): """ Hessian for regulatrized local logistic regression L2 loss Args: theta (np.array): Current lwlr parameters of shape [1, n_features] weights (np.array): training set weights of shape [n_samples, 1] reg_param (float): L2 regularization weight. If 0, no no regulatrization is used. Returns: Hessian (np.ndarray): Hessian of shape [n_features, n_features] """ # Add bias to X X = np.insert(self.X, 0, 1, axis=1) D = [] for row in range(np.shape(X)[0]): D.append(weights[row] * self.logistic_function(np.dot(X[row, :], np.transpose(theta))) * (1 - self.logistic_function(np.dot(X[row, :], np.transpose(theta))))) D = np.diag(D) hessian = (np.matmul(np.matmul(X.T, D), X) - np.identity(np.shape(X)[1]) * reg_param) return hessian
def export(): # type: () -> None node = onnx.helper.make_node( 'MatMul', inputs=['a', 'b'], outputs=['c'], ) # 2d a = np.random.randn(3, 4).astype(np.float32) b = np.random.randn(4, 3).astype(np.float32) c = np.matmul(a, b) expect(node, inputs=[a, b], outputs=[c], name='test_matmul_2d') # 3d a = np.random.randn(2, 3, 4).astype(np.float32) b = np.random.randn(2, 4, 3).astype(np.float32) c = np.matmul(a, b) expect(node, inputs=[a, b], outputs=[c], name='test_matmul_3d') # 4d a = np.random.randn(1, 2, 3, 4).astype(np.float32) b = np.random.randn(1, 2, 4, 3).astype(np.float32) c = np.matmul(a, b) expect(node, inputs=[a, b], outputs=[c], name='test_matmul_4d')
def box3d_to_rgb_projections(boxes3d, Mt=None, Kt=None): if Mt is None: Mt = np.array(MATRIX_Mt) if Kt is None: Kt = np.array(MATRIX_Kt) num = len(boxes3d) projections = np.zeros((num,8,2), dtype=np.int32) for n in range(num): if 1: box3d = boxes3d[n] Ps = np.hstack(( box3d, np.ones((8,1))) ) Qs = np.matmul(Ps,Mt) Qs = Qs[:,0:3] qs = np.matmul(Qs,Kt) zs = qs[:,2].reshape(8,1) qs = (qs/zs) projections[n] = qs[:, 0:2] else: _Kt = ([[200, 0., 0.], [0., 200, 0.], [1368/2., 1096/2., 1.]]) Kt = np.array(_Kt) box3d = boxes3d[n].copy() box3d[:,0],box3d[:,1],box3d[:,2]=box3d[:,1],box3d[:,2],box3d[:,0] Qs=box3d qs = np.matmul(Qs, Kt) zs = qs[:, 2].reshape(8, 1) qs = (qs / zs) projections[n] = qs[:, 0:2] print(projections) return projections
def MRlogL_sandwichCov(dt, Ic, Is): """ Estimates the asymptotic covariance matrix with the sandwich method evaluated at the Maximum Likelihood Estimates for Ic, Is It's Cov_hessian * Cov_OPG^-1 * Cov_hessian INPUTS: dt: list of inter-arrival times [seconds] Ic: The maximum likelihood estimate of Ic [1/second] Is: OUTPUTS: covariance matrix for mle Ic, Is from sandwich method [[cov(Ic,Ic), cov(Ic,Is)], [cov(Is,Ic), cov(Is,Is)]] """ h_cov = MRlogL_hessianCov(dt, Ic, Is) grad_Ic = -1./(1./dt+Is) + 1./(Ic+Is+dt*Is**2.) grad_Is = dt**2.*Ic/(1.+dt*Is)**2. - 3.*dt/(1.+dt*Is) + (1.+2.*dt*Is)/(Ic+Is+dt*Is**2.) #n=1.0*len(dt) grad_Ic2 = np.sum(grad_Ic**2.) grad_Is2 = np.sum(grad_Is**2.) grad_IcIs = np.sum(grad_Ic*grad_Is) opg_cov_inv = np.asarray([[grad_Ic2, grad_IcIs], [grad_IcIs, grad_Is2]]) return np.matmul(np.matmul(h_cov, opg_cov_inv),h_cov)
def predict_new(self, X, z): first_layer_output = np.zeros(self.units) for unit in range(self.units): first_layer_output[unit] = self.activation(np.matmul(np.transpose(X), z[unit*(self.ar+len(self.X_names)+1):((unit+1)*(self.ar+len(self.X_names)+1))])) params_used = ((self.units)*(self.ar+len(self.X_names)+1)) # Hidden layers hidden_layer_output = np.zeros((self.units, self.layers-1)) for layer in range(1, self.layers): for unit in range(self.units): if layer == 1: hidden_layer_output[unit,layer-1] = self.activation(np.matmul(first_layer_output, z[params_used+unit*(self.units)+((layer-1)*self.units**2):((params_used+(unit+1)*self.units)+((layer-1)*self.units**2))])) else: hidden_layer_output[unit,layer-1] = self.activation(np.matmul(hidden_layer_output[:,layer-1], z[params_used+unit*(self.units)+((layer-1)*self.units**2):((params_used+(unit+1)*self.units)+((layer-1)*self.units**2))])) params_used = params_used + (self.layers-1)*self.units**2 # Output layer if self.layers == 1: mu = np.matmul(first_layer_output, z[params_used:params_used+self.units]) else: mu = np.matmul(hidden_layer_output[:,-1], z[params_used:params_used+self.units]) return mu
def backPropogation(W,H,A,y_hat,inputDataVector,trueOutput): grad_aL_Loss = np.zeros((numClasses,1)) if(loss=="ce"): grad_aL_Loss = -(trueClassVector(trueOutput,numClasses)-y_hat) else: #TODO squared error loss Identity = np.identity(numClasses) repeatMatrix = np.repeat(y_hat,numClasses,axis=1) changeI = Identity - repeatMatrix sumMatrix = np.multiply((y_hat - trueClassVector(trueOutput,numClasses)), y_hat) grad_aL_Loss = np.matmul(changeI,sumMatrix) grad_W_Loss = [] grad_B_Loss = [] for k in range(num_hidden,-1,-1): if k == 0: tempGrad_W_Loss = np.matmul(grad_aL_Loss,np.transpose(inputDataVector)) else: tempGrad_W_Loss = np.matmul(grad_aL_Loss,np.transpose(H[k-1])) grad_W_Loss.insert(0,np.copy(tempGrad_W_Loss)) grad_B_Loss.insert(0,np.copy(grad_aL_Loss)) if(k>0): if(activation=="sigmoid"): grad_aL_Loss = (np.matmul(np.transpose(W[k]),grad_aL_Loss))*sigmoidDerivativeFunctionToVector(A[k-1]) else: grad_aL_Loss = (np.matmul(np.transpose(W[k]),grad_aL_Loss))*tanhDerivativeFunctionToVector(A[k-1]) return grad_W_Loss,grad_B_Loss
def computeJonesRes(self): """Compute the Jones that results from applying the E-Jones to the right. The structure of the jonesrbasis is [timeIdx, sphIdx, skycompIdx]. """ idxshape = self.jonesrbasis.shape[0:-2] jonesrbasis = np.reshape(self.jonesrbasis, (-1, 3, 3)) jonesrbasis_to = np.matmul(np.asarray(self.stnRot.T), jonesrbasis) (az_from, el_from) = crt2sph(jonesrbasis[..., 0].squeeze().T) theta_phi_view = (np.pi/2-el_from.flatten(), az_from.flatten()) ejones = self.dualPolElem.getJonesAlong(self.freqChan, theta_phi_view) #(theta_lcl, phi_lcl) = self.dualPolElem.getBuildCoordinates(math.pi/2-r_sph[1], r_sph[0]) #print theta_lcl, phi_lcl r_lcl = crt2sph(jonesrbasis_to[..., 0].squeeze().T) #print np.rad2deg(r_lcl) jonesbasisMat = getSph2CartTransfMat(jonesrbasis_to[..., 0].squeeze()) #paraRot = np.matmul(np.conjugate(jonesbasisMat), jonesrbasis_to) self.jonesbasis = np.reshape(jonesbasisMat, idxshape+jonesbasisMat.shape[1:]) # This is the actual MEq multiplication: if ejones.ndim > 3: frqdimsz = (ejones.shape[0],) else: frqdimsz = () self.jones = np.reshape( np.matmul(ejones, np.reshape(self.jonesr, (-1, 2, 2))), frqdimsz+idxshape+(2, 2) ) self.thisjones = np.reshape(ejones, frqdimsz+idxshape+(2, 2))
def get_pelecs_and_pions(self, convert_to_muC_per_cm2=False): """ Get the electronic and ionic dipole moments / polarizations. convert_to_muC_per_cm2: Convert from electron * Angstroms to microCoulomb per centimeter**2 """ if not convert_to_muC_per_cm2: return self.p_elecs, self.p_ions if convert_to_muC_per_cm2: p_elecs = self.p_elecs.T p_ions = self.p_ions.T volumes = [s.lattice.volume for s in self.structures] e_to_muC = -1.6021766e-13 cm2_to_A2 = 1e16 units = 1.0 / np.array(volumes) units *= e_to_muC * cm2_to_A2 p_elecs = np.matmul(units, p_elecs) p_ions = np.matmul(units, p_ions) p_elecs, p_ions = p_elecs.T, p_ions.T return p_elecs, p_ions
def forwardPropogation(W,B,inputDataVector): A = [] H = [] A.append(np.add(B[0],np.matmul(W[0],inputDataVector))) if(activation=="sigmoid"): H.append(sigmoidFunctionToVector(A[0])) else: H.append(tanhFunctionToVector(A[0])) for k in range(1,num_hidden): A.append(np.add(B[k],np.matmul(W[k],H[k-1]))) if(activation=="sigmoid"): H.append(sigmoidFunctionToVector(A[k])) else: H.append(tanhFunctionToVector(A[k])) A.append(np.add(B[-1],np.matmul(W[-1],H[-1]))) y_hat = softmax(A[-1]) return A,H,y_hat
def TestBackpropMmt(): X = np.array([[0, 0, 1], [0, 1, 1], [1, 0, 1], [1, 1, 1]]) D = np.array([[0], [1], [1], [0]]) W1 = 2*np.random.random((4, 3)) - 1 W2 = 2*np.random.random((1, 4)) - 1 for _epoch in range(10000): W1, W2 = BackPropMmt(W1, W2, X, D) N = 4 for k in range(N): x = X[k, :].T v1 = np.matmul(W1, x) y1 = Sigmoid(v1) v = np.matmul(W2, y1) y = Sigmoid(v) print(y)
def _testSvdCorrectness(self, dtype, shape): np.random.seed(1) x_np = np.random.uniform(low=-1.0, high=1.0, size=shape).astype(dtype) m, n = shape[-2], shape[-1] _, s_np, _ = np.linalg.svd(x_np) with self.cached_session() as sess: x_tf = array_ops.placeholder(dtype) with self.test_scope(): s, u, v = linalg_ops.svd(x_tf, full_matrices=True) s_val, u_val, v_val = sess.run([s, u, v], feed_dict={x_tf: x_np}) u_diff = np.matmul(u_val, np.swapaxes(u_val, -1, -2)) - np.eye(m) v_diff = np.matmul(v_val, np.swapaxes(v_val, -1, -2)) - np.eye(n) # Check u_val and v_val are orthogonal matrices. self.assertLess(np.linalg.norm(u_diff), 1e-2) self.assertLess(np.linalg.norm(v_diff), 1e-2) # Check that the singular values are correct, i.e., close to the ones from # numpy.lingal.svd. self.assertLess(np.linalg.norm(s_val - s_np), 1e-2) # The tolerance is set based on our tests on numpy's svd. As our tests # have batch dimensions and all our operations are on float32, we set the # tolerance a bit larger. Numpy's svd calls LAPACK's svd, which operates # on double precision. self.assertLess( np.linalg.norm(self._compute_usvt(s_val, u_val, v_val) - x_np), 2e-2) # Check behavior with compute_uv=False. We expect to still see 3 outputs, # with a sentinel scalar 0 in the last two outputs. with self.test_scope(): no_uv_s, no_uv_u, no_uv_v = gen_linalg_ops.svd( x_tf, full_matrices=True, compute_uv=False) no_uv_s_val, no_uv_u_val, no_uv_v_val = sess.run( [no_uv_s, no_uv_u, no_uv_v], feed_dict={x_tf: x_np}) self.assertAllClose(no_uv_s_val, s_val, atol=1e-4, rtol=1e-4) self.assertEqual(no_uv_u_val, 0.0) self.assertEqual(no_uv_v_val, 0.0)
def angle_median(alpha, dt, speed, delta=1, offset=0.0, length=CAR_LENGTH): # Rotation radius # radius = length / np.sin(angle) # alpha = speed * dt / length * np.sin(angle) # Rotation matrices. rot_mat = np.zeros(shape=(len(alpha), 2, 2), dtype=np.float32) rot_mat[:, 1, 1] = np.cos(alpha) rot_mat[:, 0, 0] = np.cos(alpha) rot_mat[:, 0, 1] = np.sin(alpha) rot_mat[:, 1, 0] = -np.sin(alpha) # dx displacement vectors. dx = np.zeros(shape=(len(alpha), 2), dtype=np.float32) dx[:, 0] = speed * dt * cosc(alpha) dx[:, 1] = speed * dt * sinc(alpha) steps = np.ones(shape=(len(alpha), ), dtype=np.int8) # Local coordinate system. TODO: dense matrix notation... ax = np.zeros(shape=(len(alpha), 2, 1), dtype=np.float32) ay = np.zeros(shape=(len(alpha), 2, 1), dtype=np.float32) ax[:, 0, 0] = ay[:, 1, 0] = 1.0 ax = np.matmul(rot_mat, ax) ay = np.matmul(rot_mat, ay) # Delta - Cumulative transformations and dx. cumul_dx = dx.copy() for j in range(1, delta): # Update cumulative dx. cumul_dx[:-j, 0] += dx[j:, 0] * ax[:-j, 0, 0] cumul_dx[:-j, 1] += dx[j:, 0] * ax[:-j, 1, 0] cumul_dx[:-j, 0] += dx[j:, 1] * ay[:-j, 0, 0] cumul_dx[:-j, 1] += dx[j:, 1] * ay[:-j, 1, 0] # Update local coordinate system. ax[:-j] = np.matmul(rot_mat[j:], ax[:-j]) ay[:-j] = np.matmul(rot_mat[j:], ay[:-j]) steps[:-j] += 1 # Median fit... P0 = np.zeros(shape=(len(alpha), 2), dtype=np.float32) P0[:, 0] = offset P1 = cumul_dx mask = (P1[:, 1] < 0.) P1[mask, 1] = 0.0 # Parameters in equation: ax - b = 0. a = P1 - P0 m = (P0 + P1) / 2. b = a[:, 0] * m[:, 0] + a[:, 1] * m[:, 1] # Inverse radius and angle. kappa = a[:, 0] / b angle = np.arcsin(kappa * length) # Just in case... angle[np.isnan(angle)] = 0.0 return angle
def BackPropMmt(W1, W2, X, D): alpha = 0.9 beta = 0.9 mmt1 = np.zeros_like(W1) mmt2 = np.zeros_like(W2) N = 4 for k in range(N): x = X[k, :].T d = D[k] v1 = np.matmul(W1, x) y1 = Sigmoid(v1) v = np.matmul(W2, y1) y = Sigmoid(v) e = d - y delta = y*(1-y) * e e1 = np.matmul(W2.T, delta) delta1 = y1*(1-y1) * e1 dW1 = (alpha*delta1).reshape(4, 1) * x.reshape(1, 3) mmt1 = dW1 + beta*mmt1 W1 = W1 + mmt1 dW2 = alpha * delta * y1 mmt2 = dW2 + beta*mmt2 W2 = W2 + mmt2 return W1, W2
def predict(self, X_test): self.check_fitted() if X_test.ndim != 2: raise Exception("X_test should have 2 dimensions! X_dim:{}" .format(X_test.ndim)) X_test = np.float32(GPRNP.check_array(X_test)) test_size = X_test.shape[0] arr_offset = 0 length_scale = self.length_scale yhats = np.zeros([test_size, 1]) sigmas = np.zeros([test_size, 1]) eips = np.zeros([test_size, 1]) while arr_offset < test_size: if arr_offset + self.batch_size_ > test_size: end_offset = test_size else: end_offset = arr_offset + self.batch_size_ xt_ = X_test[arr_offset:end_offset] K2 = self.magnitude * np.exp(-ed(self.X_train, xt_) / length_scale) K3 = self.magnitude * np.exp(-ed(xt_, xt_) / length_scale) K2_trans = np.transpose(K2) yhat = np.matmul(K2_trans, np.matmul(self.K_inv, self.y_train)) sigma = np.sqrt(np.diag(K3 - np.matmul(K2_trans, np.matmul(self.K_inv, K2)))) \ .reshape(xt_.shape[0], 1) u = (self.y_best - yhat) / sigma phi1 = 0.5 * special.erf(u / np.sqrt(2.0)) + 0.5 phi2 = (1.0 / np.sqrt(2.0 * np.pi)) * np.exp(np.square(u) * (-0.5)) eip = sigma * (u * phi1 + phi2) yhats[arr_offset:end_offset] = yhat sigmas[arr_offset:end_offset] = sigma eips[arr_offset:end_offset] = eip arr_offset = end_offset GPRNP.check_output(yhats) GPRNP.check_output(sigmas) return GPRResult(yhats, sigmas)
def BackpropXOR(W1, W2, X, D): alpha = 0.9 N = 4 for k in range(N): x = X[k, :].T d = D[k] v1 = np.matmul(W1, x) y1 = Sigmoid(v1) v = np.matmul(W2, y1) y = Sigmoid(v) e = d - y delta = y*(1-y) * e e1 = np.matmul(W2.T, delta) delta1 = y1*(1-y1) * e1 dW1 = (alpha*delta1).reshape(4, 1) * x.reshape(1, 3) W1 = W1 + dW1 dW2 = alpha * delta * y1 W2 = W2 + dW2 return W1, W2
def rotate_moment_tensor(mt,R): """ rotates moment-tensor mt using rotation matrix R """ # converts from eigenvectors & eigenvalues representation to harvard-convention # mt = [Mrr, Mtt, Mpp, Mrt, Mrp, Mtp ] (given in diagonal-form) M11 = mt[0] M22 = mt[1] M33 = mt[2] M12 = mt[3] M13 = mt[4] M23 = mt[5] # symmetric 3x3 moment-tensor mat = np.array([ [M11,M12,M13], [M12,M22,M23], [M13,M23,M33] ]) # using rotation matrix R (is eigenvector matrix here): R * M * transp(R) res = np.matmul(mat,np.transpose(R)) mat = np.matmul(R,res) # note: rotation back to original coordinate-frame will introduce numerical round-off errors #print(" rotated mat:\n",R,mat) # mt = [Mrr, Mtt, Mpp, Mrt, Mrp, Mtp ] mt_rot = np.array([mat[0,0],mat[1,1],mat[2,2],mat[0,1],mat[0,2],mat[1,2]]) return mt_rot
def backward(self, y, all_x): """backward :param y: the label, the actual class of the samples, in one-hot format :param all_x: input data and activation from every layer """ # [TODO 1.5] Compute delta factor from the output delta = all_x[-1] - y delta /= y.shape[0] # print('last delta shape = ', delta.shape) # [TODO 1.5] Compute gradient of the loss function with respect to w of softmax layer, use delta from the output grad_last = np.matmul(np.transpose(all_x[-2]), delta) grad_list = [] grad_list.append(grad_last) for i in range(len(self.layers) - 1)[::-1]: prev_layer = self.layers[i+1] layer = self.layers[i] x = all_x[i] # [TODO 1.5] Compute delta_prev factor for previous layer (in backpropagation direction) # print('last layer shape = ', prev_layer.w.shape) delta_prev = np.matmul(delta, np.transpose(prev_layer.w)) # Use delta_prev to compute delta factor for the next layer (in backpropagation direction) grad_w, delta = layer.backward(x, delta_prev) grad_list.append(grad_w.copy()) grad_list = grad_list[::-1] return grad_list
def get_inverse_transform(self, im_ref, mode='affine'): aff_im_self = self.im_file.affine aff_im_ref = im_ref.im_file.affine if mode == 'affine': transform = np.matmul(np.linalg.inv(aff_im_ref), aff_im_self) else: T_self, R_self, Sc_self, Sh_self = affines.decompose44(aff_im_self) T_ref, R_ref, Sc_ref, Sh_ref = affines.decompose44(aff_im_ref) if mode == 'translation': T_transform = T_self - T_ref R_transform = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]]) Sc_transform = np.array([1.0, 1.0, 1.0]) transform = affines.compose(T_transform, R_transform, Sc_transform) elif mode == 'rigid': T_transform = T_self - T_ref R_transform = np.matmul(np.linalg.inv(R_ref), R_self) Sc_transform = np.array([1.0, 1.0, 1.0]) transform = affines.compose(T_transform, R_transform, Sc_transform) elif mode == 'rigid_scaling': T_transform = T_self - T_ref R_transform = np.matmul(np.linalg.inv(R_ref), R_self) Sc_transform = Sc_self / Sc_ref transform = affines.compose(T_transform, R_transform, Sc_transform) else: transform = np.array([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]) return transform
def get_Matrix_VC(self): H_x_to_xe0 = np.zeros([self.num_all_edges, self.n], np.float32) H_sum_by_V_to_C = np.zeros([self.num_all_edges, self.num_all_edges], dtype=np.float32) H_xe_last_to_y = np.zeros([self.n, self.num_all_edges], dtype=np.float32) Map_row_to_line = np.zeros([self.num_all_edges, 1]) for i in range(0, self.num_all_edges): Map_row_to_line[i] = np.where(self.loc_nzero1 == self.loc_nzero2[i]) map_H_row_to_line = np.zeros([self.num_all_edges, self.num_all_edges], dtype=np.float32) for i in range(0, self.num_all_edges): map_H_row_to_line[i, int(Map_row_to_line[i])] = 1 count = 0 for i in range(0, self.n): temp = count + self.H_sum_line[i] H_sum_by_V_to_C[count:temp, count:temp] = 1 H_xe_last_to_y[i, count:temp] = 1 H_x_to_xe0[count:temp, i] = 1 for j in range(0, self.H_sum_line[i]): H_sum_by_V_to_C[count + j, count + j] = 0 count = count + self.H_sum_line[i] print("return Matrics V-C successfully!\n") return H_x_to_xe0, np.matmul(H_sum_by_V_to_C, map_H_row_to_line), np.matmul(H_xe_last_to_y, map_H_row_to_line)
def calculate_discretization(self, X, U, sigma): """ Calculate discretization for given states, inputs and total time. :param X: Matrix of states for all time points :param U: Matrix of inputs for all time points :param sigma: Total time :return: The discretization matrices """ for k in range(self.K - 1): self.V0[self.x_ind] = X[:, k] V = np.array(odeint(self._ode_dVdt, self.V0, (0, self.dt), args=(U[:, k], U[:, k + 1], sigma))[1, :]) # using \Phi_A(\tau_{k+1},\xi) = \Phi_A(\tau_{k+1},\tau_k)\Phi_A(\xi,\tau_k)^{-1} # flatten matrices in column-major (Fortran) order for CVXPY Phi = V[self.A_bar_ind].reshape((self.n_x, self.n_x)) self.A_bar[:, k] = Phi.flatten(order='F') self.B_bar[:, k] = np.matmul(Phi, V[self.B_bar_ind].reshape( (self.n_x, self.n_u))).flatten(order='F') self.C_bar[:, k] = np.matmul(Phi, V[self.C_bar_ind].reshape( (self.n_x, self.n_u))).flatten(order='F') self.S_bar[:, k] = np.matmul(Phi, V[self.S_bar_ind]) self.z_bar[:, k] = np.matmul(Phi, V[self.z_bar_ind]) return self.A_bar, self.B_bar, self.C_bar, self.S_bar, self.z_bar
def dlnprob(self, theta): if self.batchsize > 0: batch = [ i % self.N for i in range(self.iter * self.batchsize, (self.iter + 1) * self.batchsize) ] ridx = self.permutation[batch] self.iter += 1 else: ridx = np.random.permutation(self.X.shape[0]) Xs = self.X[ridx, :] Ys = self.Y[ridx] w = theta[:, :-1] # logistic weights alpha = np.exp(theta[:, -1]) # the last column is logalpha d = w.shape[1] wt = np.multiply((alpha / 2), np.sum(w ** 2, axis=1)) coff = np.matmul(Xs, w.T) y_hat = 1.0 / (1.0 + np.exp(-1 * coff)) dw_data = np.matmul(((nm.repmat(np.vstack(Ys), 1, theta.shape[0]) + 1) / 2.0 - y_hat).T, Xs) # Y \in {-1,1} dw_prior = -np.multiply(nm.repmat(np.vstack(alpha), 1, d) , w) dw = dw_data * 1.0 * self.X.shape[0] / Xs.shape[0] + dw_prior # re-scale dalpha = d / 2.0 - wt + (self.a0 - 1) - self.b0 * alpha + 1 # the last term is the jacobian term return np.hstack([dw, np.vstack(dalpha)]) # % first order derivative
def rotate_smooth(self, current_up, current_angvel, target_rot, speed = 0.01): for i in range(len(target_rot)): if target_rot[i] > 360: target_rot[i] -= 360 if target_rot[i] < 0: target_rot[i] += 360 # direction = (np.array(target_rot) - np.array(current_rot)) # print str(target_rot) # print str(current_rot) # direction = speed * direction target_rot = np.array(target_rot) target_rot = np.deg2rad(target_rot) # x axis rotation th = target_rot[0] rx = np.array([[1, 0, 0], [0, np.cos(th), np.sin(th)], [0, -np.sin(th), np.cos(th)]]) # y axis rotation th = target_rot[1] ry = np.array([[np.cos(th), 0, -np.sin(th)], [0, 1, 0], [np.sin(th), 0, np.cos(th)]]) # z axis rotation th = target_rot[2] rz = np.array([[np.cos(th), np.sin(th), 0], [-np.sin(th), np.cos(th), 0], [0, 0, 1]]) target_axis = np.matmul(np.matmul(np.matmul(rx,ry), rz), current_up) # z rotation only does not work with [0, 0, 1] have to rotate around other axis #if(target_axis == np.array([0, 0, 1])).all(): # current_up = [0, 1, 0] # target_axis = np.matmul(np.matmul(np.matmul(rx,ry), rz), current_up) return target_axis #self.stabilize(current_up, current_angvel, target_axis)
def box3d_to_rgb_box(boxes3d, Mt=None, Kt=None): if (cfg.DATA_SETS_TYPE == 'kitti'): if Mt is None: Mt = np.array(MATRIX_Mt) if Kt is None: Kt = np.array(MATRIX_Kt) num = len(boxes3d) projections = np.zeros((num,8,2), dtype=np.int32) for n in range(num): box3d = boxes3d[n] Ps = np.hstack(( box3d, np.ones((8,1))) ) Qs = np.matmul(Ps,Mt) Qs = Qs[:,0:3] qs = np.matmul(Qs,Kt) zs = qs[:,2].reshape(8,1) qs = (qs/zs) projections[n] = qs[:,0:2] return projections else: num = len(boxes3d) projections = np.zeros((num, 8, 2), dtype=np.int32) for n in range(num): box3d=boxes3d[n].copy() if np.sum(box3d[:,0]>0) >0: box2d = box3d_to_rgb_projection_cv2(box3d) box2d,out_range=convert_points_to_croped_image(box2d) if np.sum(out_range==False)>=2: projections[n]=box2d return projections
def _mel_to_linear_matrix(self): """Get the inverse mel transformation matrix.""" m = self._linear_to_mel_matrix() m_t = np.transpose(m) p = np.matmul(m, m_t) d = [1.0 / x if np.abs(x) > 1.0e-8 else x for x in np.sum(p, axis=0)] return np.matmul(m_t, np.diag(d))
def geometric_distort (image0): assert image0.shape[0] == image0.shape[1], 'need a square on input' assert is_bgra(image0), image0.shape # warp shear1 = exp((np.random.rand()-0.5) * COEF_SHEAR) rot = np.random.randn() * COEF_ROT shear2 = exp((np.random.rand()-0.5) * COEF_SHEAR) Shear1 = np.asarray([[shear1, 0], [0, 1.0/shear1]]) Rot = np.asarray([[cos(rot), sin(rot)], [-sin(rot), cos(rot)]]) Shear2 = np.asarray([[shear2, 0], [0, 1.0/shear2]]) #print shear1, rot, shear2 M = np.matmul(np.matmul(Shear2, Rot), Shear1) image = warp_patch (image0, M, 2) # crop to roi nnz = np.nonzero(image[:,:,3]) # roi = [y1 x1 y2 x2) roi = (min(nnz[0].tolist()), min(nnz[1].tolist()), max(nnz[0].tolist()), max(nnz[1].tolist())) #print roi image = image[roi[0]:roi[2],roi[1]:roi[3],:] return image
def back_propagation(self, xs, ts): """ calc back propagation of cross_entropy [in] xs: train image data ts: one hot vector corresponds the answer of x [out] pertial derivatives of MSE """ W1, W2 = self.parameters['W1'], self.parameters['W2'] b1, b2 = self.parameters['b1'], self.parameters['b2'] grads = {} batch_num = xs.shape[0] # forward z0 = xs u1 = np.matmul(z0, W1)+b1 z1 = sigmoid(u1) u2 = np.matmul(z1, W2)+b2 ys = softmax(u2) # backward # calc output layer error delta_output = (ys - ts) / batch_num # backward to hidden layer grads['W2'] = np.dot(z1.T, delta_output) grads['b2'] = np.sum(delta_output, axis=0) # take Hadamard product delta_1 = deriv_sigmoid(u1) * np.dot(delta_output, W2.T) # backward to hidden layer grads['W1'] = np.dot(z0.T, delta_1) grads['b1'] = np.sum(delta_1, axis=0) return grads
def MultiClass(W1, W2, X, D): alpha = 0.9 N = 5 for k in range(N): x = np.reshape(X[:,:,k], (25, 1)) d = D[k, :].T v1 = np.matmul(W1, x) y1 = Sigmoid(v1) v = np.matmul(W2, y1) y = Softmax(v) e = d - y delta = e e1 = np.matmul(W2.T, delta) delta1 = y1*(1-y1) * e1 dW1 = alpha * delta1 * x.T W1 = W1 + dW1 dW2 = alpha * delta * y1.T W2 = W2 + dW2 return W1, W2
def update_data(t): """ Is run each step Calculates the seedbank size and plant population in the next step by multiplying M, the transition matrix, by X, the data matrix """ global M global D global M_original global D_original if STEP_OUTPUT: print "[t: {}] Updating data...".format(t) # Manual changes in transition matrix and disperion matrix if t == 30: # Initial inundation of right side. Good graphs with N = 50, T = 75, for cell_i in range(N-26, N): M[cell_i,0] = [ss*(1-g*0.001), 0.0] M[cell_i,1] = [g*0.001, l*0.001] # Migrate Seeds Produced X[t + 1] = np.transpose([np.matmul(M[c], X[t, :, c]) for c in range(0, int(N))]) + \ np.matmul(e * np.transpose([[X[t, 1, c], 0] for c in range(0, int(N))]), D) if STEP_OUTPUT: print X[t] if t == T - 2: print "Data Calculation finished"
def projectBackBFM_withExpr(model, features, expr_paras): alpha = model.shapeEV * 0 for it in range(0, 99): alpha[it] = model.shapeEV[it] * features[it] S = np.matmul(model.shapePC, alpha) expr = model.expEV * 0 for it in range(0, 29): expr[it] = model.expEV[it] * expr_paras[it] E = np.matmul(model.expPC, expr) ## Adding back average shape S = model.shapeMU + S + model.expMU + E numVert = S.shape[0]/3 # (Texture) beta = model.texEV * 0 for it in range(0, 99): beta[it] = model.texEV[it] * features[it+99] T = np.matmul(model.texPC, beta) ## Adding back average texture T = model.texMU + T ## Some filtering T = [truncateUint8(value) for value in T] ## Final Saving for visualization S = np.reshape(S,(numVert,3)) T = np.reshape(T,(numVert, 3)) return S,T
def backward(self): if self.x.grad is not None: self.x.grad = self.x.grad + np.matmul(self.y.value, self.grad.T).T if self.y.grad is not None: nabla = np.matmul(self.x.value.T.reshape(list(self.x.value.shape) + [1]), self.grad.reshape([1] + list(self.grad.shape))) self.y.grad = self.y.grad + nabla
def Calculate_IDCT(self): self.TM = np.matmul(self.Tt, self.R) self.fin = np.matmul(self.TM, self.T) self.fin = self.fin.astype(int)
feed_dict['output'][1]['output'], weights=feed_dict['output'][2]['weights'], nodes=layers[2]['nodes'], activation=layers[2]['activation']) #cost calculation cost_per_epoch = cost_per_epoch - np.log( feed_dict['output'][2]['output'][np.argmax( feed_dict['train_label'][i + batch * batch_size])]) #calculating the gradients feed_dict['output'][2]['semi_update'] = feed_dict['output'][2][ 'output'] - feed_dict['train_label'][ i + batch * batch_size].reshape(-1, 1) feed_dict['output'][2]['update'] = np.matmul( feed_dict['output'][2]['semi_update'], np.transpose(np.vstack((feed_dict['output'][1]['output'], 1)))) temp = feed_dict['output'][2][ 'weights'][:, 0:feed_dict['output'][2]['weights'].shape[1] - 1] feed_dict['output'][1]['semi_update'] = np.matmul( np.transpose(temp), feed_dict['output'][2]['semi_update']) * deriv( feed_dict['output'][1]['output_raw']) feed_dict['output'][1]['update'] = np.matmul( feed_dict['output'][1]['semi_update'], np.transpose(np.vstack((feed_dict['output'][0]['output'], 1)))) temp = feed_dict['output'][1][ 'weights'][:, 0:feed_dict['output'][1]['weights'].shape[1] - 1] feed_dict['output'][0]['semi_update'] = np.matmul(
wage = train_data[0:2250, 10] yeart = train_data[2250:3000, 0] aget = train_data[2250:3000, 1] edut = train_data[2250:3000, 4] waget = train_data[2250:3000, 10] error = 0 degree = 6 #input the degree here Y = [] i = 0 x = np.linspace(20, 80, 400) x = np.array(x) X = np.ones(np.size(age)) X = np.transpose(X) for i in range(degree): X = np.c_[X, age**(i + 1)] W = np.matmul(np.linalg.inv(np.matmul(np.transpose(X), X)), np.matmul(np.transpose(X), wage)) Y = W[0] * np.ones(400) for i in range(1, degree + 1): Y = Y + W[i] * (x**i) for i in range(0, 750): a = 0 for j in range(0, degree + 1): a = a + W[j] * (aget[i]**j) error = error + (a - waget[i])**2 print(error) plt.xlabel("Wage") plt.ylabel("Age") plt.title("Polynomial regression for Age Vs Wage") # error plt.plot(age, wage, 'r.') #points plt.plot(x, Y) #Plot of the curve plt.show()
def superitems_duals(superitems_pool, duals): """ Compute Superitems dual from the given Items duals and SuperitemsPool """ fsi, _, _ = superitems_pool.get_fsi() return np.matmul(duals, fsi.T)
def get_cloud_and_segments(self, dist=0.2, small_segment_size=250): """Get the point cloud and the segment values. Parameters ---------- dist : float Threshold. If distance points in segments is greater than dist, than the segment will be split. small_segment_size : int Threshold to specify a small segments. The small segments will be deleted. Returns ------- tuple(np.ndarray, np.ndarray, int) The point cloud, the segments and the scene id. """ segments_filepath = "./ScannetScenes/" + self.id + "/" + self.id + "_segments.pcd" color_filepath = "./ScannetScenes/" + self.id + "/" + self.id + "_color.pcd" filtered_idxs_filepath = "./ScannetScenes/" + self.id + "/" + self.id + "_indices.txt" save_path = "./ScannetScenes/" + self.id + "/" + self.id + ".npz" segments_path = "./ScannetScenes/" + self.id + "/" + self.id + "_segments.npz" if not os.path.isfile(segments_path): P, C, orig_segments = load( segments_filepath=segments_filepath, color_filepath=color_filepath, filtered_idxs_filepath=filtered_idxs_filepath, save_path=save_path, verbose=self.verbose) uni_segments = np.unique(orig_segments) n_segments = uni_segments.shape[0] if self.verbose: print("n segments:", n_segments) P = np.hstack((P, C)) if self.verbose: print("split segments") orig_segments, n_segments = split_segments( P=P, segments=orig_segments, dist=dist, verbose=self.verbose) if self.verbose: print("n segments", n_segments) print("sort points according to segment idxs") sorted_idxs = np.argsort(orig_segments) orig_segments = orig_segments[sorted_idxs] P = P[sorted_idxs] uni_segments, uni_idxs, uni_counts = np.unique( orig_segments, return_index=True, return_counts=True) n_segments = uni_segments.shape[0] if self.verbose: print("n segments:", n_segments) np.savez(segments_path, P=P, orig_segments=orig_segments) if self.verbose: print("segments saved") else: data = np.load(segments_path) P = data["P"] orig_segments = data["orig_segments"] if self.verbose: print("segments loaded") P[:, 3:] *= 255 if self.verbose: print("filter small segments") idx_to_del = filter_small_segments( arr=orig_segments, small_segment_size=small_segment_size, verbose=self.verbose) P = np.delete(P, idx_to_del, axis=0) orig_segments = np.delete(orig_segments, idx_to_del) if self.verbose: print("reassgin segments") orig_segments, n_segments, _ = create_segments(arr=orig_segments) xyz_mean = np.mean(P[:, :3], axis=0) P[:, :3] = P[:, :3] - xyz_mean pca = PCA() pca.fit(P[:, :3]) vec = pca.components_[0] ang = angle(vec, np.array([1, 0, 0])) if self.verbose: print("rotate P around", -np.rad2deg(ang), "°") R = get_rotation_mat(angle=-ang, axis=np.array([0, 0, 1])) P[:, :3] = np.transpose(np.matmul(R, np.transpose(P[:, :3]))) self.P = P self.segments = orig_segments return self.P, self.segments, self.id
def backward(self): if self.x.grad is None: return gvdot = np.matmul(self.grad[..., np.newaxis, :], self.value[..., np.newaxis]).squeeze(-1) self.x.grad = self.x.grad + self.value * (self.grad - gvdot)
def master_problem(layer_pool, tlim=None, relaxation=True, enable_output=False): """ Solve the master problem, either in its full version (MP) or in its relaxed version (RMP). Returns the following: - Objective value: minimization of sum(alpha[l] * h[l]), with h heights and l layer - Alpha values: alpha[l] represents layer selection - [RMP] Duals: one dual for each item """ logger.info("RMP defining variables and constraints") # Solver if relaxation: slv = pywraplp.Solver("RMP", pywraplp.Solver.GLOP_LINEAR_PROGRAMMING) else: slv = pywraplp.Solver("MP", pywraplp.Solver.BOP_INTEGER_PROGRAMMING) # Enable verbose output from solver if enable_output: slv.EnableOutput() # Utility fsi, _, _ = layer_pool.superitems_pool.get_fsi() zsl = layer_pool.get_zsl() ol = layer_pool.get_ol() infinity = slv.infinity() n_layers = len(layer_pool) n_items = fsi.shape[-1] # Variables if relaxation: al = [slv.NumVar(0, infinity, f"alpha_{l}") for l in range(n_layers)] else: al = [slv.BoolVar(f"alpha_{l}") for l in range(n_layers)] # Constraints constraints = [] coefficients = np.matmul(fsi.T, zsl) # Select each item at least once # sum(al[l] * zsl[s, l] * fsi[s, i]) for i in range(n_items): c = slv.Constraint(1, infinity, f"c_{i}") for l in range(n_layers): if coefficients[i, l] > 0: c.SetCoefficient(al[l], float(coefficients[i, l])) constraints += [c] # Objective obj = slv.Objective() for l, h in enumerate(ol): obj.SetCoefficient(al[l], float(h)) obj.SetMinimization() # Set a time limit in milliseconds if tlim is not None: slv.SetTimeLimit(1000 * tlim) # Solve logger.debug(f"RMP variables: {slv.NumVariables()}") logger.debug(f"RMP constraints: {slv.NumConstraints()}") status = slv.Solve() logger.debug(f"RMP iterations: {slv.iterations()}") # Extract results duals, alphas = None, None objective = float("inf") if status in (slv.OPTIMAL, slv.FEASIBLE): logger.info(f"RMP solved") # Extract alpha values alphas = [al[l].solution_value() for l in range(n_layers)] logger.debug(f"RMP alphas: {alphas}") if not all(alphas[l] in (0, 1) for l in range(n_layers)): logger.debug("RMP solution not feasible (at least one alpha value is not binary)") # Extract objective value objective = slv.Objective().Value() logger.debug(f"RMP objective: {objective}") # Extract duals if relaxation: duals = np.array([c.DualValue() for c in constraints]) logger.debug(f"RMP duals: {duals}") else: logger.warning("RMP unfeasible") logger.debug(f"RMP time: {slv.WallTime() / 1000}") return objective, alphas, duals
def forward(self): self.value = np.matmul(self.x.value, self.y.value)
true_vect = strf_to_vector(true_strf) # # plots the stim, delayed lines version, STRF and vectorized STRF # fig, axes = plt.subplots(2,2) # axes = np.ravel(axes) # axes[0].imshow(X, aspect='auto') # axes[0].set_title('stimulus') # axes[1].imshow(delayed, aspect='auto') # axes[1].set_title('stim delayed lines') # axes[2].imshow(true_strf, aspect='auto') # axes[2].set_title('true STRF') # axes[3].imshow(true_vect[:, None],) # axes[3].set_title('true vector') # uses matrix multiplication to get the STRF response(Y) to the dummy sound (X) Y = np.matmul(true_vect, delayed) # defienes linear model model = Sequential() model.add( Dense(1, input_dim=int(channels * delays), kernel_initializer='normal', activation='linear')) model.compile(loss='mean_squared_error', optimizer='adam') # fits the model and transforms the vector into the equivalent STRF model.fit(delayed.T, Y, batch_size=100, epochs=10000, verbose=1) fit_vect = model.layers[0].get_weights()[0].squeeze() fit_strf = vector_to_strf(fit_vect, delays)
# Truth - each column of phi spans the global domain phi_trunc, cf_trunc = generate_pod_bases(sm, num_modes, tsteps) perfect_output = cf_trunc[:, -1] # # POD Galerkin - for comparison output_state_gp, state_tracker_gp = galerkin_projection( phi_trunc, cf_trunc, sm_mean, tsteps, Rnum, dt, dx, num_modes) # # LSTM network - note this will only give good predictions till the last three timesteps model = lstm_for_dynamics(cf_trunc, deployment_mode) output_state_lstm, state_tracker_lstm = evaluate_rom_deployment_lstm( model, cf_trunc, tsteps) np.save('Burgulence_LSTM_Coefficients.npy', state_tracker_lstm) #Visualization - Spectra u_true = sm_mean + (np.matmul(phi_trunc, perfect_output))[:] u_gp = sm_mean + (np.matmul(phi_trunc, output_state_gp))[:] u_lstm = sm_mean + (np.matmul(phi_trunc, output_state_lstm[:, 0]))[:] plt.figure() kx_plot = np.array([float(i) for i in list(range(0, nx // 2))]) espec1 = spectra_calculation(u_true) espec2 = spectra_calculation(u_gp) espec3 = spectra_calculation(u_lstm) plt.loglog(kx_plot, espec1, label='Truth') plt.loglog(kx_plot, espec2, label='GP') plt.loglog(kx_plot, espec3, label='LSTM') plt.legend() plt.show() # Spectra residuals
def backward(self): if self.x.grad is not None: self.x.grad = self.x.grad + np.matmul(self.y.value, self.grad.T).T if self.y.grad is not None: self.y.grad = self.y.grad + np.matmul(self.x.value.T, self.grad)
def _mean(self, x): ks = self._kernel(x, self._x) return np.matmul(ks.T, self._kfmap)
#print (x) #print (s) #print (v.shape) su = 0 x_axis = [] y_axis = [] for i in range(0,520,1): su += s[i]; per = su/x; # Percentage of image re-constructed x_axis.append(i+1) # x-axis contains : No. of feature taken for the reconstruction of image y_axis.append(per) v = np.transpose(v); # Transpose coeff = np.matmul(im_matrix,v) #Coefficient Matrix , Reconstruction a = coeff[:,0:1] b = coeff[:,1:2] c = coeff[:,2:3] d = np.zeros(520) plt.scatter(a,d) plt.xlabel('PCA-1') plt.title('1-Dimensinal Plot') plt.figure() plt.scatter(a,b) plt.xlabel('PCA-2') plt.ylabel('PCA-3') plt.title('2-Dimensinal Plot')
def simrank_similarity_numpy( G, source=None, target=None, importance_factor=0.9, max_iterations=100, tolerance=1e-4, ): """Calculate SimRank of nodes in ``G`` using matrices with ``numpy``. The SimRank algorithm for determining node similarity is defined in [1]_. Parameters ---------- G : NetworkX graph A NetworkX graph source : node If this is specified, the returned dictionary maps each node ``v`` in the graph to the similarity between ``source`` and ``v``. target : node If both ``source`` and ``target`` are specified, the similarity value between ``source`` and ``target`` is returned. If ``target`` is specified but ``source`` is not, this argument is ignored. importance_factor : float The relative importance of indirect neighbors with respect to direct neighbors. max_iterations : integer Maximum number of iterations. tolerance : float Error tolerance used to check convergence. When an iteration of the algorithm finds that no similarity value changes more than this amount, the algorithm halts. Returns ------- similarity : numpy matrix, numpy array or float If ``source`` and ``target`` are both ``None``, this returns a Matrix containing SimRank scores of the nodes. If ``source`` is not ``None`` but ``target`` is, this returns an Array containing SimRank scores of ``source`` and that node. If neither ``source`` nor ``target`` is ``None``, this returns the similarity value for the given pair of nodes. Examples -------- >>> from numpy import array >>> G = nx.cycle_graph(4) >>> sim = nx.simrank_similarity_numpy(G) References ---------- .. [1] G. Jeh and J. Widom. "SimRank: a measure of structural-context similarity", In KDD'02: Proceedings of the Eighth ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, pp. 538--543. ACM Press, 2002. """ # This algorithm follows roughly # # S = max{C * (A.T * S * A), I} # # where C is the importance factor, A is the column normalized # adjacency matrix, and I is the identity matrix. import numpy as np adjacency_matrix = nx.to_numpy_array(G) # column-normalize the ``adjacency_matrix`` adjacency_matrix /= adjacency_matrix.sum(axis=0) newsim = np.eye(adjacency_matrix.shape[0], dtype=np.float64) for _ in range(max_iterations): prevsim = np.copy(newsim) newsim = importance_factor * np.matmul( np.matmul(adjacency_matrix.T, prevsim), adjacency_matrix ) np.fill_diagonal(newsim, 1.0) if np.allclose(prevsim, newsim, atol=tolerance): break if source is not None and target is not None: return newsim[source, target] if source is not None: return newsim[source] return newsim
def test_single_tree_nonlinear_transformations(): """ Make sure Independent Tree SHAP single trees with non-linear transformations. """ # Supported non-linear transforms # def sigmoid(x): # return(1/(1+np.exp(-x))) # def log_loss(yt,yp): # return(-(yt*np.log(yp) + (1 - yt)*np.log(1 - yp))) # def mse(yt,yp): # return(np.square(yt-yp)) try: import xgboost except: print("Skipping test_several_trees!") return import shap import numpy as np np.random.seed(10) n = 1000 X = np.random.normal(size=(n, 7)) b = np.array([-2, 1, 3, 5, 2, 20, -5]) y = np.matmul(X, b) y = y + abs(min(y)) y = np.random.binomial(n=1, p=y / max(y)) max_depth = 6 # train a model with single tree Xd = xgboost.DMatrix(X, label=y) model = xgboost.train( { 'eta': 1, 'max_depth': max_depth, 'base_score': y.mean(), "lambda": 0, "objective": "binary:logistic" }, Xd, 1) pred = model.predict(Xd, output_margin=True) # In margin space (log odds) trans_pred = model.predict(Xd) # In probability space expl = shap.TreeExplainer(model, X, feature_perturbation="interventional") f = lambda inp: model.predict(xgboost.DMatrix(inp), output_margin=True) expl_kern = shap.KernelExplainer(f, X) x_ind = 0 x = X[x_ind:x_ind + 1, :] itshap = expl.shap_values(x) kshap = expl_kern.shap_values(x, nsamples=300) assert np.allclose(itshap.sum() + expl.expected_value, pred[x_ind]), \ "SHAP values don't sum to model output on explaining margin!" assert np.allclose(itshap, kshap), \ "Independent Tree SHAP doesn't match Kernel SHAP on explaining margin!" model.set_attr(objective="binary:logistic") expl = shap.TreeExplainer(model, X, feature_perturbation="interventional", model_output="probability") itshap = expl.shap_values(x) assert np.allclose(itshap.sum() + expl.expected_value, trans_pred[x_ind]), \ "SHAP values don't sum to model output on explaining logistic!"
import numpy as np a = np.array([2,4,6,8]).reshape(2,2) b = np.array([2,2,2,2]).reshape(2,2) print(a) print(b) print(a+b) print(a-b) print(a*b) print(a/b) # 행열의 곱셈 print(np.matmul(a,b))
def testSampleLarge(self): mu = np.array([-1., 1], dtype=np.float32) scale_tril = np.array([[3., 0], [1, -2]], dtype=np.float32) / 3. true_mean = mu true_scale = scale_tril true_covariance = np.matmul(true_scale, true_scale.T) true_variance = np.diag(true_covariance) true_stddev = np.sqrt(true_variance) dist = tfd.MultivariateNormalTriL(loc=mu, scale_tril=scale_tril, validate_args=True) # The following distributions will test the KL divergence calculation. mvn_chol = tfd.MultivariateNormalTriL(loc=np.array([0.5, 1.2], dtype=np.float32), scale_tril=np.array( [[3., 0], [1, 2]], dtype=np.float32), validate_args=True) n = int(10e3) samps = dist.sample(n, seed=test_util.test_seed()) sample_mean = tf.reduce_mean(input_tensor=samps, axis=0) x = samps - sample_mean sample_covariance = tf.matmul(x, x, transpose_a=True) / n sample_kl_chol = tf.reduce_mean(input_tensor=dist.log_prob(samps) - mvn_chol.log_prob(samps), axis=0) analytical_kl_chol = tfd.kl_divergence(dist, mvn_chol) scale = dist.scale.to_dense() [ sample_mean_, analytical_mean_, sample_covariance_, analytical_covariance_, analytical_variance_, analytical_stddev_, sample_kl_chol_, analytical_kl_chol_, scale_, ] = self.evaluate([ sample_mean, dist.mean(), sample_covariance, dist.covariance(), dist.variance(), dist.stddev(), sample_kl_chol, analytical_kl_chol, scale, ]) sample_variance_ = np.diag(sample_covariance_) sample_stddev_ = np.sqrt(sample_variance_) tf1.logging.vlog(2, "true_mean:\n{} ".format(true_mean)) tf1.logging.vlog(2, "sample_mean:\n{}".format(sample_mean_)) tf1.logging.vlog(2, "analytical_mean:\n{}".format(analytical_mean_)) tf1.logging.vlog(2, "true_covariance:\n{}".format(true_covariance)) tf1.logging.vlog(2, "sample_covariance:\n{}".format(sample_covariance_)) tf1.logging.vlog( 2, "analytical_covariance:\n{}".format(analytical_covariance_)) tf1.logging.vlog(2, "true_variance:\n{}".format(true_variance)) tf1.logging.vlog(2, "sample_variance:\n{}".format(sample_variance_)) tf1.logging.vlog( 2, "analytical_variance:\n{}".format(analytical_variance_)) tf1.logging.vlog(2, "true_stddev:\n{}".format(true_stddev)) tf1.logging.vlog(2, "sample_stddev:\n{}".format(sample_stddev_)) tf1.logging.vlog(2, "analytical_stddev:\n{}".format(analytical_stddev_)) tf1.logging.vlog(2, "true_scale:\n{}".format(true_scale)) tf1.logging.vlog(2, "scale:\n{}".format(scale_)) tf1.logging.vlog( 2, "kl_chol: analytical:{} sample:{}".format( analytical_kl_chol_, sample_kl_chol_)) self.assertAllClose(true_mean, sample_mean_, atol=0., rtol=0.03) self.assertAllClose(true_mean, analytical_mean_, atol=0., rtol=1e-6) self.assertAllClose(true_covariance, sample_covariance_, atol=0., rtol=0.03) self.assertAllClose(true_covariance, analytical_covariance_, atol=0., rtol=1e-6) self.assertAllClose(true_variance, sample_variance_, atol=0., rtol=0.02) self.assertAllClose(true_variance, analytical_variance_, atol=0., rtol=1e-6) self.assertAllClose(true_stddev, sample_stddev_, atol=0., rtol=0.01) self.assertAllClose(true_stddev, analytical_stddev_, atol=0., rtol=1e-6) self.assertAllClose(true_scale, scale_, atol=0., rtol=1e-6) self.assertAllClose(sample_kl_chol_, analytical_kl_chol_, atol=0., rtol=0.02)
while not rospy.is_shutdown(): if get == 1: #each time we have a new value get = 0 # ---- Extended Kalman Filter ------------------------------------------------- # dt = vect_temps[2] F = np.array([[1,dt],[0,1]]) B = np.array([[dt**2/2],[dt]]) kf_x.kalman_set_F(F) kf_x.kalman_set_B(B) ax,ay,az = vect_imu[0,0],vect_imu[1,0],vect_imu[2,0] #[x,P] = kf_x.kalman_predict(acc_NED[0,0]) display_mag() R_mat = rotation_matrix(pitch,roll,yaw) v = np.matmul(np.linalg.inv(R_mat),np.array([[ax],[ay],[az]])) #plt.xlim((-1,1)) #plt.ylim((-1,1)) #plt.plot([0,cos(wind_direction)],[0, sin(wind_direction)]) #plt.plot([0,cos(vect_wind_direction[1])],[0, sin(vect_wind_direction[1])]) #plt.pause(0.01) #plt.cla()
def calc_descent(self): time.sleep(5) self.initialization() twist = Twist() twist.linear.x = self.vel[0] twist.linear.y = 0.0 twist.linear.z = 0.0 twist.angular.x = 0.0 twist.angular.y = 0.0 twist.angular.z = self.vel[1] print(twist) self.move_pub.publish(twist) # # Transmit the current velocity, then change it based on accel r = rospy.Rate(5) while not rospy.core.is_shutdown(): # Add next state self.get_light() temp = np.append(self.loc, self.light) # print(temp) if len(self.states) >= 20: self.states.popleft() self.states.append(temp) # Calculate descent direction sum = np.array([0.0, 0.0]) weight = 0.0 gamma = -6 factor = 0.1 curState = self.states[-1] # print("weight") for i in range(0, len(self.states) - 1): dif = self.states[i][0:2] - curState[0:2] dif_norm = np.linalg.norm(dif) weight = (1 / np.power(2, dif_norm)) - np.power( 10, (gamma * dif_norm)) light_dif = weight * (self.states[i][2] - self.light) / (dif_norm) vec = light_dif * dif sum += vec sum = sum / np.linalg.norm(sum) if (np.any(np.isnan(sum))): continue var_mag = 0.3 sum += [random.gauss(0, 1) * var_mag, random.gauss(0, 1) * var_mag] sum = np.array(factor * sum / np.linalg.norm(sum)) # print("sum") # print(sum) self.acc = np.matmul(np.array([[1.0, 0], [0, 0.3]]), np.transpose(np.array(self.transmit(sum)))) # print(self.acc) self.vel = self.vel + self.acc * 0.2 if (np.abs(self.vel[0]) > 0.08): print('check') self.vel[0] = np.sign(self.vel[0]) * 0.08 if (np.abs(self.vel[1]) > 1.00): self.vel[1] = np.sign(self.vel[1]) * 1.00 twist = Twist() twist.linear.x = self.vel[0] twist.linear.y = 0.0 twist.linear.z = 0.0 twist.angular.x = 0.0 twist.angular.y = 0.0 twist.angular.z = self.vel[1] print(twist) self.move_pub.publish(twist) r.sleep() twist = Twist() twist.linear.x = 0.0 twist.linear.y = 0.0 twist.linear.z = 0.0 twist.angular.x = 0.0 twist.angular.y = 0.0 twist.angular.z = 0.0 self.move_pub.publish(twist) return