def SVMtest(maxT, sumM, val, c_w_l, C=1e3,gamma=1e-1, k=2.2e35, lims=[2.2e3,9e3], reduced=None): #val, c_w_l, idx = conditionVal(name=name, nozero=nozero, conc=conc) temp = val/c_w_l/sumM*k print(maxT.shape, temp.shape) #data = scipy.io.readsav('W_Abundances_grid_puestu_adpak_fitscaling_74_0.00000_5.00000_1000_idlsave') #te = data['en'] #idx2 = scipy.logical_and(te > lims[0], te < lims[1]) y = time.time() if reduced is None: xData = scipy.log(scipy.atleast_2d(maxT).T) yData = scipy.log(temp) else: xData = scipy.log(scipy.atleast_2d(maxT[reduced]).T) yData = scipy.log(temp[reduced]) svm = sklearn.svm.SVR(cache_size=7000)#,C=C,gamma=gamma) pipe = Pipeline([('scale',StandardScaler()),('svm',svm)]) pipe.set_params(svm__C=C,svm__gamma=gamma) pipe.fit(xData,yData) print(time.time()-y) return pipe
def prob_contour(H, xedges, yedges, p=0.95): """Compute PDF value enclosing desired probability mass. The contour corresponding to the returned PDF value will contain (approximately) p integrated probability mass. Parameters ---------- H : 2d array, (n_x, n_y) Normalized (as PDF) histogram. xedges : 1d array, (n_x + 1,) X edges of histogram bins. yedges: 1d array, (n_y + 1,) Y edges of histogram bins. p : float, optional Probability to find contour of. Default is 0.95 """ # Plan: Find highest value, add. Repeat until target probability reached, # return value of H at last point added. This should be the contour which # encloses the desired fraction of probability mass. dx = scipy.atleast_2d(scipy.diff(xedges)).T dy = scipy.atleast_2d(scipy.diff(yedges)) PM = (H * dx * dy).ravel() H = H.ravel() # Sort into order of decreasing probability mass: srtidx = PM.argsort()[::-1] # Find cumulative sum: PM_sum = PM[srtidx].cumsum() # Find first point where PM_sum >= p: mask = PM_sum >= scipy.atleast_2d(p).T out = scipy.zeros(mask.shape[0]) for i in range(mask.shape[0]): idx, = scipy.nonzero(mask[i, :]) out[i] = H[srtidx[idx[0]]] return out
def gridSearch(maxT, sumM, name,loc='svmcrossvalid.p',reduction=50,k=2.2e35,gamma=[-3,3], C=[0,6], nozero=False, conc='c_w_l', lims=[2.2e3,9e3]): val, c_w_l, idx = conditionVal(name=name, nozero=nozero, conc=conc) idx1 = sample(val,len(val)/reduction) idx2 = sample(val,len(val)/reduction) #very small subsamples started for testing algos index0 = scipy.logspace(gamma[0],gamma[1],int(abs(gamma[0]-gamma[1])+1)) index1 = scipy.logspace(C[0],C[1],int(abs(C[0]-C[1])+1)) data = scipy.io.readsav('W_Abundances_grid_puestu_adpak_fitscaling_74_0.00000_5.00000_1000_idlsave') te = data['en'] idx2 = scipy.logical_and(te > lims[0], te < lims[1]) temp = val[idx2]/c_w_l[idx2]/sumM[idx2]*k output = scipy.zeros((len(index0),len(index1))) output2 = scipy.zeros((len(index0),len(index1),len(te[idx2]))) for i in xrange(len(index0)): for j in xrange(len(index1)): print(i,j) pipe = SVMtest(maxT, sumM, val, c_w_l, reduced=idx1, gamma=index0[i], C=index1[j],k=k) output[i,j] = pipe.score(scipy.log(scipy.atleast_2d(maxT[idx2]).T),scipy.log(temp)) output2[i,j] = scipy.exp(pipe.predict(scipy.log(scipy.atleast_2d(te[idx2]).T))) pickle.dump([output,output2],open(loc,'wb')) return output,output2
def intercept(self, ray): """Solves for intersection point of surface and a ray or Beam Args: ray: Ray or Beam object It must be in the same coordinate space as the surface object. Returns: s: value of s [meters] which intercepts along norm, otherwise an empty tuple (for no intersection). Examples: Accepts all point and point-derived object inputs, though all data is stored as a python object. Generate an y direction Ray in cartesian coords using a Vec from (0,0,1):: cen = geometry.Center(flag=True) ydir = geometry.Vecx((0,1,0)) zpt = geometry.Point((0,0,1),cen) """ # Proceedure will be to generate if self._origin is ray._origin: try: rcopy = ray.copy() rcopy.redefine(self) intersect = _beam.interceptCyl(scipy.atleast_2d(rcopy.x()[:,-1]), scipy.atleast_2d(rcopy.norm.unit), scipy.array([self.sagi.s,self.sagi.s]), scipy.array([-self.norm.s,self.norm.s])) + rcopy.norm.s[-1] if not scipy.isfinite(intersect): #relies on r1 using arctan2 so that it sets the branch cut properly (-pi,pi] return None elif self.edgetest(intersect, (rcopy(intersect)).r1()): return intersect else: rcopy.norm.s[-1] = intersect intersect = _beam.interceptCyl(scipy.atleast_2d(rcopy.x()[:,-1]), scipy.atleast_2d(rcopy.norm.unit), scipy.array([self.sagi.s,self.sagi.s]), scipy.array([-self.norm.s,self.norm.s])) + rcopy.norm.s[-1] if not scipy.isfinite(intersect): #relies on r1 using arctan2 so that it sets the branch cut properly (-pi,pi] return None elif self.edgetest(intersect, (rcopy(intersect)).r1()): return None else: return None except AttributeError: raise ValueError('not a surface object') else: raise ValueError('not in same coordinate system, use redefine and try again')
def __call__(self, X, n): n = scipy.atleast_2d(scipy.asarray(n, dtype=int)) X = scipy.atleast_2d(scipy.asarray(X)) n_unique = unique_rows(n) mu = scipy.zeros(X.shape[0]) for nn in n_unique: idxs = (n == nn).all(axis=1) mu[idxs] = self.fun(X[idxs, :], nn, *self.params) return mu
def topterms(self,n_terms=10): """ This function is given. """ vec = sp.atleast_2d(sp.arange(0,self.n_words)) topics = [] for k in xrange(self.n_topics): probs = sp.atleast_2d(self._phi[k,:]) mat = sp.append(probs,vec,0) sind = sp.array([mat[:,i] for i in sp.argsort(mat[0])]).T topics.append([self.vocab[int(sind[1,self.n_words - 1 - i])] for i in xrange(n_terms)]) return topics
def worker_quality(predictions, num_classes): predictions = sp.atleast_2d(predictions) num_workers, num_objects = predictions.shape error_rates = sp.zeros((num_workers, num_classes, num_classes)) diy, diz = sp.diag_indices(num_classes) error_rates[:, diy, diz] = 1 while True: # E step new_predictions = sp.zeros((num_objects, num_classes)) for i in xrange(num_objects): individual_predictions = predictions[:, i] individual_error_rates = error_rates[range(num_workers), individual_predictions, individual_predictions] new_predictions[i, :] = sp.bincount(individual_predictions, individual_error_rates, minlength=num_classes) correct_labels = sp.argmax(new_predictions, axis=1) count_per_label = sp.bincount(correct_labels) # M step new_error_rates = sp.zeros((num_workers, num_classes, num_classes)) for i, label in enumerate(correct_labels): new_error_rates[range(num_workers), label, predictions[:, i]] += 1 for i in xrange(num_classes): new_error_rates[:, :, i] /= count_per_label diff_error_rates = sp.absolute(new_error_rates - error_rates) error_rates = new_error_rates if sp.amax(diff_error_rates) < 0.001: break # calculate the cost of each worker class_priors = sp.bincount(correct_labels, minlength=num_classes) / float(num_objects) costs = [] for k in xrange(num_workers): worker_class_priors = sp.dot(sp.atleast_2d(class_priors), error_rates[k])[0] + 0.0000001 cost = 0 for j in xrange(num_classes): soft_label = error_rates[k, :, j] * class_priors / worker_class_priors[j] soft_label_cost = 0.0 for i in xrange(num_classes): soft_label_cost += sp.sum(soft_label[i] * soft_label) soft_label_cost -= sp.sum(soft_label ** 2) # subtract the diagonal entries (those costs = 0) cost += soft_label_cost * worker_class_priors[j] costs.append(cost) return error_rates, correct_labels, costs
def mat_atan2(y,x): if shape(y)!=shape(x): raise IndexError, 'In matrix atan2, shape(x)!-shape(y)' x=atleast_2d(x) y=atleast_2d(y) nr=shape(y)[0] nc=shape(y)[1] outmat=zeros((nr,nc),'d') # pdb.set_trace() for i in range(nr): for j in range(nc): outmat[i,j]=atan2(y[i,j],x[i,j]) return colwise(outmat)
def sinc_interp1d(x, s, r): """Interpolates `x`, sampled at times `s` Output `y` is sampled at times `r` inspired from from Matlab: http://phaseportrait.blogspot.com/2008/06/sinc-interpolation-in-matlab.html :param ndarray x: input data time series :param ndarray s: input sampling time series (regular sample interval) :param ndarray r: output sampling time series :return ndarray: output data time series (regular sample interval) """ # init s = sp.asarray(s) r = sp.asarray(r) x = sp.asarray(x) if x.ndim == 1: x = sp.atleast_2d(x) else: if x.shape[0] == len(s): x = x.T else: if x.shape[1] != s.shape[0]: raise ValueError('x and s must be same temporal extend') if sp.allclose(s, r): return x.T T = s[1] - s[0] # resample sincM = sp.tile(r, (len(s), 1)) - sp.tile(s[:, sp.newaxis], (1, len(r))) return sp.vstack([sp.dot(xx, sp.sinc(sincM / T)) for xx in x]).T
def phigprov(self, Pp, Pg, theta): """ Calculate transition probabilities Parameters ------------ Pp : ndarray, shape (n, k) Conditional choice probabilities for provinces Pg : ndarray, shape (n, 2 k) Conditional choice probabilities for the government theta : ndarray, shape (5, ) Parameters Returns --------- V : ndarray Observable state values Notes ----------- Takes conditional choice probabilities :math:`P` and :math:`\theta` as an input and returns values :math:`V^P`. This is the mapping :math:`\Phi` in part (b) of the assignment. This is a wrapper for the matlab function **Phigprov**. """ theta = sp.atleast_2d(theta) return pytave.feval(1, "Phigprov", Pp, Pg, theta, self.model())[0]
def new_p(self, Pp, Pg, theta): """ Calculate transition probabilities Parameters -------------- Pp : ndarray, shape (n, k) Conditional choice probabilities for provinces Pg : ndarray, shape (n, 2 k) Conditional choice probabilities for the government theta : ndarray, shape (5, ) Parameters Returns --------- Pp : ndarray, shape (n, k) New conditional choice probabilities for provinces Pg : ndarray, shape (n, 2 k) New conditional choice probabilities for the government Notes ----------- Takes conditional choice probabilities :math:`P` and :math:`\theta` as an input and returns new conditional choice values. This is the mapping :math:`\Psi` in part (c) of the assignment. This is a wrapper for the matlab function **NewP**. """ theta = sp.atleast_2d(theta) return pytave.feval(2, "NewP", Pp, Pg, theta, self.model())
def chunk_data(data, epochs=None, invert=False): """returns a generator of chunks from data given epochs :type data: ndarray :param data: signal data [[samples, channels]] :type epochs: ndarray :param epochs: epoch set, positive mask :type invert: bool :param invert: invert epochs, negative mask instead of positive mask :returns: generator - data chunks as per :epochs: """ # checks data = sp.asarray(data) if data.ndim != 2: data = sp.atleast_2d(data).T if epochs is not None: if epochs.ndim != 2: raise ValueError("epochs has to be ndim=2 like [[start,end]]") if invert is True and epochs is not None: epochs = invert_epochs(epochs, end=data.shape[0]) if epochs is None or len(epochs) == 0: epochs = [[0, data.shape[0]]] # yield data chunks for ep in epochs: yield data[ep[0] : ep[1], :], list(ep)
def vec2ten(data, nchan=4): """converts from templates/spikes that are concatenated across the channels to tensors that have an extra dim for the channels :type data: ndarray :param data: input array [templates][vars * channels] :type nchan: int :param nchan: count of channels Default=4 :returns: ndarray - data converted to tensor [templates][vars][channels] """ if data.ndim == 1: data = sp.atleast_2d(data) n, dim = data.shape if dim % nchan != 0: raise ValueError( 'dim %s nchan != 0 !! dim=%s, nchan=%s' % (dim, nchan)) tf = dim / nchan rval = sp.zeros((n, tf, nchan), data.dtype) for i in xrange(n): for c in xrange(nchan): rval[i, :, c] = data[i, c * tf:(c + 1) * tf] return rval
def nullspace(A, atol=1e-13, rtol=0): '''Compute an approximate basis for the nullspace of A. The algorithm used by this function is based on the singular value decomposition of `A`. This implementation was copied from the scipy cookbook: http://www.scipy.org/Cookbook/RankNullspace @param A: ndarray A should be at most 2-D. A 1-D array with length k will be treated as a 2-D with shape (1, k) @param atol : float The absolute tolerance for a zero singular value. Singular values smaller than `atol` are considered to be zero. @param rtol : float The relative tolerance. Singular values less than rtol*smax are considered to be zero, where smax is the largest singular value. @note: If both `atol` and `rtol` are positive, the combined tolerance is the maximum of the two; that is:: tol = max(atol, rtol * smax) Singular values smaller than `tol` are considered to be zero. @return: ns ndarray If `A` is an array with shape (m, k), then `ns` will be an array with shape (k, n), where n is the estimated dimension of the nullspace of `A`. The columns of `ns` are a basis for the nullspace; each element in numpy.dot(A, ns) will be approximately zero. ''' A = sp.atleast_2d(A) _u, s, vh = LA.svd(A) tol = max(atol, rtol * s[0]) nnz = (s >= tol).sum() ns = vh[nnz:].conj().T return ns
def summed_dist_matrix(self, vectors, presorted=False): """ Calculates the sum of all element pair distances for each pair of vectors. If :math:`(a_1, \\dots, a_n)` and :math:`(b_1, \\dots, b_m)` are the :math:`u`-th and :math:`v`-th vector from `vectors` and :math:`K` the kernel, the resulting entry in the 2D array will be :math:`D_{uv} = \\sum_{i=1}^{n} \\sum_{j=1}^{m} K(a_i - b_j)`. :param sequence vectors: A sequence of Quantity 1D to calculate the summed distances for each pair. The required units depend on the kernel. Usually it will be the inverse unit of the kernel size. :param bool presorted: Some optimized specializations of this function may need sorted vectors. Set `presorted` to `True` if you know that the passed vectors are already sorted to skip the sorting and thus increase performance. :rtype: Quantity 2D """ D = sp.empty((len(vectors), len(vectors))) if len(vectors) > 0: might_have_units = self(vectors[0]) if hasattr(might_have_units, 'units'): D = D * might_have_units.units else: D = D * pq.dimensionless for i, j in sp.ndindex(len(vectors), len(vectors)): D[i, j] = sp.sum( self((vectors[i] - sp.atleast_2d(vectors[j]).T).flatten())) return D
def summed_dist_matrix(self, vectors, presorted=False): """ Calculates the sum of all element pair distances for each pair of vectors. If :math:`(a_1, \\dots, a_n)` and :math:`(b_1, \\dots, b_m)` are the :math:`u`-th and :math:`v`-th vector from `vectors` and :math:`K` the kernel, the resulting entry in the 2D array will be :math:`D_{uv} = \\sum_{i=1}^{n} \\sum_{j=1}^{m} K(a_i - b_j)`. :param sequence vectors: A sequence of Quantity 1D to calculate the summed distances for each pair. The required units depend on the kernel. Usually it will be the inverse unit of the kernel size. :param bool presorted: Some optimized specializations of this function may need sorted vectors. Set `presorted` to `True` if you know that the passed vectors are already sorted to skip the sorting and thus increase performance. :rtype: Quantity 2D """ D = sp.empty((len(vectors), len(vectors))) if len(vectors) > 0: might_have_units = self(vectors[0]) if hasattr(might_have_units, 'units'): D = D * might_have_units.units else: D = D * pq.dimensionless for i, j in sp.ndindex(len(vectors), len(vectors)): D[i, j] = sp.sum(self( (vectors[i] - sp.atleast_2d(vectors[j]).T).flatten())) return D
def chunk_data(data, epochs=None, invert=False, min_len=0): """returns a generator of chunks from data given epochs :type data: ndarray :param data: signal data [[samples, channels]] :type epochs: ndarray :param epochs: epoch set, positive mask :type invert: bool :param invert: invert epochs, negative mask instead of positive mask :param min_len: epochs with fewer samples will be ignored and not returned :type min_len: int :returns: generator - data chunks as per :epochs: """ # checks data = sp.asarray(data) if data.ndim != 2: data = sp.atleast_2d(data).T if epochs is not None: if epochs.ndim != 2: raise ValueError('epochs has to be ndim=2 like [[start,end]]') if invert is True and epochs is not None: epochs = invert_epochs(epochs, end=data.shape[0]) if epochs is None or len(epochs) == 0: epochs = [[0, data.shape[0]]] # yield data chunks for ep in epochs: if ep[1] - ep[0] >= min_len: yield data[ep[0]:ep[1], :], list(ep)
def arcfit(p, x, arc, mod): fit = {'coeff': scipy.atleast_2d(p).T, 'type': 'polynomial'} w = sf.genfunc(x, 0., fit) cond = (w > bcutoff) & (w < rcutoff) m = interpolate.splev(w[cond], mod) chi = (m - arc[cond]) / abs(arc[cond])**0.5 return chi
def plot_filter_set(self, ph=None, show=False): """plot the filter set in a waveform plot""" # get plotting tools try: from spikeplot import waveforms except ImportError: return None # checks if self.nf == 0: warnings.warn("skipping plot, no active units!") return None # init units = {} for k in self._idx_active_set: units[k] = sp.atleast_2d(self.bank[k].f_conc) return waveforms( units, tf=self._tf, plot_separate=True, plot_mean=False, plot_single_waveforms=False, plot_handle=ph, show=show, )
def reconstruct(self, X): n_features = sp.atleast_2d(X).shape[1] latent = sp.dot(self.inv_M, sp.dot(self.weight.T, (X - self.predict_mean).T)) eps = sprd.multivariate_normal(sp.zeros(n_features), self.sigma2 * sp.eye(n_features)) recons = sp.dot(self.weight, latent) + self.predict_mean + eps return recons
def signal(signal, events=None, epochs=None, spike_trains=None, spike_waveforms=None): """ Create a plot from an AnalogSignal. :param AnalogSignal signal: The signal to plot. :param sequence events: A list of Event objects to be included in the plot. :param sequence epochs: A list of Epoch objects to be included in the plot. :param dict spike_trains: A dictionary of SpikeTrain objects to be included in the plot. Spikes are plotted as vertical lines. Indices of the dictionary (typically Unit objects) are used for color and legend entries. :param sequence spike_waveforms: A dictionary of lists of Spike objects to be included in the plot. Waveforms of spikes are overlaid on the signal. Indices of the dictionary (typically Unit objects) are used for color and legend entries. """ # Plot title win_title = 'Analog Signal' if signal.recordingchannel: win_title += ' | Recording Channel: %s' % \ signal.recordingchannel.name if signal.segment: win_title += ' | Segment: %s' % signal.segment.name win = PlotDialog(toolbar=True, wintitle=win_title) signalarray = neo.AnalogSignalArray(sp.atleast_2d(sp.asarray(signal)).T, units=signal.units, sampling_rate=signal.sampling_rate) _plot_signal_array_on_window(win, signalarray, events, epochs, spike_trains, spike_waveforms, False)
def _multi_norm(x, mean): """ Evaluate pdf of multivariate normal distribution with a mean at rows of x with high precision. """ d = x.shape[1] fac = (2 * sp.pi)**(-d / 2.0) y = cdist(x, sp.atleast_2d(mean), 'sqeuclidean') * -0.5 return fac * sp.exp(sp.longdouble(y))
def genCylGrid(x0, x1, x2, edges=False): if edges: for i in (x0, x1, x2): i = scipy.insert(i, 0, 2 * i[1] - i[2]) i = scipy.append(i, 2 * i[-1] - i[-2]) i = (i[1:] + i[:-1]) / 2 pnts = scipy.empty((x0.size, x1.size, x2.size, 3)) xin = scipy.dot(scipy.atleast_2d(x0).T, scipy.atleast_2d(scipy.cos(x1))) yin = scipy.dot(scipy.atleast_2d(x0).T, scipy.atleast_2d(scipy.sin(x1))) zee = scipy.ones(yin.shape) for i in range(x2.size): pnts[:, :, i, 0] = xin pnts[:, :, i, 1] = yin pnts[:, :, i, 2] = x2[i] * zee return pnts
def _multi_norm(x, mean): """ Evaluate pdf of multivariate normal distribution with a mean at rows of x with high precision. """ d = x.shape[1] fac = (2 * sp.pi) ** (-d / 2.0) y = cdist(x, sp.atleast_2d(mean), "sqeuclidean") * -0.5 return fac * sp.exp(sp.longdouble(y))
def _stop_training(self, *args, **kwargs): # produce data in one piece self.data = sp.vstack(self.data) # calculate energy self.energy = self._energy_func(self.data) if self.energy.ndim == 1: self.energy = sp.atleast_2d(self.energy).T self.size, self.nchan = self.energy.shape
def genCylGrid(x0,x1,x2,edges=False): if edges: for i in (x0,x1,x2): i = scipy.insert(i,0,2*i[1]-i[2]) i = scipy.append(i,2*i[-1]-i[-2]) i = (i[1:]+i[:-1])/2 pnts = scipy.empty((x0.size, x1.size, x2.size,3)) xin = scipy.dot(scipy.atleast_2d(x0).T, scipy.atleast_2d(scipy.cos(x1))) yin = scipy.dot(scipy.atleast_2d(x0).T, scipy.atleast_2d(scipy.sin(x1))) zee = scipy.ones(yin.shape) for i in range(x2.size): pnts[:,:,i,0] = xin pnts[:,:,i,1] = yin pnts[:,:,i,2] = x2[i]*zee return pnts
def regular_cube_innerproduct(rcc, k): """ For a given regular_cube_complex, compute a matrix representing the k-form innerproduct. These elements are similar to Whitney forms, except using standard linear (bilinear,trilinear,..) elements for 0-forms. """ N = rcc.complex_dimension() #standard cube is [0,0,..,0] [0,1,...,N] standard_cube = atleast_2d(array([0] * N + range(N), dtype='i')) standard_k_faces = standard_cube for i in range(N, k, -1): standard_k_faces = cube_array_boundary(standard_k_faces, i)[0] k_faces_per_cube = standard_k_faces.shape[0] K = zeros((k_faces_per_cube, k_faces_per_cube)) #local stiffness matrix h = 1 V = h**N #cube volume scale = V * (1 / h)**2 * (1 / 3.0)**(N - k) for i, row_i in enumerate(standard_k_faces): for j, row_j in enumerate(standard_k_faces): if all(row_i[N:] == row_j[N:]): differences = (row_i[:N] != row_j[:N]) differences[row_i[N:]] = 0 K[i, j] = scale * (1.0 / 2.0)**sum(differences) else: K[i, j] = 0 CA = rcc[-1].cube_array[:, :N] num_cubes = CA.shape[0] k_faces = tile(hstack((CA, zeros((CA.shape[0], k), dtype=CA.dtype))), (1, k_faces_per_cube)).reshape((-1, N + k)) k_faces += tile(standard_k_faces, (num_cubes, 1)) k_face_array = rcc[k].cube_array face_indices = cube_array_search(k_face_array, k_faces) rows = face_indices.repeat(k_faces_per_cube) cols = face_indices.reshape( (-1, k_faces_per_cube)).repeat(k_faces_per_cube, axis=0).reshape( (-1, )) data = K.reshape((1, -1)).repeat(num_cubes, axis=0).reshape((-1, )) # temporary memory cost solution - eliminate zeros from COO representation nz_mask = data != 0.0 rows = rows[nz_mask] cols = cols[nz_mask] data = data[nz_mask] shape = (len(k_face_array), len(k_face_array)) return coo_matrix((data, (rows, cols)), shape).tocsr()
def get_all_forces(atoms, mlmodel, grid_spacing, extfield=None, mixing=[1.,0.,0.], lammpsdata=None, do_update=False): # get actual forces and potential energy of configuration pot_energy, forces = calc_lammps(atoms, preloaded_data=lammpsdata) forces = [forces] ### ML IS HERE ### if not (mlmodel is None or (mixing[1] == 0 and not do_update)): # Accumulate the new observation in the dataset coarse_colvars = round_vector(atoms.colvars(), precision=grid_spacing) distance_from_data = sp_dist.cdist( sp.atleast_2d(coarse_colvars), mlmodel.X_fit_).ravel() # check if configuration has already occurred if distance_from_data.min() == 0.0: index = list(distance_from_data).index(0.0) # Learn E_min: uncomment this if pot_energy < mlmodel.y[index]: mlmodel.y[index] = pot_energy else: do_update = False # # Learn free energy: uncomment this # beta = 1 / self.temp # mlmodel.y[index] += - 1 / beta * sp.log( # 1 + sp.exp(- beta * (pot_energy - mlmodel.y[index]))) # pot_energy = mlmodel.y[index] else: mlmodel.accumulate_data(coarse_colvars, pot_energy) if do_update: # update ML potential with all the data contained in it. mlmodel.update_fit() # Get ML constraint forces if the model is fitted if hasattr(mlmodel, 'dual_coef_') and pot_energy < 0: ml_forces = get_constraint_forces(atoms, mlmodel) # ml_forces /= sp.mean(map(LA.norm, ml_forces)) # ml_forces *= 1 * sp.mean(map(LA.norm, forces[0])) forces.append(ml_forces) else: forces.append(sp.zeros(forces[0].shape)) # X_near = Xplotgrid([atoms.phi() - 0.2, atoms.psi() - 0.2], [atoms.phi() - 0.2, atoms.psi() - 0.2], 2, 10) # y_near_mean = mlmodel.predict(X_near).mean() # if pot_energy < y_near_mean: # mix = 1.2 # else: # mix = 0.8 # EXTERNAL FIELD IS HERE if not (extfield is None or mixing[2] == 0): colvars = round_vector(atoms.colvars(), precision=grid_spacing) extfield.update_cost(colvars, pot_energy) extfield_forces = get_extfield_forces(atoms, extfield) extfield_forces /= sp.mean(map(LA.norm, extfield_forces)) extfield_forces *= sp.mean(map(LA.norm, forces[0])) forces.append(extfield_forces) # Compose the actual and the ML forces together by mixing them accordingly # a [1,-1,0] mixing would result, in the perfect fitting limit, to a zero # mean field motion. forces = [m_i * f_i for m_i, f_i in zip(mixing[:len(forces)], forces)] f = sp.sum(forces, axis=0) return f, pot_energy, forces
def detect_skew(img, min_angle=-20, max_angle=20, quality='low'): img = sp.atleast_2d(img) rows, cols = img.shape min_min_angle = min_angle max_max_angle = max_angle if quality == 'low': resolution = sp.arctan2(2.0, cols) * 180.0 / sp.pi min_target_size = 100 resize_order = 1 elif quality == 'high': resolution = sp.arctan2(1.0, cols) * 180.0 / sp.pi min_target_size = 300 resize_order = 3 else: resolution = sp.arctan2(1.0, cols) * 180.0 / sp.pi min_target_size = 200 resize_order = 2 # resize the image so it's faster to work with min_size = min(rows, cols) target_size = min_target_size if min_size > min_target_size else min_size resize_ratio = float(target_size) / min_size img = imresize(img, resize_ratio) rows, cols = img.shape # pad the image and invert the colors img *= -1 img += 255 padded_img = sp.zeros((rows*2, cols*2)) padded_img[rows//2:rows//2+rows, cols//2:cols//2+cols] = img img = padded_img # keep dividing the interval in half to achieve O(log(n)) while True: current_resolution = (max_angle - min_angle) / 30.0 best_angle = None best_variance = 0.0 # rotate the image, sum the pixel values in each row for each rotation # then find the variance of all the sums, pick the highest variance for i in xrange(31): angle = min_angle + i * current_resolution rotated_img = rotate(img, angle, reshape=False, order=resize_order) num_black_pixels = sp.sum(rotated_img, axis=1) variance = sp.var(num_black_pixels) if variance > best_variance: best_angle = angle best_variance = variance if current_resolution < resolution: break # update the angle range min_angle = max(best_angle - current_resolution, min_min_angle) max_angle = min(best_angle + current_resolution, max_max_angle) return best_angle
def regular_cube_innerproduct(rcc,k): """ For a given regular_cube_complex, compute a matrix representing the k-form innerproduct. These elements are similar to Whitney forms, except using standard linear (bilinear,trilinear,..) elements for 0-forms. """ N = rcc.complex_dimension() #standard cube is [0,0,..,0] [0,1,...,N] standard_cube = atleast_2d(array([0]*N + range(N),dtype='i')) standard_k_faces = standard_cube for i in range(N,k,-1): standard_k_faces = cube_array_boundary(standard_k_faces,i)[0] k_faces_per_cube = standard_k_faces.shape[0] K = zeros((k_faces_per_cube,k_faces_per_cube)) #local stiffness matrix h = 1 V = h**N #cube volume scale = V * (1/h)**2 * (1/3.0)**(N-k) for i,row_i in enumerate(standard_k_faces): for j,row_j in enumerate(standard_k_faces): if all(row_i[N:] == row_j[N:]): differences = (row_i[:N] != row_j[:N]) differences[row_i[N:]] = 0 K[i,j] = scale * (1.0/2.0)**sum(differences) else: K[i,j] = 0 CA = rcc[-1].cube_array[:,:N] num_cubes = CA.shape[0] k_faces = tile(hstack((CA,zeros((CA.shape[0],k),dtype=CA.dtype))),(1,k_faces_per_cube)).reshape((-1,N+k)) k_faces += tile(standard_k_faces,(num_cubes,1)) k_face_array = rcc[k].cube_array face_indices = cube_array_search(k_face_array,k_faces) rows = face_indices.repeat(k_faces_per_cube) cols = face_indices.reshape((-1,k_faces_per_cube)).repeat(k_faces_per_cube,axis=0).reshape((-1,)) data = K.reshape((1,-1)).repeat(num_cubes,axis=0).reshape((-1,)) # temporary memory cost solution - eliminate zeros from COO representation nz_mask = data != 0.0 rows = rows[nz_mask] cols = cols[nz_mask] data = data[nz_mask] shape = (len(k_face_array),len(k_face_array)) return coo_matrix( (data,(rows,cols)), shape).tocsr()
def nb_vals(matrix, indices): matrix = scipy.array(matrix) indices = tuple(scipy.transpose(scipy.atleast_2d(indices))) arr_shape = scipy.shape(matrix) dist = scipy.ones(arr_shape) dist[indices] = 0 dist = scipy.ndimage.distance_transform_cdt(dist, metric='chessboard') nb_indices = scipy.transpose(scipy.nonzero(dist == 1)) return [matrix[tuple(ind)] for ind in nb_indices]
def get_constraint_forces(atoms, ml_model): """ Atomic forces of a trained ML model given the configuration in atoms. """ pos = atoms.get_positions() ds_dr = sp.array([ddihedralangle_dr(pos, dihedral_atoms_phi), ddihedralangle_dr(pos, dihedral_atoms_psi, shift=True)]) dUml_ds = ml_model.predict_gradient(sp.atleast_2d(atoms.colvars())) forces = - sp.dot(ds_dr.T, dUml_ds.ravel()).T return forces
def compute(i, j): if i == j: return 1.0 elif trains[i].size <= 0 or trains[j].size <= 0: return 0.0 else: diff_matrix = sp.absolute(trains[i] - sp.atleast_2d(trains[j]).T) return 0.5 * ( sp.sum(kernel(sp.amin(diff_matrix, axis=0))) / trains[i].size + sp.sum(kernel(sp.amin(diff_matrix, axis=1))) / trains[j].size)
def coeffExpand(M): if M.shape[0] != M.shape[1]: raise ValueError("Matrix must be square") M = sp.atleast_2d(M) if M.shape == (1,1): return M.item(0,0) else: det = sum(M[0,i]*(((-1)**i)*coeffExpand(sp.delete(M[1:],i,1))) for i in range(len(M))) return det
def victor_purpura_dist(trains, q=1.0 * pq.Hz, kernel=None, sort=True): """ Calculates the Victor-Purpura's (VP) distance. It is often denoted as :math:`D^{\\text{spike}}[q]`. It is defined as the minimal cost of transforming spike train `a` into spike train `b` by using the following operations: * Inserting or deleting a spike (cost 1.0). * Shifting a spike from :math:`t` to :math:`t'` (cost :math:`q \\cdot |t - t'|`). A detailed description can be found in *Victor, J. D., & Purpura, K. P. (1996). Nature and precision of temporal coding in visual cortex: a metric-space analysis. Journal of Neurophysiology.* Given the average number of spikes :math:`n` in a spike train and :math:`N` spike trains the run-time complexity of this function is :math:`O(N^2 n^2)` and :math:`O(N^2 + n^2)` memory will be needed. :param sequence trains: Sequence of :class:`neo.core.SpikeTrain` objects of which the distance will be calculated pairwise. :param q: Cost factor for spike shifts as inverse time scalar. If `kernel` is not `None`, `q` will be ignored. :type q: Quantity scalar :param kernel: Kernel to use in the calculation of the distance. If `kernel` is `None`, an unnormalized triangular kernel with a half width of `2.0/q` will be used. :type kernel: :class:`.signal_processing.Kernel` :param bool sort: Spike trains with sorted spike times will be needed for the calculation. You can set `sort` to `False` if you know that your spike trains are already sorted to decrease calculation time. :returns: Matrix containing the VP distance of all pairs of spike trains. :rtype: 2-D array """ if kernel is None: if q == 0.0: num_spikes = sp.atleast_2d([st.size for st in trains]) return sp.absolute(num_spikes.T - num_spikes) else: kernel = sigproc.TriangularKernel(2.0 / q, normalize=False) if sort: trains = [sp.sort(st.view(type=pq.Quantity)) for st in trains] def compute(i, j): if i == j: return 0.0 else: return _victor_purpura_dist_for_trial_pair(trains[i], trains[j], kernel) return _create_matrix_from_indexed_function((len(trains), len(trains)), compute, kernel.is_symmetric())
def victor_purpura_dist(trains, q=1.0 * pq.Hz, kernel=None, sort=True): """ Calculates the Victor-Purpura's (VP) distance. It is often denoted as :math:`D^{\\text{spike}}[q]`. It is defined as the minimal cost of transforming spike train `a` into spike train `b` by using the following operations: * Inserting or deleting a spike (cost 1.0). * Shifting a spike from :math:`t` to :math:`t'` (cost :math:`q \\cdot |t - t'|`). A detailed description can be found in *Victor, J. D., & Purpura, K. P. (1996). Nature and precision of temporal coding in visual cortex: a metric-space analysis. Journal of Neurophysiology.* Given the average number of spikes :math:`n` in a spike train and :math:`N` spike trains the run-time complexity of this function is :math:`O(N^2 n^2)` and :math:`O(N^2 + n^2)` memory will be needed. :param sequence trains: Sequence of :class:`neo.core.SpikeTrain` objects of which the distance will be calculated pairwise. :param q: Cost factor for spike shifts as inverse time scalar. If `kernel` is not `None`, `q` will be ignored. :type q: Quantity scalar :param kernel: Kernel to use in the calculation of the distance. If `kernel` is `None`, an unnormalized triangular kernel with a half width of `2.0/q` will be used. :type kernel: :class:`.signal_processing.Kernel` :param bool sort: Spike trains with sorted spike times will be needed for the calculation. You can set `sort` to `False` if you know that your spike trains are already sorted to decrease calculation time. :returns: Matrix containing the VP distance of all pairs of spike trains. :rtype: 2-D array """ if kernel is None: if q == 0.0: num_spikes = sp.atleast_2d([st.size for st in trains]) return sp.absolute(num_spikes.T - num_spikes) else: kernel = sigproc.TriangularKernel(2.0 / q, normalize=False) if sort: trains = [sp.sort(st.view(type=pq.Quantity)) for st in trains] def compute(i, j): if i == j: return 0.0 else: return _victor_purpura_dist_for_trial_pair( trains[i], trains[j], kernel) return _create_matrix_from_indexed_function( (len(trains), len(trains)), compute, kernel.is_symmetric())
def barycentric_gradients(pts): """ Compute the gradients of the barycentric basis functions over a given simplex """ V = asarray(pts[1:] - pts[0]) ##all gradients except the first are computed grads = dot(inv(inner(V,V)),V) #safer, but slower: grads = scipy.linalg.pinv2(V).T ##since sum of all gradients is zero, simply compute the first from the others return vstack((atleast_2d(-numpy.sum(grads,axis=0)),grads))
def skycorrect(p, arc, sky, arcmodel, skymodel): fit = {'coeff': scipy.atleast_2d(p[:-1]).T, 'type': 'polynomial'} w = sf.genfunc(x, 0., fit) arcm = interpolate.splev(w + p[-1], arcmodel) chi_arc = (arcm - arc) s = sky[w > 5100.] skym = interpolate.splev(w[w > 5100.], skymodel) skym *= scipy.median(s / skym) chi_sky = 5. * (skym - s) #/abs(m)**0.5 chi = scipy.concatenate((chi_arc, chi_sky)) return chi
def posterior_prob(self, obs, with_noise=False): """posterior probabilities for data under the model :type obs: ndarray :param obs: observations to be evaluated [n, tf, nc] :type with_noise: bool :param with_noise: if True, include the noise cluster as component in the mixture. Default=False :rtype: ndarray :returns: matrix with per component posterior probabilities [n, c] """ # check obs obs = sp.atleast_2d(obs) if len(obs) == 0: raise ValueError('no observations passed!') data = [] if obs.ndim == 2: if obs.shape[1] != self._tf * self._nc: raise ValueError('data dimensions not compatible with model') for i in xrange(obs.shape[0]): data.append(obs[i]) elif obs.ndim == 3: if obs.shape[1:] != (self._tf, self._nc): raise ValueError('data dimensions not compatible with model') for i in xrange(obs.shape[0]): data.append(mcvec_to_conc(obs[i])) data = sp.asarray(data, dtype=sp.float64) # build comps comps = self.get_template_set(mc=False) if with_noise: comps = sp.vstack((comps, sp.zeros((self._tf * self._nc)))) comps = comps.astype(sp.float64) if len(comps) == 0: return sp.zeros((len(obs), 1)) # build priors prior = sp.array([self._lpr_s] * len(comps), dtype=sp.float64) if with_noise: prior[-1] = self._lpr_n # get sigma try: sigma = self._ce.get_cmx(tf=self._tf).astype(sp.float64) except: return sp.zeros((len(obs), 1)) # calc log probs lpr = log_multivariate_normal_density(data, comps, sigma, 'tied') + prior logprob = logsumexp(lpr, axis=1) return sp.exp(lpr - logprob[:, sp.newaxis])
def summed_dist_matrix(self, vectors, presorted=False): D = sp.empty((len(vectors), len(vectors))) if len(vectors) > 0: might_have_units = self(vectors[0]) if hasattr(might_have_units, 'units'): D = D * might_have_units.units for i in xrange(len(vectors)): for j in xrange(i, len(vectors)): D[i, j] = D[j, i] = sp.sum(self( (vectors[i] - sp.atleast_2d(vectors[j]).T).flatten())) return D
def __call__(self, X, n, hyper_deriv=None): """Evaluate the mean function at the given points with the current parameters. Parameters ---------- X : array, (`N`,) or (`N`, `D`) Points to evaluate the mean function at. n : array, (`N`,) or (`N`, `D`) Derivative orders for each point. hyper_deriv : int or None, optional Index of parameter to take derivative with respect to. """ n = scipy.atleast_2d(scipy.asarray(n, dtype=int)) X = scipy.atleast_2d(scipy.asarray(X)) n_unique = unique_rows(n) mu = scipy.zeros(X.shape[0]) for nn in n_unique: idxs = (n == nn).all(axis=1) mu[idxs] = self.fun(X[idxs, :], nn, *self.params, hyper_deriv=hyper_deriv) return mu
def coExpand(M): # if not M.shape[0] == M.shape[1]: # raise Exception, "Matrix must be square" M = sp.atleast_2d(M) if M.shape == (1, 1): print M.item(0, 0) return M.item(0, 0) else: print M first = M.item(0, 0) * coeffExpand(M[1:, 1:]) last = M.item(0, -1) * ((-1) ** (len(M) - 1)) * coeffExpand(M[1:, :-1])
def dofit(p, x, data, model): if scipy.isnan(p).any(): return x * 0. + 1e7 fit = {'coeff': scipy.atleast_2d(p[1:]).T, 'type': 'polynomial'} w = sf.genfunc(x, 0., fit) m = interpolate.splev(w, model) m *= p[0] chi = (m - data) / abs(data)**0.5 cond = ~scipy.isnan(chi) cond = cond & scipy.isfinite(chi) cond = cond & (w > cutoff) & (w < 10400.) return chi[cond] / chi[cond].size
def summed_dist_matrix(self, vectors, presorted=False): D = sp.empty((len(vectors), len(vectors))) if len(vectors) > 0: might_have_units = self(vectors[0]) if hasattr(might_have_units, 'units'): D = D * might_have_units.units for i in xrange(len(vectors)): for j in xrange(i, len(vectors)): D[i, j] = D[j, i] = sp.sum( self((vectors[i] - sp.atleast_2d(vectors[j]).T).flatten())) return D
def rowwise(matin, makecopy=1): # t1=time.time() if makecopy: tempmat = copy.deepcopy(matin) else: tempmat = matin # t2=time.time() # print('copy time='+str(t2-t1)) matout = scipy.atleast_2d(tempmat) myshape = scipy.shape(matout) if myshape[0] > myshape[1]: matout = scipy.transpose(matout) return matout
def compute(i, j): if i == j: return 1.0 else: if tau is None: tau_mat = spq.minimum( *spq.meshgrid(auto_taus[i], auto_taus[j])) / 2.0 else: tau_mat = sp.tile(tau, (trains[j].size, trains[i].size)) coincidence = sp.sum( kernel((trains[i] - sp.atleast_2d(trains[j]).T) / tau_mat)) normalization = 1.0 / sp.sqrt(trains[i].size * trains[j].size) return normalization * coincidence
def _van_rossum_multiunit_dist_for_trial_pair(a, b, weighting, tau, kernel): if kernel is None: spike_counts = sp.atleast_2d([st.size for st in a + b]) k_dist = spike_counts.T * (spike_counts - spike_counts.T) else: k_dist = kernel.summed_dist_matrix(a + b) non_diagonal = sp.logical_not(sp.eye(len(a))) summed_population = (sp.trace(k_dist) - sp.trace(k_dist, len(a)) - sp.trace(k_dist, -len(a))) labeled_line = (sp.sum(k_dist[:len(a), :len(a)][non_diagonal]) + sp.sum(k_dist[len(a):, len(a):][non_diagonal]) - sp.sum(k_dist[:len(a), len(a):][non_diagonal]) - sp.sum(k_dist[len(a):, :len(a)][non_diagonal])) return sp.sqrt(summed_population + weighting * labeled_line)
def pendular_ring(target, throat_diameter='throat.diameter', pore_diameter='pore.diameter'): r""" Calculates the volume of the pendular rings residing between the end of a cylindrical throat and spherical pores that are in contact but not overlapping. This volume should be added to the throat volume if the throat length was found as the center-to-center distance less the pore radii. Parameters ---------- throat_diameter : string The dictionary keys containing the array with the throat diameter values. pore_diameter : string The dictionary keys containing the array with the pore diameter values. Returns ------- volume : ND-array The volume that should be added to each throat volume to account for under-represented void volume at the pore-throat junctions. Notes ----- This model does NOT consider the possibility that multiple throats might overlap in the same location which could happen if throats are large and connectivity is random. See Also -------- lens """ network = target.network conns = network['throat.conns'] Rp = target[pore_diameter] Rt = target[throat_diameter] a = _sp.atleast_2d(Rt).T q = _sp.arcsin(a / Rp[conns]) b = Rp[conns] * _sp.cos(q) h = Rp[conns] - b Vlens = 1 / 6 * _sp.pi * h * (3 * a**2 + h**2) Vcyl = _sp.pi * (a)**2 * h V = Vcyl - Vlens return _sp.sum(V, axis=1)
def cs_dist(trains, smoothing_filter, sampling_rate, filter_area_fraction=sigproc.default_kernel_area_fraction): """ Calculates the Cauchy-Schwarz distance between two spike trains given a smoothing filter. Let :math:`v_a(t)` and :math:`v_b(t)` with :math:`t \\in \\mathcal{T}` be the spike trains convolved with some smoothing filter and :math:`V(a, b) = \\int_{\\mathcal{T}} v_a(t) v_b(t) dt`. Then, the Cauchy-Schwarz distance of the spike trains is defined as :math:`d_{CS}(a, b) = \\arccos \\frac{V(a, b)^2}{V(a, a) V(b, b)}`. The Cauchy-Schwarz distance is closely related to the Schreiber et al. similarity measure :math:`S_S` by :math:`d_{CS} = \\arccos S_S^2` This function numerically convolves the spike trains with the smoothing filter which can be quite slow and inaccurate. If the analytical result of the autocorrelation of the smoothing filter is known, one can use :func:`schreiber_similarity` for a more efficient and precise calculation. Further information can be found in *Paiva, A. R. C., Park, I., & Principe, J. (2010). Inner products for representation and learning in the spike train domain. Statistical Signal Processing for Neuroscience and Neurotechnology, Academic Press, New York.* :param sequence trains: Sequence of :class:`neo.core.SpikeTrain` objects of which the distance will be calculated pairwise. :param smoothing_filter: Smoothing filter to be convolved with the spike trains. :type smoothing_filter: :class:`.signal_processing.Kernel` :param sampling_rate: The sampling rate which will be used to bin the spike trains as inverse time scalar. :type sampling_rate: Quantity scalar :param float filter_area_fraction: A value between 0 and 1 which controls the interval over which the smoothing filter will be discretized. At least the given fraction of the complete smoothing filter area will be covered. Higher values can lead to more accurate results (besides the sampling rate). :returns: Matrix containing the Cauchy-Schwarz distance of all pairs of spike trains :rtype: 2-D array """ inner = st_inner(trains, trains, smoothing_filter, sampling_rate, filter_area_fraction) return sp.arccos(inner**2 / sp.diag(inner) / sp.atleast_2d(sp.diag(inner)).T)
def van_rossum_dist(trains, tau=1.0 * pq.s, kernel=None, sort=True): """ Calculates the van Rossum distance. It is defined as Euclidean distance of the spike trains convolved with a causal decaying exponential smoothing filter. A detailed description can be found in *Rossum, M. C. W. (2001). A novel spike distance. Neural Computation, 13(4), 751-763.* This implementation is normalized to yield a distance of 1.0 for the distance between an empty spike train and a spike train with a single spike. Divide the result by sqrt(2.0) to get the normalization used in the cited paper. Given :math:`N` spike trains with :math:`n` spikes on average the run-time complexity of this function is :math:`O(N^2 n^2)`. An implementation in :math:`O(N^2 n)` would be possible but has a high constant factor rendering it slower in practical cases. :param sequence trains: Sequence of :class:`neo.core.SpikeTrain` objects of which the van Rossum distance will be calculated pairwise. :param tau: Decay rate of the exponential function as time scalar. Controls for which time scale the metric will be sensitive. This parameter will be ignored if `kernel` is not `None`. May also be :const:`scipy.inf` which will lead to only measuring differences in spike count. :type tau: Quantity scalar :param kernel: Kernel to use in the calculation of the distance. This is not the smoothing filter, but its autocorrelation. If `kernel` is `None`, an unnormalized Laplacian kernel with a size of `tau` will be used. :type kernel: :class:`.signal_processing.Kernel` :param bool sort: Spike trains with sorted spike times might be needed for the calculation. You can set `sort` to `False` if you know that your spike trains are already sorted to decrease calculation time. :returns: Matrix containing the van Rossum distances for all pairs of spike trains. :rtype: 2-D array """ if kernel is None: if tau == sp.inf: spike_counts = [st.size for st in trains] return (spike_counts - sp.atleast_2d(spike_counts).T)**2 kernel = sigproc.LaplacianKernel(tau, normalize=False) k_dist = kernel.summed_dist_matrix( [st.view(type=pq.Quantity) for st in trains], not sort) vr_dist = sp.empty_like(k_dist) for i, j in sp.ndindex(*k_dist.shape): vr_dist[i, j] = (k_dist[i, i] + k_dist[j, j] - k_dist[i, j] - k_dist[j, i]) return sp.sqrt(vr_dist)
def dofit(p, x, data, model): if scipy.isnan(p).any(): return x * 0. + 1e7 if abs(p[2] - scale) / scale > 0.15: return x * 0. + 1e7 fit = {'coeff': scipy.atleast_2d(p[1:]).T, 'type': 'polynomial'} w = sf.genfunc(x, 0., fit) m = interpolate.splev(w, model) m *= p[0] chi = (m - data) / abs(data)**0.5 cond = ~scipy.isnan(chi) cond = cond & scipy.isfinite(chi) cond = cond & (w > lowave) & (w < maxwave) badval = abs(chi[cond]).max() chi[~cond] = 2 * badval return chi
def append_data_peaks(self, data, force=False): """append bin(s) calculated from a strip of data with this method the data is first queried for peaks. this should reduce the noise/smoothness of the histogram as observed from the amplitude distribution of the pure signal. :type data: ndarray :param data: the data to generate the bin(s) to append from :type force: bool :param force: if True, immediately start a new bin before calculation """ # check data data_ = sp.asanyarray(data) if data.ndim < 2: data_ = sp.atleast_2d(data_) if data_.shape[0] < data_.shape[1]: data_ = data_.T nsmpl, nchan = data_.shape if nchan != self._nchan: raise ValueError('data has channel count %s, expected %s' % (nchan, self._nchan)) # generate bin set bin_set = [0] if self._cur_bin_smpl != 0: bin_set.append(self._bin_size - self._cur_bin_smpl) while bin_set[-1] < nsmpl: bin_set.append(bin_set[-1] + self._bin_size) if bin_set[-1] > nsmpl: bin_set[-1] = nsmpl # process bins idx = 1 while idx < len(bin_set): data_bin = data_[bin_set[idx - 1]:bin_set[idx], :] for c in xrange(self._nchan): self._cur_bin[c] += sp.histogram(data_bin[:, c], bins=self._ampl_range)[0] self._cur_bin_smpl += data_bin.shape[0] if self._cur_bin_smpl == self._bin_size: self.append_bin(self._cur_bin) self._cur_bin[:] = 0 self._cur_bin_smpl = 0 idx += 1