def plot_histogram(X, Y, w, b): ''' Plots a histogram of classifier outputs (w^T X) for each class with pl.hist The title of the histogram is the accuracy of the classification Accuracy = #correctly classified points / N Definition: plot_histogram(X, Y, w, b) Input: X - DxN array of N data points with D features Y - 1D array of length N of class labels w - 1D array of length D, weight vector b - bias term for linear classification ''' # ... your code here #Data: output = (w.T.dot(X) - b) wrong = (sp.sign(output) != Y).nonzero()[0] correct = (sp.sign(output) == Y).nonzero()[0] #Info: acc = float(correct.shape[0])/float(output.shape[0]) * 100. non_target = [output[i] for i in correct] target = [output[i] for i in wrong] #Plot: pl.hist(non_target, bins = 10, histtype='bar',color='b', rwidth=0.4, label=['non-target']) pl.hist(target, bins = 10, histtype='bar', color='g', rwidth=0.4, label=['target']) pl.xlabel('w^T X') pl.title('Acc %d'%acc +'%') pl.legend()
def rpropUpdate(self, w): """ edit the update vector according to the rprop mechanism. """ n = self.xdim self.wStored.append(w.copy()) self.rpropPerformance.append(self.fx[0]) self.oldParams.append(self.combineParams(self.alpha, self.x, self.factorSigma)) if self.generation > 0: neww = zeros(len(w)) self.delta.append(zeros((self.mu*(n*(n+1)/2+n+1)))) for i in range(len(w)-1): self.delta[self.generation][i] = self.delta[self.generation - 1][i] assert len(self.wStored[self.generation]) == len(self.wStored[self.generation-1]) if self.wStored[self.generation][i] * self.wStored[self.generation-1][i] > 0.0: self.delta[self.generation][i] = min(self.delta[self.generation-1][i] * self.etaPlus, self.rpropMaxUpdate) if self.rpropUseGradient: neww[i] = self.wStored[self.generation][i] * self.delta[self.generation][i] else: neww[i] = sign(self.wStored[self.generation][i]) * self.delta[self.generation][i] elif self.wStored[self.generation][i] * self.wStored[self.generation-1][i] < 0.0: self.delta[self.generation][i] = max(self.delta[self.generation - 1][i] * self.etaMin, self.rpropMinUpdate) if self.rpropPerformance[self.generation] < self.rpropPerformance[self.generation - 1]: # undo the last update neww[i] = self.oldParams[self.generation-1][i] - self.oldParams[self.generation][i] self.wStored[self.generation][i] = 0.0 elif self.wStored[self.generation][i] * self.wStored[self.generation - 1][i] == 0.0: if self.rpropUseGradient: neww[i] = self.wStored[self.generation][i] * self.delta[self.generation][i] else: neww[i] = sign(self.wStored[self.generation][i]) * self.delta[self.generation][i] self.updateVariables(neww)
def train_perceptron(X,Y,iterations=200,eta=.1): ''' Trains a linear perceptron Definition: w, b, acc = train_perceptron(X,Y,iterations=200,eta=.1) Input: X - DxN array of N data points with D features Y - 1D array of length N of class labels {-1, 1} iter - optional, number of iterations, default 200 eta - optional, learning rate, default 0.1 Output: w - 1D array of length D, weight vector b - bias term for linear classification ''' #include the bias term by adding a row of ones to X X = sp.concatenate((sp.ones((1,X.shape[1])), X)) #initialize weight vector weights = sp.ones((X.shape[0]))/X.shape[0] for it in sp.arange(iterations): # indices of misclassified data wrong = (sp.sign(weights.dot(X)) != Y).nonzero()[0] if wrong.shape[0] > 0: # pick a random misclassified data point m = wrong[sp.random.random_integers(0, wrong.shape[0]-1)] #update weight vector (use variable learning rate (eta/(1.+it)) ) weights = weights + (eta/(1.+it)) * X[:, m] * Y[m]; # compute accuracy wrong = (sp.sign(weights.dot(X)) != Y).nonzero()[0] b = -weights[0] w = weights[1:] return w,b
def predict(self, Xtest): print "starting predict with:",Xtest.shape[0]," samples : ",datetime.datetime.now() num_batches = Xtest.shape[0] / float(self.n_pred_samples) test_ids = [] for i in range(0, int(num_batches)): test_ids.append(range((i) * self.n_pred_samples, (i + 1) * self.n_pred_samples)) if (num_batches - int(num_batches)) > 0: test_ids.append(range(int(num_batches) * self.n_pred_samples, Xtest.shape[0])) # values = [(test_id, exp_ids) for test_id in test_ids for exp_ids in self.X_exp_ids] yhattotal = [] for i in range(0,len(test_ids)): # print "computing result with batches:",i," of:",len(test_ids) yraw = Parallel(n_jobs=self.workers)(delayed(svm_predict_raw_batches)(self.X, Xtest[test_ids[i]], \ self.w, v, self.gamma) for v in self.X_exp_ids) yhat = sp.sign(sp.vstack(yraw).mean(axis=0)) yhattotal.append(yhat) yhattotal = [item for sublist in yhattotal for item in sublist] print "stopping predict:", datetime.datetime.now() return sp.sign(yhattotal)
def crossvalidate(X,Y, f=5, trainfun=train_ncc): ''' Test generalization performance of a linear classifier by crossvalidation Definition: crossvalidate(X,Y, f=5, trainfun=train_ncc) Input: X - DxN array of N data points with D features Y - 1D array of length N of class labels f - number of cross-validation folds trainfun - function for linear classification training Output: acc_train - (f,) array of accuracies in test train folds acc_test - (f,) array of accuracies in each test fold ''' N = f*(X.shape[-1]/f) idx = sp.reshape(sp.arange(N),(f,N/f)) acc_train = sp.zeros((f)) acc_test = sp.zeros((f)) for ifold in sp.arange(f): testidx = sp.zeros((f),dtype=bool) testidx[ifold] = 1 test = idx[testidx,:].flatten() train = idx[~testidx,:].flatten() w,b = trainfun(X[:,train],Y[train]) acc_train[ifold] = sp.sum(sp.sign(w.dot(X[:,train])-b)==Y[train])/sp.double(train.shape[0]) acc_test[ifold] = sp.sum(sp.sign(w.dot(X[:,test])-b)==Y[test])/sp.double(test.shape[0]) # pdb.set_trace() return acc_train,acc_test
def f(self,xarr,t): x0dot = -self.coef*pl.exp(-self.k*(1.0+abs(xarr[3]-1.0)))*pl.sin(self.w*t-self.k*xarr[2]) x1dot = pl.sign(xarr[3]-1.0)*self.coef*pl.exp(-self.k*(1.0+abs(xarr[3]-1.0)))*pl.cos(self.w*t-self.k*xarr[2]) -\ pl.sign(xarr[3]-1.0)*9.8 x2dot = xarr[0] x3dot = xarr[1] return [x0dot,x1dot,x2dot,x3dot]
def zero_crossing_rate(self, frames): nf = len(frames) # 帧数 zcr = np.zeros(nf) # 初始化 for k in range(nf): x_sub = frames[k] x_sub1 = x_sub[:-1] x_sub2 = x_sub[1:] zcr[k] = np.sum(np.abs(scipy.sign(x_sub1) - scipy.sign(x_sub2))) / 2 / len(x_sub1) return zcr
def dsekl_test_predict(dname='sonar', num_test=1000, maxN=1000): print "started loading:", datetime.datetime.now() Xtotal, Ytotal = load_realdata(dname) print "loading data done!", datetime.datetime.now() # decrease dataset size N = Xtotal.shape[0] if maxN > 0: N = sp.minimum(Xtotal.shape[0], maxN) Xtotal = Xtotal[:N + num_test] Ytotal = Ytotal[:N + num_test] # randomize datapoints print "randomization", datetime.datetime.now() sp.random.seed(0) idx = sp.random.permutation(Xtotal.shape[0]) print idx Xtotal = Xtotal[idx] Ytotal = Ytotal[idx] # divide test and train print "dividing in train and test", datetime.datetime.now() Xtest = Xtotal[N:N+num_test] Ytest = Ytotal[N:N+num_test] Xtrain = Xtotal[:N] Ytrain = Ytotal[:N] print "densifying", datetime.datetime.now() # unit variance and zero mean Xtrain = Xtrain.todense() Xtest = Xtest.todense() if not sp.sparse.issparse(Xtrain): scaler = StandardScaler() print "fitting scaler", datetime.datetime.now() scaler.fit(Xtrain) # Don't cheat - fit only on training data print "transforming data train", datetime.datetime.now() Xtrain = scaler.transform(Xtrain) print "transforming data test", datetime.datetime.now() Xtest = scaler.transform(Xtest) else: scaler = StandardScaler(with_mean=False) scaler.fit(Xtrain) Xtrain = scaler.transform(Xtrain) Xtest = scaler.transform(Xtest) DS = pickle.load(file("DS","rb")) res_hl = DS.predict_support_hardlimits(Xtest) res_hl = sp.mean(sp.sign(res_hl) != Ytest) print "res_hl",res_hl res_perc = DS.predict_support_percentiles(Xtest) res_perc = sp.mean(sp.sign(res_perc) != Ytest) print "res_perc",res_perc
def performAstroActions(self): for j, active in enumerate(self.astro_statuses): assert active in [-1, 0, 1] if active == 1: assert sign(self.remaining_active_durs[j]) == 1 self.neur_in_ws[:,j] += self.neur_in_ws[:,j] * self.incr_percent self.remaining_active_durs[j] -= 1 elif active == -1: assert sign(self.remaining_active_durs[j]) == -1 self.neur_in_ws[:,j] += self.neur_in_ws[:,j] * -self.decr_percent self.remaining_active_durs[j] += 1
def performAstroActions(self): for j, active in enumerate(self.astro_statuses): assert active in [-1, 0, 1] if active == 1: # need to check output weights are modified in the correct way assert sign(self.remaining_active_durs[j]) == 1 self.in_ws[:,j] += self.in_ws[:,j] * self.incr_percent self.remaining_active_durs[j] -= 1 elif active == -1: assert sign(self.remaining_active_durs[j]) == -1 self.in_ws[:,j] += self.in_ws[:,j] * -self.decr_percent self.remaining_active_durs[j] += 1
def svdInverse(mat,maxEig=1e10,minEig=1e-10): #1e10,1e-10 u,w,vt = scipy.linalg.svd(mat) if any(w==0.): raise ZeroDivisionError, "Singular matrix." wInv = w ** -1 largeIndices = pylab.find( abs(wInv) > maxEig ) if len(largeIndices) > 0: print "svdInverse:",len(largeIndices),"large singular values out of",len(w) wInv[largeIndices] = maxEig*scipy.sign(wInv[largeIndices]) smallIndices = pylab.find( abs(wInv) < minEig ) if len(smallIndices) > 0: print "svdInverse:",len(smallIndices),"small singular values out of",len(w) wInv[smallIndices] = minEig*scipy.sign(wInv[smallIndices]) return scipy.dot( scipy.dot(vt.T,scipy.diag(wInv)), u.T )
def expectation_prop_inner(m0,V0,Y,Z,F,z,needed): #expectation propagation on multivariate gaussian for soft inequality constraint #m0,v0 are mean vector , covariance before EP #Y is inequality value, Z is sign, 1 for geq, -1 for leq, F is softness variance #z is number of ep rounds to run #returns mt, Vt the value and variance for observations created by ep m0=sp.array(m0).flatten() V0=sp.array(V0) n = V0.shape[0] print "expectation prpagation running on "+str(n)+" dimensions for "+str(z)+" loops:" mt =sp.zeros(n) Vt= sp.eye(n)*float(1e10) m = sp.empty(n) V = sp.empty([n,n]) conv = sp.empty(z) for i in xrange(z): #compute the m V give ep obs m,V = gaussian_fusion(m0,mt,V0,Vt) mtprev=mt.copy() Vtprev=Vt.copy() for j in [k for k in xrange(n) if needed[k]]: print [i,j] #the cavity dist at index j tmp = 1./(Vt[j,j]-V[j,j]) v_ = (V[j,j]*Vt[j,j])*tmp m_ = tmp*(m[j]*Vt[j, j]-mt[j]*V[j, j]) alpha = sp.sign(Z[j])*(m_-Y[j]) / (sp.sqrt(v_+F[j])) pr = PhiR(alpha) if sp.isnan(pr): pr = -alpha beta = pr*(pr+alpha)/(v_+F[j]) kappa = sp.sign(Z[j])*(pr+alpha) / (sp.sqrt(v_+F[j])) #print [alpha,beta,kappa,pr] mt[j] = m_+1./kappa #mt[j] = min(abs(mt[j]),1e5)*sp.sign(mt[j]) Vt[j,j] = min(1e10,1./beta - v_) #print sp.amax(mtprev-mt) #print sp.amax(sp.diagonal(Vtprev)-sp.diagonal(Vt)) #TODO make this a ratio instead of absolute delta = max(sp.amax(mtprev-mt),sp.amax(sp.diagonal(Vtprev)-sp.diagonal(Vt))) conv[i]=delta print "EP finished with final max deltas "+str(conv[-3:]) V = V0.dot(spl.solve(V0+Vt,Vt)) m = V.dot((spl.solve(V0,m0)+spl.solve(Vt,mt)).T) return mt, Vt
def featurex(self): """ feature X:(c1, r1,c2,r2,c3,r3,...,#crrtness) """ self.user=set() for sample in self.train_data: self.user.add(sample['user']) self.user=list(self.user) self.user_inv={} for n in xrange(0,len(self.user)): self.user_inv[self.user[n]]=n self.X=sp.zeros((len(self.user),len(self.questions.category)*2+1),dtype=float) for sample in self.train_data: ratio=(float(sample['position']))/len(self.questions.questions[sample['question']][3]) user_idx=self.user_inv[sample['user']] ques_idx=self.questions.category_inv[self.questions.questions[sample['question']][2]] self.X[user_idx,ques_idx*2]+=1.0 self.X[user_idx,ques_idx*2+1]+=abs(ratio) self.X[user_idx,-1]+=sp.sign(ratio) #normalization for n in xrange(0,len(self.X)): for m in xrange(0,len(self.questions.category)): if self.X[n,m*2]>0.5: self.X[n,m*2+1]/=(self.X[n,m*2]) self.X[n,-1]/=sum(self.X[n,0:-1:2]) self.X[n,0:-1:2]/=sum(self.X[n,0:-1:2])
def plot_histogram(X, Y, w, b): ''' Plots a histogram of classifier outputs (w^T X) for each class with pl.hist The title of the histogram is the accuracy of the classification Accuracy = #correctly classified points / N Definition: plot_histogram(X, Y, w, b) Input: X - DxN array of N data points with D features Y - 1D array of length N of class labels w - 1D array of length D, weight vector b - bias term for linear classification ''' #calculate the correct classified correct = (sp.sign(w.dot(X) - b) == Y).nonzero()[0] #class labels 1 target = w.dot(X[:, (Y == 1)]) #class balels -1 non_target = w.dot(X[:, (Y == -1)]) pl.title("Acc %0.0f%%" % (float(correct.shape[0]) / X.shape[1] * 100,)) pl.xlabel('w^T X') pl.hist(non_target) pl.hist(target) pl.legend(["non target", "target"], loc=0) pl.show()
def calc_modal_vector(atoms1,atoms2): """ Calculate the 'modal vector', i.e. the difference vector between the two configurations. The minimum image convention is applied! """ from scipy.linalg import inv from scipy import array,dot from scipy import sign,floor cell1 = atoms1.get_cell() cell2 = atoms2.get_cell() # The cells need to be the same (otherwise the whole process won't make sense) if (cell1 != cell2).any(): raise ValueError("Encountered different cells in atoms1 and atoms2. Those need to be the same.") cell = cell1 icell = inv(cell) frac1 = atoms1.get_scaled_positions() frac2 = atoms2.get_scaled_positions() modal_vector_frac = frac1 - frac2 for i in range(modal_vector_frac.shape[0]): for j in range(modal_vector_frac.shape[1]): if abs(modal_vector_frac[i,j]) > .5: value = modal_vector_frac[i,j] vsign = sign(modal_vector_frac[i,j]) absvalue = abs(value) modal_vector_frac[i,j] = value - vsign*floor(absvalue+.5) return dot(modal_vector_frac,cell)
def north_direction(lat): '''get the north direction relative to image positive y coordinate''' dlatdx = nd.filters.sobel(lat,axis=1,mode='constant',cval=sp.nan) #gradient in x-direction dlatdy = nd.filters.sobel(lat,axis=0,mode='constant',cval=sp.nan) ydir = lat[-1,0] -lat[0,0] # check if latitude is ascending or descending in y axis # same step might have to be done with x direction. return sp.arctan2(dlatdx,dlatdy*sp.sign(ydir) )*180/sp.pi
def PlotEigenvectors(eigVects, net = None, title = None): nEv = 3 nOv = len(eigVects[:,0]) for jj in range(nEv): subplot(nEv, 1, jj+1) if jj == 0 and title is not None: title(title) bar(range(nOv), eigVects[:,jj]/scipy.linalg.norm(eigVects[:,jj])) axis([-1, nOv] + axis()[2:]) if net is not None: mags = zip(abs(eigVects[:,jj]), range(nOv), eigVects[:,jj]) mags.sort() mags.reverse() for mag, index, val in mags[:5]: name = net.optimizableVars[index].name if name is None: name = net.optimizableVars[index].id text(index, val + scipy.sign(val)*0.05, name, horizontalalignment='center', verticalalignment='center') a = list(axis()) a[0:2] = [-.03*nOv, nOv*1.03] a[2] -= 0.1 a[3] += 0.1 axis(a)
def to_bool_array(self): """ Returns a dense matrix (`scipy.sparse.csr_matrix`), which rows represent the number of spike trains and the columns represent the binned index position of a spike in a spike train. The matrix columns contain **True**, which indicate a spike and **False** for non spike. Returns ------- bool matrix : numpy.ndarray Returns a dense matrix representation of the sparse matrix, with **True** indicating a spike and **False*** for non spike. The **Trues** in the columns represent the index position of the spike in the spike train and rows represent the number of spike trains. Examples -------- >>> import elephant.conversion as conv >>> import neo as n >>> import quantities as pq >>> a = n.SpikeTrain([0.5, 0.7, 1.2, 3.1, 4.3, 5.5, 6.7] * pq.s, t_stop=10.0 * pq.s) >>> x = conv.BinnedSpikeTrain(a, num_bins=10, binsize=1 * pq.s, t_start=0 * pq.s) >>> print(x.to_bool_array()) [[ True True False True True True True False False False]] See also -------- scipy.sparse.csr_matrix scipy.sparse.csr_matrix.toarray """ return abs(scipy.sign(self.to_array())).astype(bool)
def classify(self, xL, xR): a1L, a1R, a2L, a2LR, a2R, a3, z1Lb, z1LRb, z1Rb, z2b, xLb, xRb = self.forward_pass(xL, xR) if self.k == 2 : classif = sp.sign(a3); else : classif = sp.argmax(a3,axis=0); return a3, classif
def performAstrocyteActions(self): i = len(self.neuronal_input_connection.params)/self.dim for j, active in enumerate(self.astrocyte_statuses): J = j*i assert active in [-1, 0, 1] if active == 1: # NEED TO CHECK _setParameters and _params method assert sign(self.remaining_active_durations[j]) == 1 self.neuronal_input_connection.params[J:J+i] += \ self.neuronal_input_connection.params[J:J+i]*self.increment_percent self.remaining_active_durations[j] -= 1 elif active == -1: assert sign(self.remaining_active_durations[j]) == -1 self.neuronal_input_connection.params[J:J+i] += \ self.neuronal_input_connection.params[J:J+i]*-self.decrement_percent self.remaining_active_durations[j] += 1
def predict(self, Xtest,number_of_redraws=1000): yraw = Parallel(n_jobs=8)(delayed(svm_predict_raw)(self.X, Xtest, \ self.w, self.n_expand_samples, self.gamma, i) for i in range(number_of_redraws)) yhat = sp.sign(sp.vstack(yraw).mean(axis=0)) return yhat
def __call__(self, gradient, error): products = self.previous_gradient * gradient signs = sign(gradient) # For positive gradient parts. positive = (products > 0).astype('int8') pos_step = self.step * self.upfactor * positive clip(pos_step, -self.bound, self.bound) pos_update = self.values - signs * pos_step # For negative gradient parts. negative = (products < 0).astype('int8') neg_step = self.step * self.downfactor * negative clip(neg_step, -self.bound, self.bound) if error <= self.previous_error: # If the error has decreased, do nothing. neg_update = zeros(gradient.shape) else: # If it has increased, move back 2 steps. neg_update = self.more_prev_values # Set all negative gradients to zero for the next step. gradient *= positive # Bookkeeping. self.previous_gradient = gradient self.more_prev_values = self.prev_values self.prev_values = self.values.copy() self.previous_error = error # Updates. self.step[:] = pos_step + neg_step self.values[:] = positive * pos_update + negative * neg_update return self.values
def bin_correlation_nu(self, lag_inds, freq_diffs, norms=False, cross_power=False): """"bin the correlation function in frequency only""" nf = len(self.freq_inds) n_diffs = len(freq_diffs) # Allowcate memory. corrf = sp.zeros((n_diffs, len(lag_inds))) countsf = sp.zeros(n_diffs, dtype=int) for ii in range(nf): for jj in range(nf): if norms: thiscorr = (self.corr[ii, jj, lag_inds] * self.norms[ii, jj, sp.newaxis]) else: thiscorr = self.corr[ii, jj, lag_inds] df = abs(self.freq1[ii] - self.freq2[jj]) for kk in range(1, n_diffs - 1): if (abs(freq_diffs[kk] - df) <= abs(freq_diffs[kk - 1] - df) and abs(freq_diffs[kk] - df) < abs(freq_diffs[kk + 1] - df)): d_ind = kk if abs(freq_diffs[0] - df) < abs(freq_diffs[1] - df): d_ind = 0 if abs(freq_diffs[-1] - df) <= abs(freq_diffs[-2] - df): d_ind = n_diffs - 1 corrf[d_ind, :] += thiscorr countsf[d_ind] += 1 corrf /= countsf[:, sp.newaxis] if cross_power: pdat = corrf * 1e3 else: pdat = sp.sign(corrf) * sp.sqrt(abs(corrf)) * 1e3 return pdat
def classify_output(self, y): """Classify SVM output""" cl = int(s.sign(y)) if cl == 0: import random print "Warning, class = 0, assigning label 1..." cl = 1 return cl
def classify(self, x): """Classify the input (one point) as +1 or -1""" output = self.compute_layers_output(x) output_class = int(s.sign(output)) if output_class == 0: print >> sys.stderr, "DATA CLASSIFIED WITH 0; deciding to put class 1" output_class = 1 return output_class
def fit_svm_dskl_emp(X,Y,Xtest,Ytest,its=100,eta=1.,C=.1,nPredSamples=10,nExpandSamples=10, kernel=(GaussianKernel,(1.))): Wemp = sp.randn(len(Y)) Eemp = [] for it in range(1,its+1): Wemp = step_dskl_empirical(X,Y,Wemp,eta/it,C,kernel,nPredSamples,nExpandSamples) Eemp.append(sp.mean(Ytest != sp.sign(predict_svm_emp(X,Xtest,Wemp,kernel)))) return Eemp
def __init__(self, *args, **kwargs): MultiModalFunction.__init__(self, *args, **kwargs) self._mu0 = 2.5 self._s = 1 - 1 / (2 * sqrt(self.xdim + 20) - 8.2) self._mu1 = -sqrt((self._mu0 ** 2 - 1) / self._s) self._signs = sign(randn(self.xdim)) self._R1 = orth(rand(self.xdim, self.xdim)) self._R2 = orth(rand(self.xdim, self.xdim)) self._diags = generateDiags(100, self.xdim)
def softThreshold(coeffs,thresh): new_coeffs = [] for j in coeffs: new_coeffs.append(sp.copy(j)) for j in xrange(1,len(new_coeffs)): for i in new_coeffs[j]: i[sp.absolute(i)<thresh] = 0 i[sp.absolute(i)>=thresh] -= (sp.sign(i[sp.absolute(i)>=thresh]))*thresh return new_coeffs
def hyperparameter_search_dskl(reps=2,dname='sonar',maxN=1000,num_test=10000): Xtotal, Ytotal = load_realdata(dname) if maxN > 0: N = sp.minimum(Xtotal.shape[0], maxN) else: N = Xtotal.shape[0] params_dksl = { 'n_pred_samples': [300],#[int(N/2*0.01)],#,int(N/2*0.02),int(N/2*0.03)], 'n_expand_samples': [300],#[int(N/2*0.01)],#,int(N/2*0.02),int(N/2*0.03)], 'n_its': [10000], 'eta': [0.999], 'C': 10. ** sp.arange(-30., -19., 1.),#2 'gamma': [10.], #** sp.arange(0., 4., 1.),#2 'workers': [7], } print "checking parameters:\n",params_dksl Eemp = [] for irep in range(reps): print "repetition:",irep," of ",reps #idx = sp.random.randint(low=0,high=Xtotal.shape[0],size=N + num_test) Xtrain = Xtotal[:N,:]#idx[:N],:] Ytrain = Ytotal[:N]#idx[:N]] # TODO: check when if we have enough data here. Xtest = Xtotal[N:N+num_test,:]#idx[N:N+num_test],:] Ytest = Ytotal[N:N+num_test]#idx[N:N+num_test]] # Xtrain = Xtrain.todense() # Xtest = Xtest.todense() if not sp.sparse.issparse(Xtrain): scaler = StandardScaler() scaler.fit(Xtrain) # Don't cheat - fit only on training data Xtrain = scaler.transform(Xtrain) Xtest = scaler.transform(Xtest) else: scaler = StandardScaler(with_mean=False) scaler.fit(Xtrain) Xtrain = scaler.transform(Xtrain) Xtest = scaler.transform(Xtest) print "Training empirical" # clf = GridSearchCV(DSEKL(),params_dksl,n_jobs=-1,verbose=1,cv=2).fit(Xtrain,Ytrain) clf = GridSearchCV(DSEKLBATCH(),params_dksl,n_jobs=-1,verbose=1,cv=2).fit(Xtrain,Ytrain) print clf.best_estimator_.get_params() Eemp.append(sp.mean(sp.sign(clf.best_estimator_.transform(Xtest))!=Ytest)) print "Emp: %0.2f"%(Eemp[-1]) fname = custom_data_home + "clf_scmallscale_" + dname + "_nt" + str(N) + "_" + str(irep) + str(datetime.datetime.now()) f = open(fname,'wb') print "saving to file:", fname pickle.dump(clf, f, pickle.HIGHEST_PROTOCOL) print "***************************************************************" print "Data set [%s]: Emp_avg: %0.2f+-%0.2f"%(dname,sp.array(Eemp).mean(),sp.array(Eemp).std()) print "***************************************************************"
def run_realdata(reps=2,dname='sonar',maxN=1000): Xtotal,Ytotal = load_realdata(dname) params_dksl = { 'n_pred_samples': [500,1000], 'n_expand_samples': [500,1000], 'n_its':[1000], 'eta':[1.], 'C':10.**sp.arange(-8.,4.,2.),#**sp.arange(-8,-6,1),#[1e-6],# 'gamma':10.**sp.arange(-4.,4.,2.),#**sp.arange(-1.,2.,1)#[10.]# 'workers':[500,1000] } params_batch = { 'C':10.**sp.arange(-8.,4.,2.), 'gamma':10.**sp.arange(-4.,4.,2.) } if maxN > 0: N = sp.minimum(Xtotal.shape[0],maxN) else: N = Xtotal.shape[0] Eemp,Ebatch = [],[] num_train = int(0.9*N) for irep in range(reps): print "repetition:",irep," of ",reps idx = sp.random.randint(low=0,high=Xtotal.shape[0],size=N) Xtrain = Xtotal[idx[:num_train],:] Ytrain = Ytotal[idx[:num_train]] Xtest = Xtotal[idx[num_train:],:] Ytest = Ytotal[idx[num_train:]] # Xtrain = Xtrain.todense() # Xtest = Xtest.todense() if not sp.sparse.issparse(Xtrain): scaler = StandardScaler() scaler.fit(Xtrain) # Don't cheat - fit only on training data Xtrain = scaler.transform(Xtrain) Xtest = scaler.transform(Xtest) else: scaler = StandardScaler(with_mean=False) scaler.fit(Xtrain) Xtrain = scaler.transform(Xtrain) Xtest = scaler.transform(Xtest) print "Training empirical" clf = GridSearchCV(DSEKL(),params_dksl,n_jobs=10,verbose=1,cv=2).fit(Xtrain,Ytrain) Eemp.append(sp.mean(sp.sign(clf.best_estimator_.transform(Xtest))!=Ytest)) clf_batch = GridSearchCV(svm.SVC(),params_batch,n_jobs=1000,verbose=1,cv=3).fit(Xtrain,Ytrain) Ebatch.append(sp.mean(clf_batch.best_estimator_.predict(Xtest)!=Ytest)) print "Emp: %0.2f - Batch: %0.2f"%(Eemp[-1],Ebatch[-1]) print clf.best_estimator_.get_params() print clf_batch.best_estimator_.get_params() print "***************************************************************" print "Data set [%s]: Emp_avg: %0.2f+-%0.2f - Ebatch_avg: %0.2f+-%0.2f"%(dname,sp.array(Eemp).mean(),sp.array(Eemp).std(),sp.array(Ebatch).mean(),sp.array(Ebatch).std()) print "***************************************************************"
def metastable_u0s(k, includeNegativeu0=True): # compute all the values of u0 corresponding to metastable boundaries u0List = [0] if k < 0: raise NotImplemented( 'Metastable boundaries for negative k not implemented') # compute metastable bc for n positive n = 0 err = lambda u0: k * u0 - abs(sin(u0 / 2)) while sign(err(2 * pi * (n + .5))) != sign(err(2 * pi * (n + 1))): u0 = brentq(err, 2 * pi * (n + .5), 2 * pi * (n + 1)) u0List.append(u0) if includeNegativeu0: # add negative metastable u0 u0List.insert(0, -u0) n += 1 return np.array(u0List)
def getBetaSNPste(self): """ get standard errors on betas Returns ------- beta_ste : ndarray """ beta = self.getBetaSNP() pv = self.getPv() z = sp.sign(beta) * sp.sqrt(st.chi2(1).isf(pv)) ste = beta / z return ste
def construct_co_occurrence_matrix(sparse_tokens): """ Calculates a log-scaled co-occurrence matrix between all elements of a count matrix using a dot product. :param sparse_tokens: A sparse matrix of counts :return: Log-scaled co-occurrence matrix """ # compute normalized log co-occurrence counts co_occur = (sparse_tokens.T).dot(sparse_tokens).todense() co_occur_log_matrix = sp.special.xlogy( sp.sign(co_occur), co_occur ) - np.log(co_occur.sum()) np.fill_diagonal(co_occur_log_matrix, 0) return co_occur_log_matrix
def centralityEigenvector(G, max_iter=50, tol=0): M = nx.to_scipy_sparse_matrix(G, nodelist=list(G), weight=None, dtype=float) eigenvalue, eigenvector = linalg.eigs(M.T, k=1, which='LR', maxiter=max_iter, tol=tol) largest = eigenvector.flatten().real norm = sp.sign(largest.sum()) * sp.linalg.norm(largest) return dict(zip(G, largest / norm))
def initializer(self, shape): """通过随机正交矩阵进行LU分解初始化 """ import scipy as sp import scipy.linalg random_matrix = sp.random.randn(shape[-1], shape[-1]) random_orthogonal = sp.linalg.qr(random_matrix)[0] p, l, u = sp.linalg.lu(random_orthogonal) u_diag_sign = sp.sign(sp.diag(u)) u_diag_abs_log = sp.log(abs(sp.diag(u))) l_mask = 1 - sp.tri(shape[-1]).T # l的mask,下三角全1阵(但对角线全0) u_mask = 1 - sp.tri(shape[-1]) # u的mask,上三角全1阵(但对角线全0) return p, l, u, u_diag_sign, u_diag_abs_log, l_mask, u_mask
def signal_to_noise(probability_of_detection, probability_of_false_alarm, number_of_pulses, swerling_type): """ Calculate the single pulse signal to noise for non-coherent integration. :param probability_of_detection: The probability of detection. :param probability_of_false_alarm: The probability of false alarm. :param number_of_pulses: The number of pulses to be non-coherently integrated. :param swerling_type: The Swerling target type. :return: The single pulse signal to noise. """ # First parameter, based on Swerling type if swerling_type == 'Swerling 0': k = sys.float_info.max elif swerling_type == 'Swerling 1': k = 1 elif swerling_type == 'Swerling 2': k = number_of_pulses elif swerling_type == 'Swerling 3': k = 2 else: k = 2 * number_of_pulses # Second parameter, based on number of pulses if number_of_pulses < 40: alpha = 0 else: alpha = 0.25 # Calculated parameters eta = sqrt(-0.8 * log(4 * probability_of_false_alarm * (1.0 - probability_of_false_alarm))) \ + sign(probability_of_detection - 0.5) * sqrt(-0.8 * log(4 * probability_of_detection * (1.0 - probability_of_detection))) x = eta * (eta + 2.0 * sqrt(0.5 * number_of_pulses + alpha - 0.25)) # Constants c1 = (((17.7006 * probability_of_detection - 18.4496) * probability_of_detection + 14.5339) * probability_of_detection - 3.525) / k c2 = (1.0 / k) * (exp(27.31 * probability_of_detection - 25.14) + (probability_of_detection - 0.8) * (0.7 * log(1e-5 / probability_of_false_alarm) + (2.0 * number_of_pulses - 2)) / 80) if 0.1 <= probability_of_detection <= 0.872: cdb = c1 elif 0.872 <= probability_of_detection <= 0.99: cdb = c1 + c2 c = 10.0**(cdb / 10.0) # Signal to noise ratio return 10.0 * log10(c * x / number_of_pulses)
def fit_svm_dskl_comparison(X,Y,its=100,eta=1.,C=.1,nPredSamples=10,nExpandSamples=10, kernel=(GaussianKernel,(1.))): # split into train and test Xtest = X[:,:len(Y)/2] Ytest = Y[:len(Y)/2] X = X[:,(len(Y)/2):] Y = Y[(len(Y)/2):] # random gaussian for rks Zrks = sp.randn(len(Y),X.shape[0]) / (kernel[1]**2) Wrks = sp.randn(len(Y)) Wemp = sp.randn(len(Y)) Erks = [] Eemp = [] for it in range(1,its+1): Wrks = step_dskl_rks(X,Y,Wrks,Zrks,eta/it,C,nPredSamples,nExpandSamples) Wemp = step_dskl_empirical(X,Y,Wemp,eta/it,C,kernel,nPredSamples,nExpandSamples) Erks.append(sp.mean(Ytest != sp.sign(predict_svm_rks(Xtest,Wrks,Zrks)))) Eemp.append(sp.mean(Ytest != sp.sign(predict_svm_emp(X,Xtest,Wemp,kernel)))) return Eemp,Erks
def fit_svm_kernel(X,Y,its=100,eta=1.,C=.1,kernel=(GaussianKernel,(1.)),nPredSamples=10,nExpandSamples=10): D,N = X.shape[0],X.shape[1] X = sp.vstack((sp.ones((1,N)),X)) W = sp.randn(len(Y)) for it in range(its): print "Iteration %4d Accuracy %0.3f"%(it,sp.mean(Y==sp.sign(kernel[0](X,X,kernel[1]).dot(W)))) rnpred = sp.random.randint(low=0,high=N,size=nsamples) rnexpand = sp.random.randint(low=0,high=N,size=nsamples) # compute gradient G = compute_gradient(Y[rnpred],X[:,rnpred],X[:,rnexpand],W[rnexpand],kernel,C) # update W[rnexpand] -= eta/(it+1.) * G return W
def _bess(npts, x1, x2, x1err, x2err, cerr): """ Do the entire regression calculation for 4 slopes: OLS(Y|X), OLS(X|Y), bisector, orthogonal """ # calculate sigma's for datapoints using length of confidence # intervals sig11var = sum(x1err**2) / npts sig22var = sum(x2err**2) / npts sig12var = sum(cerr) / npts # calculate means and variances x1av = scipy.average(x1) x1var = scipy.std(x1)**2 x2av = scipy.average(x2) x2var = scipy.std(x2)**2 covar_x1x2 = sum((x1 - x1av) * (x2 - x2av)) / npts # compute the regression slopes for OLS(X2|X1), OLS(X1|X2), # bisector and orthogonal b = scipy.zeros(4) b[0] = (covar_x1x2 - sig12var) / (x1var - sig11var) b[1] = (x2var - sig22var) / (covar_x1x2 - sig12var) b[2] = (b[0] * b[1] - 1 + scipy.sqrt((1 + b[0] ** 2) * \ (1 + b[1] ** 2))) / (b[0] + b[1]) b[3] = 0.5 * ((b[1] - 1 / b[0]) + scipy.sign(covar_x1x2) * \ scipy.sqrt(4 + (b[1] - 1 / b[0]) ** 2)) # compute intercepts for above 4 cases: a = x2av - b * x1av # set up variables to calculate standard deviations of slope # and intercept xi = [] xi.append(((x1 - x1av) * \ (x2 - b[0] * x1 - a[0]) + b[0] * x1err ** 2) / \ (x1var - sig11var)) xi.append(((x2 - x2av) * (x2 - b[1] * x1 - a[1]) + x2err ** 2) / \ covar_x1x2) xi.append((xi[0] * (1 + b[1] ** 2) + xi[1] * (1 + b[0] ** 2)) / \ ((b[0] + b[1]) * \ scipy.sqrt((1 + b[0] ** 2) * (1 + b[1] ** 2)))) xi.append((xi[0] / b[0] ** 2 + xi[1]) * b[3] / \ scipy.sqrt(4 + (b[1] - 1 / b[0]) ** 2)) zeta = [] for i in xrange(4): zeta.append(x2 - b[i] * x1 - x1av * xi[i]) # calculate variance for all a and b bvar = scipy.zeros(4) avar = scipy.zeros(4) for i in xrange(4): bvar[i] = scipy.std(xi[i])**2 / npts avar[i] = scipy.std(zeta[i])**2 / npts return a, b, avar, bvar, xi, zeta
def draw_weighted_adjacency_matrix(self, inmatrix, labels=None, pos=None): # remove connections with low values ... if self.threshold: inmatrix = self.apply_threshold(inmatrix, self.threshold) adjmat = S.sign(inmatrix) dgr = nx.from_numpy_matrix(adjmat, create_using=nx.DiGraph()) if pos is None: pos = nx.graphviz_layout(dgr) edgewidth = [] for (u, v) in dgr.edges(): flow = inmatrix[u][v] # normalize flow by dividing by some number flow = flow / self.flow_scaler # now done above # set flow = 0 when less than some value ... # so flow originally less than 100 # if flow < 0.5: flow = 0 edgewidth.append(flow) selfflows = [] # normalize size of nodes by dividing by arbitrary constants for nn in dgr.nodes(): flowtoself = inmatrix[nn][nn] / self.total_scaler selfflows.append(flowtoself) # assume nodes are enumerated in right order totalflows = inmatrix.sum(axis=1) / self.total_scaler nx.draw_networkx_edges(dgr, pos, width=edgewidth, edge_color='b', alpha=0.5, node_size=0) nx.draw_networkx_nodes(dgr, pos, node_size=totalflows, node_color='k', alpha=1.0) nx.draw_networkx_nodes(dgr, pos, node_size=selfflows, node_color='y', alpha=1.0) nx.draw_networkx_labels(dgr, pos, labels=labels, font_size=self.font_size, font_color='r') return (dgr, pos)
def __init__(self, documents, tfidf): self.tfidf = tfidf self.vector_tfidf = tfidf.fit_transform(documents) tfidf.use_idf = False tfidf.norm = None self.count_tf = tfidf.fit_transform(documents) self.matrix_tfidf = self.vector_tfidf self.matrix_binary = csr_matrix(scipy.sign(self.count_tf.toarray())) #self.XT = self.matrix_binary.T * self.matrix_binary #self.XD = self.matrix_binary * self.matrix_binary.T self.KT = np.dot(self.matrix_tfidf.T, self.matrix_tfidf) #self.KD = self.matrix_tfidf * self.matrix_tfidf.T self.terms = self.tfidf.get_feature_names()
def captive_system_func(self, v, t, v_cap): """ Function governing the captive trajectory system dynamics , i.e., f(v,t) where dv/dt = f(v,t). Note, In this case v is ignored and v_cap is used as the forces remain constant between realtime system updates. The system is simulated by running an odeint integration for the system evolution between every realtime system update. """ # Get mass and damping m = param.sub_body_mass + param.sub_mount_mass # Compute function value val = -scipy.sign(v_cap) * self.drag_func(v_cap) / m + self.force_func( v_cap, t) / m return val
def train(self): total_batch = int(self.n_items / self.batch_size) idxs = np.random.permutation(self.n_items) # shuffled ordering loss = [] for i in range(total_batch): batch_set_idx = idxs[i * self.batch_size: (i + 1) * self.batch_size] _, loss_ = self.sess.run( [self.optimizer, self.loss], feed_dict={ self.rating_matrix: self.train_matrix[:, batch_set_idx].toarray(), self.rating_matrix_mask: scipy.sign(self.train_matrix[:, batch_set_idx].toarray()), self.keep_rate_net: 1 # 0.95 }) loss.append(loss_) return np.mean(loss)
def train_perceptron(X, Y, iterations=200, eta=.1): ''' Trains a linear perceptron Definition: w, b, acc = train_perceptron(X,Y,iterations=200,eta=.1) Input: X - DxN array of N data points with D features Y - 1D array of length N of class labels {-1, 1} iter - optional, number of iterations, default 200 eta - optional, learning rate, default 0.1 Output: w - 1D array of length D, weight vector b - bias term for linear classification acc - 1D array of length iter, contains classification accuracies after each iteration Accuracy = #correctly classified points / N ''' acc = sp.zeros((iterations)) #include the bias term by adding a row of ones to X X = sp.concatenate((sp.ones((1, X.shape[1])), X)) #initialize weight vector weights = sp.ones((X.shape[0])) / X.shape[0] for it in sp.arange(iterations): # indices of misclassified data wrong = (sp.sign(weights.dot(X)) != Y).nonzero()[0] # compute accuracy acc[it] acc[it] = 1 - ( wrong.shape[0] / float(X.shape[1]) ) # we have to convert one thing to make it a float divison # ... your code here if wrong.shape[0] > 0: # pick a random misclassified data point # ... your code here #update weight vector (use variable learning rate (eta/(1.+it)) ) # ... your code here xidx = sp.random.choice(wrong) x = X[:, xidx] y = Y[xidx] weights = weights + (eta / (1. + it)) * x * y # pick a random misclassified data point # ... your code here #update weight vector (use variable learning rate (eta/(1.+it)) ) # ... your code here if it % 20 == 0: print "Iteration %d:" % it + "Accuracy %0.2f" % acc[it] b = -weights[0] w = weights[1:] #return weight vector, bias and accuracies return w, b, acc
def load_bci_data(fname): ''' Loads BCI data (one subject, copy-spelling experiment) from <fname> Definition: X, Y = load_bci_data(fname) Input: fname - string Output: X - DxN array with N images with D pixels Y - 1D array of length N of class labels (1- target, -1 - non-target) ''' # load the data data = io.loadmat(fname) # extract time-electrode features and labels X = data['X'] Y = data['Y'] # collapse the time-electrode dimensions X = sp.reshape(X, (X.shape[0] * X.shape[1], X.shape[2])) # transform the labels to (-1,1) Y = sp.sign((Y[0, :] > 0) - .5) return X, Y
def guess_initial_parameters(mean, phi0, omega): mean_max = mean.max() mean_min = mean.min() offset = (mean_max + mean_min) / 2. amplitude = (mean_max - mean_min) / 2. if phi0 is None or omega is None: y = mean - offset y2 = savgol_filter(y, 11, 1, mode="nearest") if phi0 is None: cos_phi0 = clip(y2[0] / amplitude, -1., 1.) if y2[1] > y2[0]: phi0 = -arccos(cos_phi0) else: phi0 = arccos(cos_phi0) if omega is None: zero_crossings = scipy.where(scipy.diff(scipy.sign(y2)))[0] omega = pi / scipy.average(scipy.diff(zero_crossings)) return offset, amplitude, phi0, omega
def getF(self): """ returns F=RB_{\Phi}(\Psi), often calculated for grad-shafranov solutions. Not implemented on LIUQE Returns: F (Array): [nt,npsi] array of F=RB_{\Phi}(\Psi) Not stored on LIUQE nodes Raises: ValueError: if module cannot retrieve data from MDS tree. """ if self._fpol is None: try: fluxFFNode = self._MDSTree.getNode(self._root+'::ttpr_coeffs') # Liuqe the data are divided by mu_0 # and following the way chease work we normalize # for mu_0/B0 # we normalize appropriately as done in # read_results_for_chease _zb0 = self.getBtVac()[:, None] _zb0Sign = scipy.sign(_zb0.mean()) duData = (fluxFFNode.data() * scipy.constants.mu_0) # then we build an appropriate grid nPsi = self.getRmidPsi().shape[1] psiV = scipy.linspace(1, 0, nPsi) rad = [psiV] for i in range(duData.shape[1]-1): rad += [rad[-1]*psiV*(i+1)/(i+2)] rad = scipy.vstack(rad) _du = scipy.dot(duData, rad) self._fpol = _zb0Sign*scipy.sqrt( scipy.reshape( self.getFluxAxis(), (self.getFluxAxis().size, 1))*2 * scipy.subtract(_du.transpose(), _du[:, -1].transpose()).transpose() + (_zb0*0.88)**2) self._defaultUnits['_fpol'] = 'T*m' except TreeException: raise ValueError('data retrieval failed.') return self._fpol.copy()
def __call__(self, gradient, error=None): """ calculates parameter change based on given gradient and returns updated parameters """ # check if gradient has correct dimensionality, then make array """ if len(gradient) != len(self.values): raise Exception("{} is not equal to {}".format( str(gradient), str(self.values))) gradient_arr = asarray(gradient) if self.rprop: rprop_theta = self.rprop_theta # update parameters self.values += sign(gradient_arr) * rprop_theta # update rprop meta parameters dirSwitch = self.lastgradient * gradient_arr rprop_theta[dirSwitch > 0] *= self.etaplus idx = dirSwitch < 0 rprop_theta[idx] *= self.etaminus gradient_arr[idx] = 0 # upper and lower bound for both matrices rprop_theta = rprop_theta.clip(min=self.deltamin, max=self.deltamax) # save current gradients to compare with in next time step self.lastgradient = gradient_arr.copy() self.rprop_theta = rprop_theta else: # update momentum vector (momentum = 0 clears it) self.momentumvector *= self.momentum # update parameters (including momentum) self.momentumvector += self.alpha * gradient_arr self.alpha *= self.alphadecay # update parameters self.values += self.momentumvector return self.values
def sort_reduce_tfidf(self, n): # Converte para Matrix mtx = self.vector_tfidf.toarray() # Converte matrix espaca em array para ordenar por TFIDF s = [np.sum(x) for x in mtx.T] sorted_s = sorted(s) sorted_s = np.array(sorted_s) if (not n): n = len(s) s_id_sorted = sorted(range(len(s)), key=lambda k: s[k], reverse=True)[:n] # print(s_id_sorted) self.matrix_tfidf = mtx.T[s_id_sorted].T self.matrix_binary = scipy.sign(self.matrix_tfidf) self.terms = np.array(self.tfidf.get_feature_names())[s_id_sorted] return
def get_e_in(theta, s, x, y, u=None): e_in = 0 correct = [] incorrect = [] if u is None: n = len(x) else: n = sum(u) for i in range(len(x)): if s * sign(x[i] - theta) != y[i]: incorrect.append(i) if u is None: e_in += 1 / n else: e_in += u[i] / n else: correct.append(i) return e_in, correct, incorrect
def hess(A): """Computes the upper Hessenberg form of A using Householder reflectors. input: A, mxn array output: Q, orthogonal mxm array H, upper Hessenberg s.t. QHQ' = A """ H = A.copy() m, n = H.shape Q = sp.eye(m, m) for k in sp.arange(n - 2): v = H[k + 1:m, k].copy() v[0] += sp.sign(v[0]) * la.norm(v) v = v / la.norm(v) v = v.reshape(m - k - 1, 1) P = sp.eye(m, m) P[k + 1:m, k + 1:m] -= 2 * sp.dot(v, v.T) Q = sp.dot(P, Q) H = sp.dot(P, sp.dot(H, P.T)) return Q.T, H
def hqr(A): """Finds the QR decomposition of A using Householder reflectors. input: A, mxn array with m>=n output: Q, orthogonal mxm array R, upper triangular mxn array s.t QR = A """ R = A.copy() m, n = R.shape Q = sp.eye(m, m) for k in sp.arange(n - 1): v = R[k:m, k].copy() v[0] += sp.sign(v[0]) * la.norm(v) v = v / la.norm(v) v = v.reshape(m - k, 1) P = sp.eye(m, m) P[k:m, k:m] -= 2 * sp.dot(v, v.T) Q = sp.dot(P, Q) R = sp.dot(P, R) return Q.T, R
def Horizontal(lat_sites, lon_sites, lat_events, lon_events, lengths, azimuths, widths, dips, depths, depths_to_top, projection, trace_start_lat, trace_start_lon, rupture_centroid_x, rupture_centroid_y): """Distance function that calculates Horizontal. Horizontal is the shortest horizontal distance (km) from a site to the line defined by extending the surface rupture trace to infinity. ^ north / /\azimuth start 0======---+-------- \ | \ | \ | \ | Rx \ | \ | \ | \ | \| . site We get Horizontal by using ll2xy() to convert start/site positions to x and y in the coordinates relative to start and with axes shown in fig 3.1 of the manual. Rx is therefore the y value. """ # get correct dimensionality lat_sites = lat_sites[:, newaxis] lon_sites = lon_sites[:, newaxis] # get x,y position of sites w.r.t. origin 'start' (_, Rx) = ll2xy(lat_sites, lon_sites, trace_start_lat, trace_start_lon, azimuths) # limit distance to 1.0km minimum return where(abs(Rx) < DISTANCE_LIMIT, sign(Rx) * DISTANCE_LIMIT, Rx)
def scale_DLogistic(self, steepness): ''' Scale the video with a double logistic of steepness. Double Logistic Definition (bottom): http://en.wikipedia.org/wiki/Logistic_function Use a double logistic to normalize the 1-band video array in Va and then rescale output to the 0:1 range Some asserts that are required. 1. Video is float32 already TODO: Inplace operation should be supported. But, the sp.sign and sp.exp don't seem to allow out= keywords even though their doc says they do. ''' assert (self.V.dtype == sp.float32) Va = self.V Va = sp.sign(Va) * (1.0 - sp.exp(-(Va / steepness) * (Va / steepness))) Va = (Va + 1.0) / 2.0 return asvideo(Va)
def create_my_plot(ad_time, gd_time, ad_score): FF = lambda a, b: sc.sign(a - b) * a / b ad_time[ad_time == 0] = 9 gd_time[gd_time == 0] = 9 print("ad_time".format(np.mean(ad_time, axis=0))) print("".format(np.mean(gd_time, axis=0))) plt.imshow(sc.mean(FF(ad_time, gd_time), axis=0), cmap=plt.cm.get_cmap('RdBu'), vmin=-9, vmax=9) cb = plt.colorbar() tick_locator = ticker.MaxNLocator(nbins=9) cb.locator = tick_locator cb.update_ticks() cb.ax.set_yticklabels( ['1/8', '1/6', '1/4', '1/2', '1', '2', '4', '6', '8']) plt.xticks(np.arange(6), ('200', '500', '1000', '2000', '5000', '10000')) plt.yticks(np.arange(7), ('30000', '20000', '10000', '5000', '2500', '1000', '200')) plt.show() GG = lambda a, b: sc.log(a / b) plt.figure() plt.imshow(sc.mean(sc.log(ad_score), axis=0), cmap=plt.cm.get_cmap('Reds'), vmin=-18, vmax=0) cb = plt.colorbar() tick_locator = ticker.MaxNLocator(nbins=5) cb.locator = tick_locator cb.update_ticks() cb.ax.set_yticklabels(['1e-8', '1e-6', '1e-4', '1e-2', '1']) plt.xticks(np.arange(6), ('200', '500', '1000', '2000', '5000', '10000')) plt.yticks(np.arange(7), ('30000', '20000', '10000', '5000', '2500', '1000', '200'))
def showfullmulti( matfile ): """ Author: Disa Mhembere contact: [email protected] 1. False color graph from a mat file 2. Mono-coloring for binirized mat file Both full graphs not upper/lower triangular """ matcontents = loadmat ( matfile ) graphcsc = matcontents[ "fibergraph" ] graphdata = np.array ( graphcsc.todense() ) graphdata = graphdata + graphdata.T print graphdata [ 0:4, 0:4 ] fig = matplotlib.pyplot.pcolormesh( graphdata[:,:] ) matplotlib.pyplot.colorbar() matplotlib.pyplot.show () bw_graphdata = scipy.sign(graphdata) fig2 = matplotlib.pyplot.pcolormesh( bw_graphdata[ :,: ], cmap='Greys')#, interpolation='nearest' ) matplotlib.pyplot.colorbar() matplotlib.pyplot.show ()
def plot_eigvect(vect, labels=None, bottom=0, num_label=5, label_offset=0.15): """ Plot a given eigenvector. If a list of labels is passed in, the largest (in magnitude) num_label bars will be labeled on the plot. label_offset controls how much the labels are shifted from the top of the bars for clarity. bottom controls where the bar plot is centered along the y axis. This is useful for plotting several e'vectors on the same axes. """ # The 0.4 centers the bars on their numbers, accounting for the default # bar width of 0.8 vect = scipy.real(vect) max_index = scipy.argmax(abs(vect)) if vect[max_index] < 0: vect = -vect bar(scipy.arange(len(vect)) - 0.4, vect / scipy.linalg.norm(vect), bottom=bottom) a = list(axis()) a[0:2] = [-.03 * len(vect) - 0.4, (len(vect) - 1) * 1.03 + 0.4] if labels is not None: mags = zip(abs(vect), range(len(vect)), vect) mags.sort() mags.reverse() for mag, index, val in mags[:num_label]: name = labels[index] text(index, val + scipy.sign(val) * label_offset, name, horizontalalignment='center', verticalalignment='center') a[2] -= 0.1 a[3] += 0.1 axis(a)
def get_updates(self, params, constraints, loss): """ calculates parameter change based on given gradient and returns updated parameters check if gradient has correct dimensionality, then make array """ gradient_arr = asarray(gradient) if self.rprop: rprop_theta = self.rprop_theta # update parameters self.values += sign(gradient_arr) * rprop_theta # update rprop meta parameters dirSwitch = self.lastgradient * gradient_arr rprop_theta[dirSwitch > 0] *= self.etaplus idx = dirSwitch < 0 rprop_theta[idx] *= self.etaminus gradient_arr[idx] = 0 # upper and lower bound for both matrices rprop_theta = rprop_theta.clip(min=self.deltamin, max=self.deltamax) # save current gradients to compare with in next time step self.lastgradient = gradient_arr.copy() self.rprop_theta = rprop_theta else: # update momentum vector (momentum = 0 clears it) self.momentumvector *= self.momentum # update parameters (including momentum) self.momentumvector += self.alpha * gradient_arr self.alpha *= self.alphadecay # update parameters self.values += self.momentumvector return self.values
def kMeans(img,k): ''' Applique la méthode des k-means sur une image pour la segmenter @param img: image à traiter (créer précédemment grâce à "imread()") @param k: nombre de clusters @return: l'image après traitement ''' # convert to np.float32 res = img.reshape((-1, 3)) res = np.float32(res) # define criteria, number of clusters(K) and apply kmeans() criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 10, 1.0) ret, label, center = cv2.kmeans(res, k, None, criteria, 10, cv2.KMEANS_RANDOM_CENTERS) # Now convert back into uint8, and make original image center = np.uint8(center) res = center[label.flatten()] res = (res/np.min(res))-1 # normaliser à 0 res = scipy.sign(res) # Binarisation res = res * 255 # pour afficher en noir blanc res2 = res.reshape((img.shape)) return res2