Python numpy.dot() Examples
The following are 30
code examples of numpy.dot().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
numpy
, or try the search function
.

Example #1
Source File: NLP.py From Financial-NLP with Apache License 2.0 | 7 votes |
def similarity_label(self, words, normalization=True): """ you can calculate more than one word at the same time. """ if self.model==None: raise Exception('no model.') if isinstance(words, string_types): words=[words] vectors=np.transpose(self.model.wv.__getitem__(words)) if normalization: unit_vector=unitvec(vectors,ax=0) # 这样写比原来那样速度提升一倍 #unit_vector=np.zeros((len(vectors),len(words))) #for i in range(len(words)): # unit_vector[:,i]=matutils.unitvec(vectors[:,i]) dists=np.dot(self.Label_vec_u, unit_vector) else: dists=np.dot(self.Label_vec, vectors) return dists
Example #2
Source File: point_cloud.py From FRIDA with MIT License | 6 votes |
def classical_mds(self, D): ''' Classical multidimensional scaling Parameters ---------- D : square 2D ndarray Euclidean Distance Matrix (matrix containing squared distances between points ''' # Apply MDS algorithm for denoising n = D.shape[0] J = np.eye(n) - np.ones((n,n))/float(n) G = -0.5*np.dot(J, np.dot(D, J)) s, U = np.linalg.eig(G) # we need to sort the eigenvalues in decreasing order s = np.real(s) o = np.argsort(s) s = s[o[::-1]] U = U[:,o[::-1]] S = np.diag(s)[0:self.dim,:] self.X = np.dot(np.sqrt(S),U.T)
Example #3
Source File: point_cloud.py From FRIDA with MIT License | 6 votes |
def flatten(self, ind): ''' Transform the set of points so that the subset of markers given as argument is as close as flat (wrt z-axis) as possible. Parameters ---------- ind : list of bools Lists of marker indices that should be all in the same subspace ''' # Transform references to indices if needed ind = [self.key2ind(s) for s in ind] # center point cloud around the group of indices centroid = self.X[:,ind].mean(axis=1, keepdims=True) X_centered = self.X - centroid # The rotation is given by left matrix of SVD U,S,V = la.svd(X_centered[:,ind], full_matrices=False) self.X = np.dot(U.T, X_centered) + centroid
Example #4
Source File: generators.py From FRIDA with MIT License | 6 votes |
def gen_visibility(alphak, phi_k, pos_mic_x, pos_mic_y): """ generate visibility from the Dirac parameter and microphone array layout :param alphak: Diracs' amplitudes :param phi_k: azimuths :param pos_mic_x: a vector that contains microphones' x coordinates :param pos_mic_y: a vector that contains microphones' y coordinates :return: """ xk, yk = polar2cart(1, phi_k) num_mic = pos_mic_x.size visi = np.zeros((num_mic, num_mic), dtype=complex) for q in xrange(num_mic): p_x_outer = pos_mic_x[q] p_y_outer = pos_mic_y[q] for qp in xrange(num_mic): p_x_qqp = p_x_outer - pos_mic_x[qp] # a scalar p_y_qqp = p_y_outer - pos_mic_y[qp] # a scalar visi[qp, q] = np.dot(np.exp(-1j * (xk * p_x_qqp + yk * p_y_qqp)), alphak) return visi
Example #5
Source File: doa.py From FRIDA with MIT License | 6 votes |
def compute_mode(self): """ Pre-compute mode vectors from candidate locations (in spherical coordinates). """ if self.num_loc is None: raise ValueError('Lookup table appears to be empty. \ Run build_lookup().') self.mode_vec = np.zeros((self.max_bin,self.M,self.num_loc), dtype='complex64') if (self.nfft % 2 == 1): raise ValueError('Signal length must be even.') f = 1.0 / self.nfft * np.linspace(0, self.nfft / 2, self.max_bin) \ * 1j * 2 * np.pi for i in range(self.num_loc): p_s = self.loc[:, i] for m in range(self.M): p_m = self.L[:, m] if (self.mode == 'near'): dist = np.linalg.norm(p_m - p_s, axis=1) if (self.mode == 'far'): dist = np.dot(p_s, p_m) # tau = np.round(self.fs*dist/self.c) # discrete - jagged tau = self.fs * dist / self.c # "continuous" - smoother self.mode_vec[:, m, i] = np.exp(f * tau)
Example #6
Source File: tools_fri_doa_plane.py From FRIDA with MIT License | 6 votes |
def cov_mtx_est(y_mic): """ estimate covariance matrix :param y_mic: received signal (complex based band representation) at microphones :return: """ # Q: total number of microphones # num_snapshot: number of snapshots used to estimate the covariance matrix Q, num_snapshot = y_mic.shape cov_mtx = np.zeros((Q, Q), dtype=complex, order='F') for q in range(Q): y_mic_outer = y_mic[q, :] for qp in range(Q): y_mic_inner = y_mic[qp, :] cov_mtx[qp, q] = np.dot(y_mic_outer, y_mic_inner.T.conj()) return cov_mtx / num_snapshot
Example #7
Source File: tools_fri_doa_plane.py From FRIDA with MIT License | 6 votes |
def mtx_updated_G(phi_recon, M, mtx_amp2visi_ri, mtx_fri2visi_ri): """ Update the linear transformation matrix that links the FRI sequence to the visibilities by using the reconstructed Dirac locations. :param phi_recon: the reconstructed Dirac locations (azimuths) :param M: the Fourier series expansion is between -M to M :param p_mic_x: a vector that contains microphones' x-coordinates :param p_mic_y: a vector that contains microphones' y-coordinates :param mtx_freq2visi: the linear mapping from Fourier series to visibilities :return: """ L = 2 * M + 1 ms_half = np.reshape(np.arange(-M, 1, step=1), (-1, 1), order='F') phi_recon = np.reshape(phi_recon, (1, -1), order='F') mtx_amp2freq = np.exp(-1j * ms_half * phi_recon) # size: (M + 1) x K mtx_amp2freq_ri = np.vstack((mtx_amp2freq.real, mtx_amp2freq.imag[:-1, :])) # size: (2M + 1) x K mtx_fri2amp_ri = linalg.lstsq(mtx_amp2freq_ri, np.eye(L))[0] # projection mtx_freq2visi to the null space of mtx_fri2amp mtx_null_proj = np.eye(L) - np.dot(mtx_fri2amp_ri.T, linalg.lstsq(mtx_fri2amp_ri.T, np.eye(L))[0]) G_updated = np.dot(mtx_amp2visi_ri, mtx_fri2amp_ri) + \ np.dot(mtx_fri2visi_ri, mtx_null_proj) return G_updated
Example #8
Source File: display_graph.py From gated-graph-transformer-network with MIT License | 6 votes |
def prep_graph_display(states, options={}): clean_states = [x.tolist() for x in states] nstr, nid, nstate, estr = states flat_nid = nid.reshape([-1,nid.shape[-1]]) flat_estr = estr.reshape([-1,estr.shape[-1]]) flat_estr = flat_estr / (np.linalg.norm(flat_estr, axis=1, keepdims=True) + 1e-8) num_unique_colors = nid.shape[-1] + estr.shape[-1] id_denom = max(nid.shape[-1] - 1, 1) id_project_mat = np.array([list(cm_rainbow(i/id_denom)[:3]) for i in range(0,nid.shape[-1])]) estr_denom = estr.shape[-1] estr_project_mat = np.array([list(cm_rainbow((i+0.37)/estr_denom)[:3]) for i in range(estr.shape[-1])]) node_colors = np.dot(flat_nid, id_project_mat) edge_colors = np.dot(flat_estr, estr_project_mat) colormap = { "node_id": node_colors.reshape(nid.shape[:-1] + (3,)).tolist(), "edge_type": edge_colors.reshape(estr.shape[:-1] + (3,)).tolist(), } return json.dumps({ "states":clean_states, "colormap":colormap, "options":options })
Example #9
Source File: dynamic.py From StructEngPy with MIT License | 6 votes |
def Riz_mode(model:Model,n,F): """ Solve the Riz mode of the MDOF system\n n: number of modes to extract\n F: spacial load pattern """ # alpha=np.array(mode).T # #Grum-Schmidt procedure # beta=[] # for i in range(len(mode)): # beta_i=alpha[i] # for j in range(i): # beta_i-=np.dot(alpha[i],beta[j])/np.dot(alpha[j],alpha[j])*beta[j] # beta.append(beta_i) # mode_=np.array(beta).T pass
Example #10
Source File: dynamic.py From StructEngPy with MIT License | 6 votes |
def spectrum_analysis(model,n,spec): """ sepctrum analysis params: n: number of modes to use\n spec: a list of tuples (period,acceleration response) """ freq,mode=eigen_mode(model,n) M_=np.dot(mode.T,model.M) M_=np.dot(M_,mode) K_=np.dot(mode.T,model.K) K_=np.dot(K_,mode) C_=np.dot(mode.T,model.C) C_=np.dot(C_,mode) d_=[] for (m_,k_,c_) in zip(M_.diag(),K_.diag(),C_.diag()): sdof=SDOFSystem(m_,k_) T=sdof.omega_d() d_.append(np.interp(T,spec[0],spec[1]*m_)) d=np.dot(d_,mode) #CQC return d
Example #11
Source File: __init__.py From StructEngPy with MIT License | 6 votes |
def resolve_modal_displacement(self,node_id,k): """ resolve modal node displacement. params: node_id: int. k: order of vibration mode. return: 6-array of local nodal displacement. """ if not self.is_solved: raise Exception('The model has to be solved first.') if node_id in self.__nodes.keys(): node=self.__nodes[node_id] T=node.transform_matrix return T.dot(self.mode_[node_id*6:node_id*6+6,k-1]).reshape(6) else: raise Exception("The node doesn't exists.")
Example #12
Source File: element.py From StructEngPy with MIT License | 6 votes |
def _BtDB(self,s,r): """ dot product of B^T, D, B params: s,r:natural position of evalue point.2-array. returns: 3x3 matrix. """ print(self._B(s,r).transpose(2,0,1).shape) print( np.matmul( np.dot(self._B(s,r).T,self._D), self._B(s,r).transpose(2,0,1)).shape ) print(self._D.shape) return np.matmul(np.dot(self._B(s,r).T,self._D),self._B(s,r).transpose(2,0,1)).transpose(1,2,0)
Example #13
Source File: csys.py From StructEngPy with MIT License | 6 votes |
def __init__(self,origin, pt1, pt2, name=None): """ origin: 3x1 vector pt1: 3x1 vector pt2: 3x1 vector """ self.__origin=origin vec1 = np.array([pt1[0] - origin[0] , pt1[1] - origin[1] , pt1[2] - origin[2]]) vec2 = np.array([pt2[0] - origin[0] , pt2[1] - origin[1] , pt2[2] - origin[2]]) cos = np.dot(vec1, vec2)/np.linalg.norm(vec1)/np.linalg.norm(vec2) if cos == 1 or cos == -1: raise Exception("Three points should not in a line!!") self.__x = vec1/np.linalg.norm(vec1) z = np.cross(vec1, vec2) self.__z = z/np.linalg.norm(z) self.__y = np.cross(self.z, self.x) self.__name=uuid.uuid1() if name==None else name
Example #14
Source File: csys.py From StructEngPy with MIT License | 6 votes |
def set_by_3pts(self,origin, pt1, pt2): """ origin: tuple 3 pt1: tuple 3 pt2: tuple 3 """ self.origin=origin vec1 = np.array([pt1[0] - origin[0] , pt1[1] - origin[1] , pt1[2] - origin[2]]) vec2 = np.array([pt2[0] - origin[0] , pt2[1] - origin[1] , pt2[2] - origin[2]]) cos = np.dot(vec1, vec2)/np.linalg.norm(vec1)/np.linalg.norm(vec2) if cos == 1 or cos == -1: raise Exception("Three points should not in a line!!") self.x = vec1/np.linalg.norm(vec1) z = np.cross(vec1, vec2) self.z = z/np.linalg.norm(z) self.y = np.cross(self.z, self.x)
Example #15
Source File: kalman_filter.py From kalman_filter_multi_object_tracking with MIT License | 6 votes |
def predict(self): """Predict state vector u and variance of uncertainty P (covariance). where, u: previous state vector P: previous covariance matrix F: state transition matrix Q: process noise matrix Equations: u'_{k|k-1} = Fu'_{k-1|k-1} P_{k|k-1} = FP_{k-1|k-1} F.T + Q where, F.T is F transpose Args: None Return: vector of predicted state estimate """ # Predicted state estimate self.u = np.round(np.dot(self.F, self.u)) # Predicted estimate covariance self.P = np.dot(self.F, np.dot(self.P, self.F.T)) + self.Q self.lastResult = self.u # same last predicted result return self.u
Example #16
Source File: nn.py From deep-learning-note with MIT License | 6 votes |
def train(self, inputs_list, targets_list): inputs = np.array(inputs_list, ndmin=2).T targets = np.array(targets_list, ndmin=2).T hidden_inputs = np.dot(self.wih, inputs) hidden_outputs = self.activation_function(hidden_inputs) final_inputs = np.dot(self.who, hidden_outputs) final_outputs = self.activation_function(final_inputs) output_errors = targets - final_outputs hidden_errors = np.dot(self.who.T, output_errors) self.who += self.lr * np.dot((output_errors * final_outputs * (1.0 - final_outputs)), np.transpose(hidden_outputs)) self.wih += self.lr * np.dot((hidden_errors * hidden_outputs * (1.0 - hidden_outputs)), np.transpose(inputs)) pass # query
Example #17
Source File: kde.py From svviz with MIT License | 5 votes |
def evaluate(self, points): points = atleast_2d(points) d, m = points.shape if d != self.d: if d == 1 and m == self.d: # points was passed in as a row vector points = reshape(points, (self.d, 1)) m = 1 else: msg = "points have dimension %s, dataset has dimension %s" % (d, self.d) raise ValueError(msg) result = zeros((m,), dtype=np.float) if m >= self.n: # there are more points than data, so loop over data for i in range(self.n): diff = self.dataset[:, i, newaxis] - points tdiff = dot(self.inv_cov, diff) energy = sum(diff*tdiff,axis=0) / 2.0 result = result + exp(-energy) else: # loop over points for i in range(m): diff = self.dataset - points[:, i, newaxis] tdiff = dot(self.inv_cov, diff) energy = sum(diff * tdiff, axis=0) / 2.0 result[i] = sum(exp(-energy), axis=0) result = result / self._norm_factor return result
Example #18
Source File: util.py From libTLDA with MIT License | 5 votes |
def nullspace(A, atol=1e-13, rtol=0): """ Compute an approximate basis for the nullspace of A. INPUT (1) array 'A': 1-D array with length k will be treated as a 2-D with shape (1, k). (2) float 'atol': the absolute tolerance for a zero singular value. Singular values smaller than `atol` are considered to be zero. (3) float 'rtol': relative tolerance. Singular values less than rtol*smax are considered to be zero, where smax is the largest singular value. If both `atol` and `rtol` are positive, the combined tolerance is the maximum of the two; tol = max(atol, rtol * smax) Singular values smaller than `tol` are considered to be zero. OUTPUT (1) array 'B': if A is an array with shape (m, k), then B will be an array with shape (k, n), where n is the estimated dimension of the nullspace of A. The columns of B are a basis for the nullspace; each element in np.dot(A, B) will be approximately zero. """ # Expand A to a matrix A = np.atleast_2d(A) # Singular value decomposition u, s, vh = al.svd(A) # Set tolerance tol = max(atol, rtol * s[0]) # Compute the number of non-zero entries nnz = (s >= tol).sum() # Conjugate and transpose to ensure real numbers ns = vh[nnz:].conj().T return ns
Example #19
Source File: suba.py From libTLDA with MIT License | 5 votes |
def zca_whiten(self, X): """ Perform ZCA whitening (aka Mahalanobis whitening). Parameters ---------- X : array (M samples x D features) data matrix. Returns ------- X : array (M samples x D features) whitened data. """ # Covariance matrix Sigma = np.cov(X.T) # Singular value decomposition U, S, V = svd(Sigma) # Whitening constant to prevent division by zero epsilon = 1e-5 # ZCA whitening matrix W = np.dot(U, np.dot(np.diag(1.0 / np.sqrt(S + epsilon)), V)) # Apply whitening matrix return np.dot(X, W)
Example #20
Source File: suba.py From libTLDA with MIT License | 5 votes |
def align_data(self, X, Z, CX, CZ, V): """ Align data to components and transform source. Parameters ---------- X : array source data set (N samples x D features) Z : array target data set (M samples x D features) CX : array source principal components (D features x d subspaces) CZ : array target principal component (D features x d subspaces) V : array transformation matrix (d subspaces x d subspaces) Returns ------- X : array transformed source data (N samples x d subspaces) Z : array projected target data (M samples x d subspaces) """ # Map source data onto source principal components XC = np.dot(X, CX) # Align projected source data to target components XV = np.dot(XC, V) # Map target data onto target principal components ZC = np.dot(Z, CZ) return XV, ZC
Example #21
Source File: suba.py From libTLDA with MIT License | 5 votes |
def reg_cov(self, X): """ Regularize covariance matrix until non-singular. Parameters ---------- C : array square symmetric covariance matrix. Returns ------- C : array regularized covariance matrix. """ # Number of data points N = X.shape[0] # Compute mean of data muX = np.mean(X, axis=0, keepdims=1) # Compute covariance matrix without regularization SX = np.dot((X - muX).T, (X - muX)) / N # Initialize regularization parameter reg = 1e-6 # Keep going until non-singular while not self.is_pos_def(SX): # Compute covariance matrix with regularization SX = np.dot((X - muX).T, (X - muX)) / N + reg*np.eye(X.shape[1]) # Increment reg reg *= 10 # Report regularization print('Final regularization parameter = {}'.format(reg)) return SX
Example #22
Source File: flda.py From libTLDA with MIT License | 5 votes |
def predict(self, Z_): """ Make predictions on new dataset. Parameters ---------- Z : array new data set (M samples by D features) Returns ------- preds : array label predictions (M samples by 1) """ # Data shape M, D = Z_.shape # If classifier is trained, check for same dimensionality if self.is_trained: if not self.train_data_dim == D: raise ValueError('''Test data is of different dimensionality than training data.''') # Predict target labels preds = np.argmax(np.dot(Z_, self.theta), axis=1) # Map predictions back to labels preds = self.classes[preds] # Return predictions array return preds
Example #23
Source File: rba.py From libTLDA with MIT License | 5 votes |
def psi(self, X, theta, w, K=2): """ Compute psi function. Parameters ---------- X : array data set (N samples by D features) theta : array classifier parameters (D features by 1) w : array importance-weights (N samples by 1) K : int number of classes (def: 2) Returns ------- psi : array array with psi function values (N samples by K classes) """ # Number of samples N = X.shape[0] # Preallocate psi array psi = np.zeros((N, K)) # Loop over classes for k in range(K): # Compute feature statistics Xk = self.feature_stats(X, k*np.ones((N, 1))) # Compute psi function psi[:, k] = (w*np.dot(Xk, theta))[:, 0] return psi
Example #24
Source File: scl.py From libTLDA with MIT License | 5 votes |
def Huber_loss(self, theta, X, y, l2=0.0): """ Huber loss function. Reference: Ando & Zhang (2005a). A framework for learning predictive structures from multiple tasks and unlabeled data. JMLR. Parameters ---------- theta : array classifier parameters (D features by 1) X : array data (N samples by D features) y : array label vector (N samples by 1) l2 : float l2-regularization parameter (def= 0.0) Returns ------- array Objective function value. """ # Precompute terms Xy = (X.T*y.T).T Xyt = np.dot(Xy, theta) # Indices of discontinuity ix = (Xyt >= -1) # Loss function return np.sum(np.clip(1 - Xyt[ix], 0, None)**2, axis=0) \ + np.sum(-4*Xyt[~ix], axis=0) + l2*np.sum(theta**2, axis=0)
Example #25
Source File: scl.py From libTLDA with MIT License | 5 votes |
def predict(self, Z): """ Make predictions on new dataset. Parameters ---------- Z : array new data set (M samples by D features) Returns ------- preds : array label predictions (M samples by 1) """ # Data shape M, D = Z.shape # If classifier is trained, check for same dimensionality if self.is_trained: if not self.train_data_dim == D: raise ValueError('''Test data is of different dimensionality than training data.''') # Check for augmentation if not self.train_data_dim == D: Z = np.concatenate((np.dot(Z, self.C), Z), axis=1) # Call scikit's predict function preds = self.clf.predict(Z) # For quadratic loss function, correct predictions if self.loss == 'quadratic': preds = (np.sign(preds)+1)/2. # Return predictions array return preds
Example #26
Source File: tca.py From libTLDA with MIT License | 5 votes |
def predict(self, Z): """ Make predictions on new dataset. Parameters ---------- Z : array new data set (M samples by D features) Returns ------- preds : array label predictions (M samples by 1) """ # Data shape M, D = Z.shape # If classifier is trained, check for same dimensionality if self.is_trained: if not self.train_data_dim == D: raise ValueError('''Test data is of different dimensionality than training data.''') # Compute kernel for new data K = self.kernel(Z, self.XZ, type=self.kernel_type, bandwidth=self.bandwidth, order=self.order) # Map new data onto transfer components Z = np.dot(K, self.C) # Call scikit's predict function preds = self.clf.predict(Z) # For quadratic loss function, correct predictions if self.loss == 'quadratic': preds = (np.sign(preds)+1)/2. # Return predictions array return preds
Example #27
Source File: test_suba.py From libTLDA with MIT License | 5 votes |
def test_subspace_alignment(): """Test the alignment between datasets.""" X = rnd.randn(100, 10) Z = np.dot(rnd.randn(100, 10), np.diag(np.arange(1, 11))) clf = SubspaceAlignedClassifier() V, CX, CZ = clf.subspace_alignment(X, Z, subspace_dim=3) assert not np.any(np.isnan(V)) assert CX.shape[1] == 3 assert CZ.shape[1] == 3
Example #28
Source File: viz.py From libTLDA with MIT License | 5 votes |
def plotc(parameters, ax=[], color='k', gridsize=(101, 101)): """ Plot a linear classifier in a 2D scatterplot. INPUT (1) tuple 'parameters': consists of a list of class proportions (1 by K classes), an array of class means (K classes by D features), an array of class-covariance matrices (D features by D features by K classes) (2) object 'ax': axes of a pyplot figure or subject (def: empty) (3) str 'colors': colors of the contours in the plot (def: 'k') (4) tuple 'gridsize': number of points in the grid (def: (101, 101)) OUTPUT None """ # Check for figure object if fig: ax = fig.gca() else: fig, ax = plt.subplots() # Get axes limits xl = ax.get_xlim() yl = ax.get_ylim() # Define grid gx = np.linspace(xl[0], xl[1], gridsize[0]) gy = np.linspace(yl[0], yl[1], gridsize[1]) x, y = np.meshgrid(gx, gy) xy = np.vstack((x.ravel(), y.ravel())).T # Values of grid z = np.dot(xy, parameters[:-1, :]) + parameters[-1, :] z = np.reshape(z[:, 0] - z[:, 1], gridsize) # Plot grid ax.contour(x, y, z, levels=0, colors=colors)
Example #29
Source File: test_xrft.py From xrft with MIT License | 5 votes |
def numpy_detrend(da): """ Detrend a 2D field by subtracting out the least-square plane fit. Parameters ---------- da : `numpy.array` The data to be detrended Returns ------- da : `numpy.array` The detrended input data """ N = da.shape G = np.ones((N[0]*N[1],3)) for i in range(N[0]): G[N[1]*i:N[1]*i+N[1], 1] = i+1 G[N[1]*i:N[1]*i+N[1], 2] = np.arange(1, N[1]+1) d_obs = np.reshape(da.copy(), (N[0]*N[1],1)) m_est = np.dot(np.dot(spl.inv(np.dot(G.T, G)), G.T), d_obs) d_est = np.dot(G, m_est) lin_trend = np.reshape(d_est, N) return da - lin_trend
Example #30
Source File: point_cloud.py From FRIDA with MIT License | 5 votes |
def EDM(self): ''' Computes the EDM corresponding to the marker set ''' if self.X is None: raise ValueError('No marker set') G = np.dot(self.X.T, self.X) return np.outer(np.ones(self.m), np.diag(G)) \ - 2*G + np.outer(np.diag(G), np.ones(self.m))