我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用numpy.argmin()。
def fftfilt(b, x, *n): N_x = len(x) N_b = len(b) N = 2**np.arange(np.ceil(np.log2(N_b)),np.floor(np.log2(N_x))) cost = np.ceil(N_x / (N - N_b + 1)) * N * (np.log2(N) + 1) N_fft = int(N[np.argmin(cost)]) N_fft = int(N_fft) # Compute the block length: L = int(N_fft - N_b + 1) # Compute the transform of the filter: H = np.fft.fft(b,N_fft) y = np.zeros(N_x, x.dtype) i = 0 while i <= N_x: il = np.min([i+L,N_x]) k = np.min([i+N_fft,N_x]) yt = np.fft.ifft(np.fft.fft(x[i:il],N_fft)*H,N_fft) # Overlap.. y[i:k] = y[i:k] + yt[:k-i] # and add i += L return y
def contest(self, b, g, r): """ Search for biased BGR values Finds closest neuron (min dist) and updates self.freq finds best neuron (min dist-self.bias) and returns position for frequently chosen neurons, self.freq[i] is high and self.bias[i] is negative self.bias[i] = self.GAMMA*((1/self.NETSIZE)-self.freq[i])""" i, j = self.SPECIALS, self.NETSIZE dists = abs(self.network[i:j] - np.array([b,g,r])).sum(1) bestpos = i + np.argmin(dists) biasdists = dists - self.bias[i:j] bestbiaspos = i + np.argmin(biasdists) self.freq[i:j] *= (1-self.BETA) self.bias[i:j] += self.BETAGAMMA * self.freq[i:j] self.freq[bestpos] += self.BETA self.bias[bestpos] -= self.BETAGAMMA return bestbiaspos
def rasterMaskToGrid( rasterMask ): grid = [] mask = rasterMask['mask'] for y in range(rasterMask['height']): for x in range(rasterMask['width']): if mask[y,x]==0: grid.append([x,y]) grid = np.array(grid,dtype=np.float) if not (rasterMask is None) and rasterMask['hex'] is True: f = math.sqrt(3.0)/2.0 offset = -0.5 if np.argmin(rasterMask['mask'][0]) > np.argmin(rasterMask['mask'][1]): offset = 0.5 for i in range(len(grid)): if (grid[i][1]%2.0==0.0): grid[i][0]-=offset grid[i][1] *= f return grid
def update_waveforms(self): self.waveforms_ax.clear() for idx, p in enumerate(self.to_consider[list(self.inspect_templates)]): tmp = self.templates[:, p] tmp = tmp.toarray().reshape(self.N_e, self.N_t) elec = numpy.argmin(numpy.min(tmp, 1)) thr = self.thresholds[elec] if self.ui.show_peaks.isChecked(): indices = [self.inv_nodes[self.nodes[elec]]] else: indices = self.inv_nodes[self.edges[self.nodes[elec]]] for sidx in indices: xaxis = numpy.linspace(self.x_position[sidx], self.x_position[sidx] + (self.N_t/(self.sampling_rate*1e-3)), self.N_t) self.waveforms_ax.plot(xaxis, self.y_position[sidx] + tmp[sidx], c=colorConverter.to_rgba(self.inspect_colors_templates[idx])) #self.waveforms_ax.plot([0, xaxis[-1]], [-thr, -thr], c=colorConverter.to_rgba(self.inspect_colors_templates[idx]), linestyle='--') self.waveforms_ax.set_xlabel('Probe Space') self.waveforms_ax.set_ylabel('Probe Space') for fig in [self.ui.waveforms]: fig.draw_idle()
def run_forests(): print('random forest: \n') params = [] scores = [] for _ in range(5): max_features = np.random.randint(400,800) max_depth = np.random.choice([None, None, None, None, 30, 40, 60]) forest = RandomForestClassifier(n_estimators=50, max_features=max_features, max_depth=max_depth) forest_fit = forest.fit(X_train, Y_train) pred = forest_fit.predict(X_test) print('\n params:', dict(max_features=max_features, max_depth=max_depth)) print('forest train: ',zero_one_score(Y_train, forest_fit.predict(X_train)), ' test: ', zero_one_score(Y_test, pred)) params.append( (max_features, max_depth) ) scores.append( zero_one_score(Y_test, pred)) print('best:', params[np.argmin(scores)])
def _translate(seq, f_init, f_next, trg_eos_idx, src_sel, trg_sel, k, cond_init_trg, normalize, n_best, **kwargs): sample, score = gen_sample( f_init, f_next, x=numpy.array(seq).reshape([len(seq), 1]), eos_idx=trg_eos_idx, src_selector=src_sel, trg_selector=trg_sel, k=k, maxlen=3*len(seq), stochastic=False, argmax=False, cond_init_trg=cond_init_trg, **kwargs) if normalize: lengths = numpy.array([len(s) for s in sample]) score = score / lengths if n_best == 1: sidx = numpy.argmin(score) elif n_best > 1: sidx = numpy.argsort(score)[:n_best] else: raise ValueError('n_best cannot be negative!') return sample[sidx], score[sidx]
def doesnt_match(self, words): """ Which word from the given list doesn't go with the others? Example:: >>> trained_model.doesnt_match("breakfast cereal dinner lunch".split()) 'cereal' """ words = [word for word in words if word in self.vocab] # filter out OOV words logger.debug("using words %s" % words) if not words: raise ValueError("cannot select a word from an empty list") # which word vector representation is furthest away from the mean? selection = self.syn0norm[[self.vocab[word].index for word in words]] mean = np.mean(selection, axis=0) sim = np.dot(selection, mean / np.linalg.norm(mean)) return words[np.argmin(sim)]
def temporalize(x, smoothing_steps, distance='L1'): """ :param x: An (n_samples, n_dims) dataset :return: A (n_samples, ) array of indexes that can be used to shuffle the input for temporal smoothness. """ x_flat = x.reshape(x.shape[0], -1) index_buffer = np.arange(1, smoothing_steps+1) next_sample_buffer = x_flat[1:smoothing_steps+1].copy() # Technically, we could do this without a next_sample_buffer (and only an index_buffer), but it would require # repeatedly accessing a bunch of really scattered memory, so we do it this way. shuffling_indices = np.zeros(len(x), dtype=int) rectifier = np.abs if distance=='L1' else np.square if distance=='L2' else bad_value(distance) p=ProgressIndicator(len(x), name = 'Temporalize') current_index = 0 for i in xrange(len(x)): shuffling_indices[i] = current_index closest = np.argmin(rectifier(x_flat[current_index]-next_sample_buffer).sum(axis=1)) current_index = index_buffer[closest] weve_aint_done_yet = i+smoothing_steps+1 < len(x) next_index = i+smoothing_steps+1 next_sample_buffer[closest] = x_flat[next_index] if weve_aint_done_yet else float('inf') index_buffer[closest] = next_index if weve_aint_done_yet else -1 p() return shuffling_indices
def _solveHyperplaneProjection(self, points): m, n = self.A.shape errors = np.zeros(m) for i in range(m): if i in self.ban_constraints: errors[i] = 9999999 else: ai = self.A[i] / np.linalg.norm(self.A[i].T, self.normalize_c) bi = self.b[i] / np.linalg.norm(self.A[i].T, self.normalize_c) errors[i] = np.sum([ai * pt - bi for pt in points]) minInd = np.argmin(errors) self.c = self.A[minInd] / np.linalg.norm(self.A[minInd].T, self.normalize_c) self.c = self.c.tolist()[0] self.error = errors[minInd] self.dual = np.zeros(m) self.dual[minInd] = 1 / np.linalg.norm(self.A[minInd].T, self.normalize_c) self._solved = True return errors[minInd]
def get_min_pos_kinect(): (depth,_) = get_depth() minVal = np.min(depth) #This is the minimum value from the depth image minPos = np.argmin(depth) #This is the raw index of the minimum value above xPos = np.mod(minPos, xSize) #This is the x component of the raw index yPos = minPos//xSize #This is the y component of the raw index xList.append(xPos) del xList[0] xPos = int(np.mean(xList)) yList.append(yPos) del yList[0] yPos = int(np.mean(yList)) return (xSize - xPos-10, yPos, minVal)
def al_just_expert(adata, clf, thresh_random = 3): n = len(adata.taken_items) # examples taken m = adata.mat.shape[0] # examples available if m < 1: return -1 if n < thresh_random or not adata.taken_both_classes(): i = random.randint(0, m-1) return adata.query_expert_direct(i) # uncertainty sampling # undersample: #mat, rel = undersam(adata.taken_mat.tocsr(), adata.taken_rel) #clf.fit(mat, rel) clf.fit(adata.taken_mat, adata.taken_rel) pp = clf.predict_proba(adata.mat) uncertain = np.abs(pp[:,0] - 0.5) i = np.argmin(uncertain) j = np.argmin(pp[:,0]) #print pp[i,0] return adata.query_expert_direct(i)
def al_crowd_fin_expert(adata, clf, turk_uncer, crowd_budget = 5*1500): if adata.spent_crowd < crowd_budget and len(adata.rel) > 0: res = al_just_crowd(adata, clf) if res != -1: return res print "q expert" n = len(adata.taken_items) crowd_prob = np.zeros(n) found = False for i in range(n): if not adata.expert_fixed[i]: found = True j = adata.taken_items[i] crowd_prob[i] = turk_uncer[j][0] *1.0/ (turk_uncer[j][0] + turk_uncer[j][1]) else: crowd_prob[i] = 100 if not found: return -1 uncertain = np.abs(crowd_prob - 0.5) i = np.argmin(uncertain) #print i, adata.expert_fixed[i] print "most", turk_uncer[adata.taken_items[i]] return adata.query_expert_fix(i)
def _spatial_sort(glyph): from scipy.spatial.distance import cdist from numpy import argsort from numpy import argmin curr = argmin(glyph[:,0]) visited = set([curr]) order = [curr] dd = cdist(glyph, glyph) while len(visited)<len(glyph): row = dd[curr,:] for i in argsort(row): if row[i]<=0.0 or i==curr or i in visited: continue order.append(i) visited.add(i) break glyph[:,:] = glyph[order,:]
def _hpd_interval(self, x, width): """ Code adapted from pymc3.stats.calc_min_interval: https://github.com/pymc-devs/pymc3/blob/master/pymc3/stats.py """ x = np.sort(x) n = len(x) interval_idx_inc = int(np.floor(width * n)) n_intervals = n - interval_idx_inc interval_width = x[interval_idx_inc:] - x[:n_intervals] if len(interval_width) == 0: raise ValueError('Too few elements for interval calculation') min_idx = np.argmin(interval_width) hdi_min = x[min_idx] hdi_max = x[min_idx + interval_idx_inc] index = ['hpd{}_{}'.format(width, x) for x in ['lower', 'upper']] return pd.Series([hdi_min, hdi_max], index=index)
def contest(self, b, g, r): """ Search for biased BGR values Finds closest neuron (min dist) and updates self.freq finds best neuron (min dist-self.bias) and returns position for frequently chosen neurons, self.freq[i] is high and self.bias[i] is negative self.bias[i] = self.GAMMA*((1/self.NETSIZE)-self.freq[i])""" i, j = self.SPECIALS, self.NETSIZE dists = abs(self.network[i:j] - np.array([b, g, r])).sum(1) bestpos = i + np.argmin(dists) biasdists = dists - self.bias[i:j] bestbiaspos = i + np.argmin(biasdists) self.freq[i:j] *= (1 - self.BETA) self.bias[i:j] += self.BETAGAMMA * self.freq[i:j] self.freq[bestpos] += self.BETA self.bias[bestpos] -= self.BETAGAMMA return bestbiaspos
def tune_tal(mono_phi_score, tal_list): errs = [] tals = [] for tal in tal_list: err = [] for i in range(len(mono_phi_score)): mono_1 = numpy.delete(mono_phi_score, i, axis=0) dim_h = mono_phi_score[i][:-1] value_h, alpha = train_predict_regression(mono_1, dim_h, tal) err.append((value_h - mono_phi_score[i][-1])**2) err = numpy.mean(err) errs.append(err) tals.append(tal) print 'regression tal:', tal, 'err', err idx = numpy.argmin(errs) return tals[idx]
def find_min_phase(sdata,a,f,sr,phase): rms1 = 0 rms2 = 0 rms3 = 0 samples = len(sdata) for i in xrange(samples): diff1 = (sdata[i] - a*cos(2*pi*i*f/sr + phase[0])) rms1 += diff1*diff1 diff2 = (sdata[i] - a*cos(2*pi*i*f/sr + phase[1])) rms2 += diff2*diff2 diff3 = (sdata[i] - a*cos(2*pi*i*f/sr + phase[2])) rms3 += diff3*diff3 rms = numpy.zeros(3) rms[0] = rms1 rms[1] = rms2 rms[2] = rms3 i = numpy.argmin(rms) p = phase[i] return i,p
def _center_mahalanobis(self, data): """ Finds a point that is in the center of the data using Mahalanobis distance. Parameters ---------- data: input data as numpy array Returns ------- mean: numpy array """ distances = cdist(data, data, metric='mahalanobis', VI=self._inv_covar_matrices) sum_distances = np.sum(distances, axis=0) center_idx = np.argmin(sum_distances) return data[center_idx]
def find_stable_a(self, A, cond_h, cond_s): # build the different combinations of # condition equations condeq = [] if cond_h.size > 0: condeq.append(cond_h) condeq.append(cond_s) if cond_h.size > 0: condeq.append(numpy.row_stack((cond_s,cond_h))) condnum = [] condnum.append(numpy.linalg.cond(A)) for cond in condeq: condnum.append(numpy.linalg.cond(numpy.row_stack((A,cond)))) i = numpy.argmin(numpy.array(condnum)) if i == 0: return numpy.array([]) else: return condeq[i-1]
def nearest_cell(self, x, y, bbox=None, shape=None): """ Returns the index of the cell (column, row) closest to a given geographical coordinate. Parameters ---------- x : int or float x coordinate. y : int or float y coordinate. """ if not bbox: bbox = self._bbox if not shape: shape = self.shape # Note: this speedup assumes grid cells are square y_ix, x_ix = self.bbox_indices(self._bbox, self.shape) y_ix += self.cellsize / 2.0 x_ix += self.cellsize / 2.0 desired_y = np.argmin(np.abs(y_ix - y)) desired_x = np.argmin(np.abs(x_ix - x)) return desired_x, desired_y
def autoencoder(args, model): latent_dim = args.latent_dim structures = read_smiles_data(args.data) datobj = SmilesDataGenerator(structures, 120) train_gen = datobj.generator(1) if os.path.isfile(args.model): model.load(datobj.chars, args.model, latent_rep_size = latent_dim) else: raise ValueError("Model file %s doesn't exist" % args.model) true_pred_gen = (((mat, weight, model.autoencoder.predict(mat)) for (mat, _, weight) in train_gen)) text_gen = ((str.join('\n', [str((datobj.table.decode(true_mat[vec_ix])[:np.argmin(weight[vec_ix])], datobj.table.decode(vec)[:])) for (vec_ix, vec) in enumerate(pred_mat)])) for (true_mat, weight, pred_mat) in true_pred_gen) for _ in range(args.sample): print(text_gen.next())
def test_output_shape(self): # see also gh-616 a = np.ones((10, 5)) # Check some simple shape mismatches out = np.ones(11, dtype=np.int_) assert_raises(ValueError, a.argmin, -1, out) out = np.ones((2, 5), dtype=np.int_) assert_raises(ValueError, a.argmin, -1, out) # these could be relaxed possibly (used to allow even the previous) out = np.ones((1, 10), dtype=np.int_) assert_raises(ValueError, a.argmin, -1, out) out = np.ones(10, dtype=np.int_) a.argmin(-1, out=out) assert_equal(out, a.argmin(-1))
def get_closest_k(kpoint, ref_ks, return_diff=False): """ returns the list of difference between kpoints. If return_diff True, then for a given kpoint the minimum distance among distances with ref_ks is returned or just the reference kpoint that results if not return_diff Args: kpoint (1x3 array): the coordinates of the input k-point ref_ks ([1x3 array]): list of reference k-points from which the distance with initial_ks are calculated return_diff (bool): if True, the minimum distance is returned Returns (1x3 array): """ min_dist_ik = np.array([norm(ki - kpoint) for ki in ref_ks]).argmin() if return_diff: return kpoint - ref_ks[min_dist_ik] else: return ref_ks[min_dist_ik]
def mergeLocation(tx0, sp0, tx1, sp1): """ find merge location in (tx0,sp0) """ if len(tx0) < 2: return 9999 txmin=min( np.array(tx0)[:,1] ) # minimal line heigh, used as detection threshold txx=[] for i in range(min(len(tx0)-1,len(tx1))): tx=tx0[i][1] + sp0[i][1] + tx0[i+1][1] txx.append(tx - tx1[i][1]) cc = np.argmin(txx) if txx[cc] < txmin/3: #expected to be near 0 return cc else: return 9999
def _fit(self, dataset): est = self.getOrDefault(self.estimator) epm = self.getOrDefault(self.estimatorParamMaps) numModels = len(epm) eva = self.getOrDefault(self.evaluator) tRatio = self.getOrDefault(self.trainRatio) seed = self.getOrDefault(self.seed) randCol = self.uid + "_rand" df = dataset.select("*", rand(seed).alias(randCol)) metrics = [0.0] * numModels condition = (df[randCol] >= tRatio) validation = df.filter(condition) train = df.filter(~condition) for j in range(numModels): model = est.fit(train, epm[j]) metric = eva.evaluate(model.transform(validation, epm[j])) metrics[j] += metric if eva.isLargerBetter(): bestIndex = np.argmax(metrics) else: bestIndex = np.argmin(metrics) bestModel = est.fit(dataset, epm[bestIndex]) return self._copyValues(TrainValidationSplitModel(bestModel, metrics))
def contour_to_monitor_coords(screenCnt): '''Apply pyimagesearch algorithm to identify tl,tr,br,bl points from a contour''' # now that we have our screen contour, we need to determine # the top-left, top-right, bottom-right, and bottom-left # points so that we can later warp the image -- we'll start # by reshaping our contour to be our finals and initializing # our output rectangle in top-left, top-right, bottom-right, # and bottom-left order pts = screenCnt.reshape(4, 2) rect = np.zeros((4, 2), dtype = "float32") # the top-left point has the smallest sum whereas the # bottom-right has the largest sum s = pts.sum(axis = 1) rect[0] = pts[np.argmin(s)] rect[2] = pts[np.argmax(s)] # compute the difference between the points -- the top-right # will have the minumum difference and the bottom-left will # have the maximum difference diff = np.diff(pts, axis = 1) rect[1] = pts[np.argmin(diff)] rect[3] = pts[np.argmax(diff)] return rect
def _get_relative_note_occurences(note_models, pitch_distribution): max_rel_occur = 0 for note_symbol, note in iteritems(note_models): try: # get the relative occurrence of each note from the pitch # distribution dists = np.array([abs(note['stable_pitch']['value'] - dist_bin) for dist_bin in pitch_distribution.bins]) except TypeError: logging.info(u'The stable pitch for {0:s} is not computed' .format(note_symbol)) # use the max peak even if it's weak, far from theoretical etc. peak_idx, heights = note['distribution'].detect_peaks() max_peak_ind = peak_idx[np.argmax(heights)] max_bin = note['distribution'].bins[max_peak_ind] dists = np.array([abs(max_bin - dist_bin) for dist_bin in pitch_distribution.bins]) peak_ind = np.argmin(dists) note['rel_occur'] = pitch_distribution.vals[peak_ind] max_rel_occur = max([max_rel_occur, note['rel_occur']]) return max_rel_occur
def _evalAndDer(self,x): ''' Returns the level and first derivative of the function at each value in x. Only called internally by HARKinterpolator1D.eval_and_der. ''' m = len(x) fx = np.zeros((m,self.funcCount)) for j in range(self.funcCount): fx[:,j] = self.functions[j](x) fx[np.isnan(fx)] = np.inf i = np.argmin(fx,axis=1) y = fx[np.arange(m),i] dydx = np.zeros_like(y) for j in range(self.funcCount): c = i == j dydx[c] = self.functions[j].derivative(x[c]) return y,dydx
def _derX(self,x,y): ''' Returns the first derivative of the function with respect to X at each value in (x,y). Only called internally by HARKinterpolator2D._derX. ''' m = len(x) temp = np.zeros((m,self.funcCount)) for j in range(self.funcCount): temp[:,j] = self.functions[j](x,y) temp[np.isnan(temp)] = np.inf i = np.argmin(temp,axis=1) dfdx = np.zeros_like(x) for j in range(self.funcCount): c = i == j dfdx[c] = self.functions[j].derivativeX(x[c],y[c]) return dfdx
def _derY(self,x,y): ''' Returns the first derivative of the function with respect to Y at each value in (x,y). Only called internally by HARKinterpolator2D._derY. ''' m = len(x) temp = np.zeros((m,self.funcCount)) for j in range(self.funcCount): temp[:,j] = self.functions[j](x,y) temp[np.isnan(temp)] = np.inf i = np.argmin(temp,axis=1) y = temp[np.arange(m),i] dfdy = np.zeros_like(x) for j in range(self.funcCount): c = i == j dfdy[c] = self.functions[j].derivativeY(x[c],y[c]) return dfdy
def _derX(self,x,y,z): ''' Returns the first derivative of the function with respect to X at each value in (x,y,z). Only called internally by HARKinterpolator3D._derX. ''' m = len(x) temp = np.zeros((m,self.funcCount)) for j in range(self.funcCount): temp[:,j] = self.functions[j](x,y,z) temp[np.isnan(temp)] = np.inf i = np.argmin(temp,axis=1) dfdx = np.zeros_like(x) for j in range(self.funcCount): c = i == j dfdx[c] = self.functions[j].derivativeX(x[c],y[c],z[c]) return dfdx
def _derY(self,x,y,z): ''' Returns the first derivative of the function with respect to Y at each value in (x,y,z). Only called internally by HARKinterpolator3D._derY. ''' m = len(x) temp = np.zeros((m,self.funcCount)) for j in range(self.funcCount): temp[:,j] = self.functions[j](x,y,z) temp[np.isnan(temp)] = np.inf i = np.argmin(temp,axis=1) y = temp[np.arange(m),i] dfdy = np.zeros_like(x) for j in range(self.funcCount): c = i == j dfdy[c] = self.functions[j].derivativeY(x[c],y[c],z[c]) return dfdy
def test_summary_max_shortest_2(self): c = ChainConsumer() c.add_chain(self.data_skew) summary_area = 0.6827 c.configure(statistics="max_shortest", bins=1.0, summary_area=summary_area) summary = c.analysis.get_summary()['0'] xs = np.linspace(-1, 5, 1000) pdf = skewnorm.pdf(xs, 5, 1, 1.5) cdf = skewnorm.cdf(xs, 5, 1, 1.5) x2 = interp1d(cdf, xs, bounds_error=False, fill_value=np.inf)(cdf + summary_area) dist = x2 - xs ind = np.argmin(dist) x0 = xs[ind] x2 = x2[ind] xmax = xs[pdf.argmax()] assert np.isclose(xmax, summary[1], atol=0.05) assert np.isclose(x0, summary[0], atol=0.05) assert np.isclose(x2, summary[2], atol=0.05)
def test_summary_max_shortest_3(self): c = ChainConsumer() c.add_chain(self.data_skew) summary_area = 0.95 c.configure(statistics="max_shortest", bins=1.0, summary_area=summary_area) summary = c.analysis.get_summary()['0'] xs = np.linspace(-1, 5, 1000) pdf = skewnorm.pdf(xs, 5, 1, 1.5) cdf = skewnorm.cdf(xs, 5, 1, 1.5) x2 = interp1d(cdf, xs, bounds_error=False, fill_value=np.inf)(cdf + summary_area) dist = x2 - xs ind = np.argmin(dist) x0 = xs[ind] x2 = x2[ind] xmax = xs[pdf.argmax()] assert np.isclose(xmax, summary[1], atol=0.05) assert np.isclose(x0, summary[0], atol=0.05) assert np.isclose(x2, summary[2], atol=0.05)
def find_closest(t, v, t0, v0): """ Find the closest point on the curve f = a + b/x to the given point (t,v) """ a = v0 b = v0*t0 # Solve for intersection points eqn_coefs = [1/b, -t/b, 0, v-a, -b] tis = np.roots(eqn_coefs) tis = tis[abs(tis.imag/tis.real)<0.01].real # We care only real solutions tis = tis[tis>0] # and positive ones # Choose the shortest among solutions ds = abs(tis-t)*np.sqrt(1 + np.power(tis,4)/(b*b)) # Distance from solutions to given point (t,v) idx = np.argmin(ds) ti = tis[idx] vi = a + b/ti return ti, vi
def find_null_offset(xpts, powers, default=0.0): """Finds the offset corresponding to the minimum power using a fit to the measured data""" def model(x, a, b, c): return a*(x - b)**2 + c powers = np.power(10, powers/10.) min_idx = np.argmin(powers) try: fit = curve_fit(model, xpts, powers, p0=[1, xpts[min_idx], powers[min_idx]]) except RuntimeError: logger.warning("Mixer null offset fit failed.") return default, np.zeros(len(powers)) best_offset = np.real(fit[0][1]) best_offset = np.minimum(best_offset, xpts[-1]) best_offset = np.maximum(best_offset, xpts[0]) xpts_fine = np.linspace(xpts[0],xpts[-1],101) fit_pts = np.array([np.real(model(x, *fit[0])) for x in xpts_fine]) if min(fit_pts)<0: fit_pts-=min(fit_pts)-1e-10 #prevent log of a negative number return best_offset, xpts_fine, 10*np.log10(fit_pts)
def test_reduce_argmin(): def argmin(ndarray, axis, keepdims=False): res = np.argmin(ndarray, axis=axis) if keepdims: res = np.expand_dims(res, axis=axis) return res data = np.array([[[5, 1], [20, 2]], [[30, 1], [40, 2]], [[55, 1], [60, 2]]], dtype=np.float32) assert np.array_equal(import_and_compute('ArgMin', data, axis=0), argmin(data, keepdims=True, axis=0)) assert np.array_equal(import_and_compute('ArgMin', data, axis=0, keepdims=0), argmin(data, keepdims=False, axis=0)) assert np.array_equal(import_and_compute('ArgMin', data, axis=1), argmin(data, keepdims=True, axis=1)) assert np.array_equal(import_and_compute('ArgMin', data, axis=1, keepdims=0), argmin(data, keepdims=False, axis=1)) assert np.array_equal(import_and_compute('ArgMin', data, axis=2), argmin(data, keepdims=True, axis=2)) assert np.array_equal(import_and_compute('ArgMin', data, axis=2, keepdims=0), argmin(data, keepdims=False, axis=2))
def logistic_var(): """ Finds a variance to match probit and logistic regression. Finds a variance :math:`\\tau_w` such that, :math:`p=P(W < z) \\approx \\frac{1}{1+e^{-z}},` where :math:`W \\sim {\\mathcal N}(0,\\tau_w)`. """ z = np.linspace(-5,5,1000) # z points to test p1 = 1/(1+np.exp(-z)) # target probability var_test = np.linspace(2,3,1000) err = [] for v in var_test: p2 = 0.5*(1+scipy.special.erf(z/np.sqrt(v*2))) err.append(np.mean((p1-p2)**2)) i = np.argmin(err) wvar = var_test[i] return wvar
def NLS_annealing(F, xi, yi, p, N=100, n=10, sigma=5.,factor=0.5): # N = size of population in one iteration # n = number of iterations # sigma = initial (multiplicative) standard deviation # factor = factor to reduce sigma per iteration print "initial", p p = np.atleast_1d(p) dim = len(p) # make initial sigma act like multiplication by sigma^(+-1) sigma = np.log(sigma)*np.ones(dim) for k in range(n): # create new population by adding multiplicative gaussian noise P = p[None, :] * np.exp(np.random.randn(N, dim) * sigma[None, :]) # compute mean square loss on population f = np.mean((F(xi[None, :], P) - yi)**2, 1) # replace p by new best guess p = P[np.argmin(f), :] # update sigma sigma *= factor print "parameters:", p print "minimum", min(f) return tuple(p)
def furthest_point_sample(vertices, faces, N, K): num_vertices = vertices.shape[0] center_indices = np.random.choice(num_vertices, N, replace=False) sqr_dists = 1e10 * np.ones(num_vertices) vertex_as = np.zeros(num_vertices, dtype=np.int32) for i in range(N): new_sqr_dists = np.sum(np.square(vertices - vertices[center_indices[i]]), 1) update_mask = new_sqr_dists < sqr_dists sqr_dists[update_mask] = new_sqr_dists[update_mask] vertex_as[update_mask] = i next_center = np.argmax(sqr_dists) if K - 1 <= i < N - 1: center_indices[i + 1] = next_center centers = vertices[center_indices] face_centers = np.mean(vertices[faces], 1) sqr_dists = sqr_dist(centers, face_centers) face_as = np.argmin(sqr_dists, 1) return center_indices, vertex_as, face_as
def createLists(dbFilename): print('Splitting RIRs into sets...') sets = [ RirSet('train', 0.8), RirSet('test', 0.1), RirSet('dev', 0.1), ] # open database rirDb = json.load(open(dbFilename)) rirs = sorted(list(rirDb.keys())) # to distribute the RIRs to the set we could to a shuffle, but as they are in alphabetical order and just going over them guaranties that we distribute the different conditions (mostly) equally on the different sets sets[0].add(rirs[0]) for i in range(1, len(rirs)): si = np.argmin([s.missing(i) for s in sets]) sets[si].add(rirs[i]) # safe set files util.createDirectory(ListDir) for s in sets: s.save(ListDir)
def lat_lng_to_usaf_station(lat, lng): """Return the closest USAF station ID using latitude and longitude coordinates. Parameters ---------- lat : float Latitude coordinate. lng : float Longitude coordinate. Returns ------- station : str, None String representing a USAF weather station ID or None, if none was found. """ if lat is None or lng is None: return None usaf_station_to_lat_lng_index = _load_usaf_station_to_lat_lng_index() index_list = list(usaf_station_to_lat_lng_index.items()) dists = [haversine(lat, lng, stat_lat, stat_lng) for _, (stat_lat, stat_lng) in index_list] return index_list[np.argmin(dists)][0]
def lat_lng_to_tmy3_station(lat, lng): """Return the closest TMY3 station ID using latitude and longitude coordinates. Parameters ---------- lat : float Latitude coordinate. lng : float Longitude coordinate. Returns ------- station : str, None String representing a TMY3 weather station ID or None, if none was found. """ if lat is None or lng is None: return None tmy3_station_to_lat_lng_index = _load_tmy3_station_to_lat_lng_index() index_list = list(tmy3_station_to_lat_lng_index.items()) dists = [haversine(lat, lng, stat_lat, stat_lng) for _, (stat_lat, stat_lng) in index_list] return index_list[np.argmin(dists)][0]
def lat_lng_to_zipcode(lat, lng): """Return the closest ZIP code using latitude and longitude coordinates. Parameters ---------- lat : float Latitude coordinate. lng : float Longitude coordinate. Returns ------- zipcode : str, None String representing a USPS ZIP code, or None, if none was found. """ if lat is None or lng is None: return None zipcode_to_lat_lng_index = _load_zipcode_to_lat_lng_index() index_list = list(zipcode_to_lat_lng_index.items()) dists = [haversine(lat, lng, zip_lat, zip_lng) for _, (zip_lat, zip_lng) in index_list] return index_list[np.argmin(dists)][0]
