我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用numpy.nonzero()。
def generate_patch_probs(path, patch_locations, patch_size, im_size): x, y, z = patch_locations seg = nib.load(glob.glob(os.path.join(path, '*_seg.nii.gz'))[0]).get_data().astype(np.float32) p = [] for i in range(len(x)): for j in range(len(y)): for k in range(len(z)): patch = seg[int(x[i] - patch_size / 2) : int(x[i] + patch_size / 2), int(y[j] - patch_size / 2) : int(y[j] + patch_size / 2), int(z[k] - patch_size / 2) : int(z[k] + patch_size / 2)] patch = (patch > 0).astype(np.float32) percent = np.sum(patch) / (patch_size * patch_size * patch_size) p.append((1 - np.abs(percent - 0.5)) * percent) p = np.asarray(p, dtype=np.float32) p[p == 0] = np.amin(p[np.nonzero(p)]) p = p / np.sum(p) return p
def callback_rect(self, eclick, erelease): xmin, xmax, ymin, ymax = eclick.xdata, erelease.xdata, eclick.ydata, erelease.ydata if xmin > xmax: xmin, xmax = xmax, xmin if ymin > ymax: ymin, ymax = ymax, ymin x, y = self.x_position, self.y_position in_selection = ((x >= xmin) & (x <= xmax) & (y >= ymin) & (y <= ymax)) indices = np.nonzero(in_selection)[0] add_or_remove = None if erelease.key == 'shift': add_or_remove = 'add' elif erelease.key == 'control': add_or_remove = 'remove' self.update_inspect(indices, add_or_remove)
def get_bc_counts(genomes, genes, molecule_counter): genome_ids = molecule_counter.get_column('genome') genome_index = cr_reference.get_genome_index(genomes) conf_mapped_reads = molecule_counter.get_column('reads') barcodes = molecule_counter.get_column('barcode') bc_counts = {} for genome in genomes: genome_id = cr_reference.get_genome_id(genome, genome_index) genome_indices = genome_ids == genome_id if genome_indices.sum() == 0: # edge case - there's no data for this genome (e.g. empty sample, false barnyard sample, or nothing confidently mapped) continue bcs_for_genome = barcodes[genome_indices] # only count UMIs with at least one conf mapped read umi_conf_mapped_to_genome = conf_mapped_reads[genome_indices] > 0 bc_breaks = bcs_for_genome[1:] - bcs_for_genome[:-1] bc_breaks = np.concatenate(([1], bc_breaks)) # first row is always a break bc_break_indices = np.nonzero(bc_breaks)[0] unique_bcs = bcs_for_genome[bc_break_indices] umis_per_bc = np.add.reduceat(umi_conf_mapped_to_genome, bc_break_indices) cmb_reads_per_bc = np.add.reduceat(conf_mapped_reads[genome_indices], bc_break_indices) bc_counts[genome] = (unique_bcs, umis_per_bc, cmb_reads_per_bc) return bc_counts
def primes_2_to_n(n): """ Efficient algorithm to find and list primes from 2 to `n'. Args: n (int): highest number from which to search for primes Returns: np array of all primes from 2 to n References: Robert William Hanks, https://stackoverflow.com/questions/2068372/fastest-way-to-list-all-primes-below-n/ """ sieve = np.ones(int(n / 3 + (n % 6 == 2)), dtype=np.bool) for i in range(1, int((n ** 0.5) / 3 + 1)): if sieve[i]: k = 3 * i + 1 | 1 sieve[int(k * k / 3)::2 * k] = False sieve[int(k * (k - 2 * (i & 1) + 4) / 3)::2 * k] = False return np.r_[2, 3, ((3 * np.nonzero(sieve)[0][1:] + 1) | 1)]
def top_uncer_items(adata, pp, n, flag = None): """ Return top a flag list of top n uncertain item that not flag """ uncertain = np.abs(pp[:,0] - 0.5) if flag != None: addition = np.asarray(flag, dtype = int)*10# flagged items are not consider, increase their value uncertain = uncertain + addition if len(uncertain) <= n: return np.nonzero(uncertain <= 10000000)[0] sorted_uncertain = np.sort(uncertain) thresh = sorted_uncertain[n] return np.nonzero(uncertain <= thresh)[0]
def items_for_expert(adata, pp, n, flag): """ take n items for expert to consider """ combined_prob = 0.8*np.asarray(adata.taken_crowd_prob) + 0.2*pp[:,1] uncertain = np.abs(combined_prob - 0.5) if flag != None: addition = np.asarray(flag, dtype = int)*10# flagged items are not consider, increase their value uncertain = uncertain + addition if len(uncertain) <= n: return np.nonzero(uncertain <= 10000000)[0] sorted_uncertain = np.sort(uncertain) thresh = sorted_uncertain[n] return np.nonzero(uncertain <= thresh)[0]
def balance_dataset(dataset_0, labels_0, dataset_1, labels_1, ratio=1): """Balance the dataset_0 with samples from dataset_1 up to given ratio. Args: dataset_0: array of text samples labels_0: array of labels for dataset_0 dataset_1: array of text samples labels_1: array of labels for dataset_1 ratio: ratio of samples of class 1 to samples of class 0 (default 1.0) Returns: balanced array of text samples, corresponding array of labels """ initial_train_size = dataset_0.shape[0] insult_inds = np.nonzero(labels_1)[0] num_insults_0 = len(np.nonzero(labels_0)[0]) num_insults_1 = len(np.nonzero(labels_1)[0]) insult_inds_to_add = insult_inds[np.random.randint(low=0, high=num_insults_1, size=(ratio * (initial_train_size - num_insults_0) - num_insults_0))] result = dataset_0.append(dataset_1.iloc[insult_inds_to_add]) result_labels = labels_0.append(labels_1.iloc[insult_inds_to_add]) return result, result_labels
def retrieve_features(best_estimator): """Retrieve selected features from any estimator. In case it has the 'get_support' method, use it. Else, if it has a 'coef_' attribute, assume it's a linear model and the features correspond to the indices of the coefficients != 0 """ if hasattr(best_estimator, 'get_support'): return np.nonzero(best_estimator.get_support())[0] elif hasattr(best_estimator, 'coef_'): # print best_estimator.coef_ if best_estimator.coef_.ndim > 1 and 1 not in best_estimator.coef_.shape: sel_feats = [] for dim in range(best_estimator.coef_.ndim): sel_feats += np.nonzero( best_estimator.coef_[dim])[0].ravel().tolist() return np.unique(sel_feats) return np.nonzero(best_estimator.coef_.flatten())[0] else: # Raise an error raise AttributeError('The best_estimator object does not have ' 'neither the `coef_` attribute nor the ' '`get_support` method')
def _get_missing_m_trend(self, pad='DEFAULT_PAD', **kwargs): """Get a single second of missing data.""" logging.debug('Fetching missing m-trend: {}'.format(self)) missing_buf = self.fetch() # explicitly fetch from NDS2 trend = self.channel.split('.')[1].split(',')[0] # make m-trend value for this minute based on trend extension if len(np.nonzero(missing_buf == -1)[0]) != 0: # this won't actually check for anything at the moment because # gwpy.timeseries.TimeSeries.fetch() does not have a padding option # yet logging.warn('Still missing data in {}'.format(self)) elif trend == 'mean': buf_trend = missing_buf.mean() elif trend == 'min': buf_trend = missing_buf.min() elif trend == 'max': buf_trend = missing_buf.max() elif trend == 'rms': buf_trend = missing_buf.rms(60)[0] elif trend == 'n': buf_trend = missing_buf.sum() else: raise ValueError('Unrecognized trend type: {}'.format(trend)) return buf_trend
def plot_timeseries(self, ax, **kwargs): """Scale up by 10^9 since plots are in ns, not seconds. Remove any indices considered bad in ``plot_properties``""" # define the variables for our plots y = np.delete(self.plot_vars.means - self.trend, self.bad_indices.means) / SEC_PER['ns'] t = np.delete(self.t_axis, self.bad_indices.means) yerr = np.delete(self.plot_vars.stds, self.bad_indices.means) / SEC_PER['ns'] mint = np.delete(self.t_axis, self.bad_indices.mins) miny = np.delete(self.plot_vars.mins - self.trend, self.bad_indices.mins) / SEC_PER['ns'] maxt = np.delete(self.t_axis, self.bad_indices.maxs) maxy = np.delete(self.plot_vars.maxs - self.trend, self.bad_indices.maxs) / SEC_PER['ns'] # plot everything, but only if the plotted data has nonzero length # in order to avoid an annoying matplotlib bug when adding legends. if len(t) != 0: ax.errorbar(t, y, marker="o", color="green", linestyle='none', yerr=yerr, label="Means +/- Std. Dev.") if len(mint) != 0: ax.scatter(mint, miny, marker="^", color="blue", label="Minima") if len(maxt) != 0: ax.scatter(maxt, maxy, marker="v", color="red", label="Maxima")
def plot_timeseries(self, ax, **kwargs): """Scale up by 10^9 since plots are in ns, not seconds. Remove any indices considered bad in ``plot_properties``""" # define the variables for our plots t = np.delete(self.t_axis, self.bad_indices.means) y = np.delete(self.plot_vars.means - self.trend, self.bad_indices.means) / SEC_PER['ns'] yerr = np.delete(self.plot_vars.stds, self.bad_indices.means) / SEC_PER['ns'] mint = np.delete(self.t_axis, self.bad_indices.absmins) miny = np.delete(self.plot_vars.absmins - self.trend, self.bad_indices.absmins) / SEC_PER['ns'] maxt = np.delete(self.t_axis, self.bad_indices.absmaxs) maxy = np.delete(self.plot_vars.absmaxs - self.trend, self.bad_indices.absmaxs) / SEC_PER['ns'] # plot everything, but only if the plotted data has nonzero length # in order to avoid an annoying matplotlib bug when adding legends. if len(t) != 0: ax.errorbar(t, y, marker="o", color="green", linestyle='none', yerr=yerr, label="Means +/- Std. Dev.") if len(mint) != 0: ax.scatter(mint,miny,marker="^", color="blue", label="Abs. Minima") if len(maxt) != 0: ax.scatter(maxt,maxy,marker="v", color="red", label="Abs. Maxima")
def __act_manual(self, state_meas): if len(self.__measure_for_manual): # [AMMO2, AMMO3, AMMO4, AMMO5, AMMO6, AMMO7, WEAPON2, # WEAPON3 WEAPON4 WEAPON5 WEAPON6 WEAPON7 SELECTED_WEAPON] assert len(self.__measure_for_manual) == 13 # [SELECT_WEAPON2 SELECT_WEAPON3 SELECT_WEAPON4 SELECT_WEAPON5 SELECT_WEAPON6 SELECT_WEAPON7] curr_action = np.zeros((state_meas.shape[0], self.__num_manual_controls), dtype=np.int) for ns in range(state_meas.shape[0]): curr_ammo = state_meas[ns, self.__measure_for_manual[:6]] curr_weapons = state_meas[ns, self.__measure_for_manual[6:12]] if self.verbose: print 'current ammo:', curr_ammo print 'current weapons:', curr_weapons available_weapons = np.logical_and(curr_ammo >= np.array([1, 2, 1, 1, 1, 40]), curr_weapons) if any(available_weapons): best_weapon = np.nonzero(available_weapons)[0][-1] if not state_meas[ns, self.__measure_for_manual[12]] == best_weapon + 2: curr_action[ns, best_weapon] = 1 return curr_action else: return []
def test_bool_flat_indexing_invalid_nr_elements(self, level=rlevel): s = np.ones(10, dtype=float) x = np.array((15,), dtype=float) def ia(x, s, v): x[(s > 0)] = v # After removing deprecation, the following are ValueErrors. # This might seem odd as compared to the value error below. This # is due to the fact that the new code always uses "nonzero" logic # and the boolean special case is not taken. with warnings.catch_warnings(): warnings.simplefilter('ignore', DeprecationWarning) warnings.simplefilter('ignore', np.VisibleDeprecationWarning) self.assertRaises(IndexError, ia, x, s, np.zeros(9, dtype=float)) self.assertRaises(IndexError, ia, x, s, np.zeros(11, dtype=float)) # Old special case (different code path): self.assertRaises(ValueError, ia, x.flat, s, np.zeros(9, dtype=float)) self.assertRaises(ValueError, ia, x.flat, s, np.zeros(11, dtype=float))
def test_nonzero_twodim(self): x = np.array([[0, 1, 0], [2, 0, 3]]) assert_equal(np.count_nonzero(x), 3) assert_equal(np.nonzero(x), ([0, 1, 1], [1, 0, 2])) x = np.eye(3) assert_equal(np.count_nonzero(x), 3) assert_equal(np.nonzero(x), ([0, 1, 2], [0, 1, 2])) x = np.array([[(0, 1), (0, 0), (1, 11)], [(1, 1), (1, 0), (0, 0)], [(0, 0), (1, 5), (0, 1)]], dtype=[('a', 'f4'), ('b', 'u1')]) assert_equal(np.count_nonzero(x['a']), 4) assert_equal(np.count_nonzero(x['b']), 5) assert_equal(np.nonzero(x['a']), ([0, 1, 1, 2], [2, 0, 1, 1])) assert_equal(np.nonzero(x['b']), ([0, 0, 1, 2, 2], [0, 2, 0, 1, 2])) assert_(not x['a'].T.flags.aligned) assert_equal(np.count_nonzero(x['a'].T), 4) assert_equal(np.count_nonzero(x['b'].T), 5) assert_equal(np.nonzero(x['a'].T), ([0, 1, 1, 2], [1, 1, 2, 0])) assert_equal(np.nonzero(x['b'].T), ([0, 0, 1, 2, 2], [0, 1, 2, 0, 2]))
def test_half_ordering(self): """Make sure comparisons are working right""" # All non-NaN float16 values in reverse order a = self.nonan_f16[::-1].copy() # 32-bit float copy b = np.array(a, dtype=float32) # Should sort the same a.sort() b.sort() assert_equal(a, b) # Comparisons should work assert_((a[:-1] <= a[1:]).all()) assert_(not (a[:-1] > a[1:]).any()) assert_((a[1:] >= a[:-1]).all()) assert_(not (a[1:] < a[:-1]).any()) # All != except for +/-0 assert_equal(np.nonzero(a[:-1] < a[1:])[0].size, a.size-2) assert_equal(np.nonzero(a[1:] > a[:-1])[0].size, a.size-2)
def denseToSparseAbvCutoff(self, denseMatrix, cutoff): """ Remove datas in denseMatrix that is below cutoff, Convert the remaining datas into sparse matrix. Parameters: ---------------------- denseMatrix: dense numpy matrix cutoff: int or float Returns ---------------------- Scipy csr_matrix """ maskArray=denseMatrix>=cutoff sparseMatrix=csr_matrix( (np.asarray(denseMatrix[maskArray]).reshape(-1),np.nonzero(maskArray)),\ shape=denseMatrix.shape) return sparseMatrix
def get_starting_location(self): rows_with_points = self.hits.max(axis=1) max_row = np.nonzero(rows_with_points)[0].max() # TODO: if max_row == 215, we should exit row = self.hits[max_row, :] idx = np.nonzero(row)[0] col = np.random.choice(idx) col = np.random.randint(col - 2, col + 2) loc = [min(STATE.layout.rows - 1, max_row + 10), col] assert self.max_row <= max_row self.max_row = max_row return loc #def get_starting_location(self): # rows_with_points = self.hits.max(axis=1) # max_row = np.nonzero(rows_with_points)[0].max() # loc = [min(STATE.layout.rows - 1, max_row + 10), np.random.randint(STATE.layout.columns)] #assert self.max_row <= max_row #self.max_row = max_row #return loc
def bestMap(L1, L2): if L1.__len__() != L2.__len__(): print('size(L1) must == size(L2)') Label1 = np.unique(L1) nClass1 = Label1.__len__() Label2 = np.unique(L2) nClass2 = Label2.__len__() nClass = max(nClass1, nClass2) G = np.zeros((nClass, nClass)) for i in range(nClass1): for j in range(nClass2): G[i][j] = np.nonzero((L1 == Label1[i]) * (L2 == Label2[j]))[0].__len__() c = linear_assignment_.linear_assignment(-G.T)[:, 1] newL2 = np.zeros(L2.__len__()) for i in range(nClass2): for j in np.nonzero(L2 == Label2[i])[0]: if len(Label1) > c[i]: newL2[j] = Label1[c[i]] return accuracy_score(L1, newL2)
def _vlines(lines, ctrs=None, lengths=None, vecs=None, angle_lo=20, angle_hi=160, ransac_options=RANSAC_OPTIONS): ctrs = ctrs if ctrs is not None else lines.mean(1) vecs = vecs if vecs is not None else lines[:, 1, :] - lines[:, 0, :] lengths = lengths if lengths is not None else np.hypot(vecs[:, 0], vecs[:, 1]) angles = np.degrees(np.arccos(vecs[:, 0] / lengths)) points = np.column_stack([ctrs[:, 0], angles]) point_indices, = np.nonzero((angles > angle_lo) & (angles < angle_hi)) points = points[point_indices] if len(points) > 2: model_ransac = linear_model.RANSACRegressor(**ransac_options) model_ransac.fit(points[:, 0].reshape(-1, 1), points[:, 1].reshape(-1, 1)) inlier_mask = model_ransac.inlier_mask_ valid_lines = lines[point_indices[inlier_mask], :, :] else: valid_lines = [] return valid_lines
def _hlines(lines, ctrs=None, lengths=None, vecs=None, angle_lo=20, angle_hi=160, ransac_options=RANSAC_OPTIONS): ctrs = ctrs if ctrs is not None else lines.mean(1) vecs = vecs if vecs is not None else lines[:, 1, :] - lines[:, 0, :] lengths = lengths if lengths is not None else np.hypot(vecs[:, 0], vecs[:, 1]) angles = np.degrees(np.arccos(vecs[:, 1] / lengths)) points = np.column_stack([ctrs[:, 1], angles]) point_indices, = np.nonzero((angles > angle_lo) & (angles < angle_hi)) points = points[point_indices] if len(points) > 2: model_ransac = linear_model.RANSACRegressor(**ransac_options) model_ransac.fit(points[:, 0].reshape(-1, 1), points[:, 1].reshape(-1, 1)) inlier_mask = model_ransac.inlier_mask_ valid_lines = lines[point_indices[inlier_mask], :, :] else: valid_lines = [] return valid_lines
def _tipping_point_update(self, tmp, consump, peak_temp_interval=30.0): """Determine whether a tipping point has occurred, if so reduce consumption for all periods after this date. """ draws = tmp.shape[0] disaster = self._disaster_simulation() disaster_cons = self._disaster_cons_simulation() period_lengths = self.tree.decision_times[1:] - self.tree.decision_times[:-1] tmp_scale = np.maximum(self.peak_temp, tmp) ave_prob_of_survival = 1.0 - np.square(tmp / tmp_scale) prob_of_survival = ave_prob_of_survival**(period_lengths / peak_temp_interval) # this part may be done better, this takes a long time to loop over res = prob_of_survival < disaster rows, cols = np.nonzero(res) row, count = np.unique(rows, return_counts=True) first_occurance = zip(row, cols[np.insert(count.cumsum()[:-1],0,0)]) for pos in first_occurance: consump[pos[0], pos[1]:] *= np.exp(-disaster_cons[pos[0]]) return consump
def contributions(in_length, out_length, scale, kernel, k_width): if scale < 1: h = lambda x: scale * kernel(scale * x) kernel_width = 1.0 * k_width / scale else: h = kernel kernel_width = k_width x = np.arange(1, out_length+1).astype(np.float64) u = x / scale + 0.5 * (1 - 1 / scale) left = np.floor(u - kernel_width / 2) P = int(ceil(kernel_width)) + 2 ind = np.expand_dims(left, axis=1) + np.arange(P) - 1 # -1 because indexing from 0 indices = ind.astype(np.int32) weights = h(np.expand_dims(u, axis=1) - indices - 1) # -1 because indexing from 0 weights = np.divide(weights, np.expand_dims(np.sum(weights, axis=1), axis=1)) aux = np.concatenate((np.arange(in_length), np.arange(in_length - 1, -1, step=-1))).astype(np.int32) indices = aux[np.mod(indices, aux.size)] ind2store = np.nonzero(np.any(weights, axis=0)) weights = weights[:, ind2store] indices = indices[:, ind2store] return weights, indices
def decode(self, sentence, src=True): ''' Given an encoded sentence matrix, return the represented sentence string (tokenized). ''' words = [] for word in sentence: idxs = np.nonzero(word)[0] if len(idxs) > 1: raise Exception("Multiple hot bits on word vec") elif len(idxs) == 0: continue if src: words.append(self.words_src[0][idxs[0]]) else: words.append(self.words_dst[0][idxs[0]]) return ' '.join(words)
def move_ellipses(self, coll, cyl=False): xz = self.x[:, ::2] if not cyl else np.column_stack( [np.sqrt(np.sum(self.x[:, :2]**2, 1)), self.x[:, 2]]) coll.set_offsets(xz) #inside = self.inside_wall() #margin = np.nonzero(self.alive)[0][self.inside_wall(2.)] colors = np.full((self.N,), "b", dtype=str) #colors[margin] = "r" colors[self.success] = "k" colors[self.fail] = "k" colors[self.alive & ~self.can_bind] = "r" #colors = [("r" if inside[i] else "g") if margin[i] else "b" for i in range(self.N)] coll.set_facecolors(colors) #y = self.x[:, 1] #d = 50. #sizes = self.params.rMolecule*(1. + y/d) #coll.set(widths=sizes, heights=sizes)
def set_free(self, uid=None): ''' reset status of occupied points to zero ''' self.read() data = self.data # check for valid id if uid in [0,1]: print "Error: %s is not a valid ID, returning." %uid return None if uid is not None: # get indices of vertices by id vertices = np.nonzero(data["status"] == uid)[0] else: vertices = np.nonzero(np.logical_and(data["status"] != 0, data["status"] != 1))[0] # reset vertices to 0 data["status"][vertices] = 0 self.write()
def _split_data(self): counts = np.zeros(self._num_classes) labeled_indices = list() num_per_class = int(self._num_labels / self._num_classes) for i, l in enumerate(self._labels): index = np.nonzero(l)[0][0] if counts[index] < num_per_class: counts[index] += 1 labeled_indices.append(i) elif counts.sum() == self._num_labels: break else: continue all_indices = set(range(self._num_train_images)) unlabeled_indices = list(all_indices - set(labeled_indices)) images_labeled = self._images[labeled_indices] images_unlabeled = self._images[unlabeled_indices] labels = self._labels[labeled_indices] return images_labeled, images_unlabeled, labels
def jaccard(v1, v2): ''' Due to the idiosyncracies of my code the jaccard index is a bit altered. The theory is the same but the implementation might be a bit weird. I do not have two vectors containing the words of both documents but instead I have two equally sized vectors. The columns of the vectors are the same and represent the words in the whole corpus. If an entry is 1 then the word is present in the document. If it is 0 then it is not present. SO first we find the indices of the words in each documents and then jaccard is calculated based on the indices. ''' indices1 = numpy.nonzero(v1)[0].tolist() indices2 = numpy.nonzero(v2)[0].tolist() inter = len(set(indices1) & set(indices2)) un = len(set(indices1) | set(indices2)) dist = 1 - inter/float(un) return dist
def get_signature_genes(X,n,lda=10): W = np.zeros((X.shape[0],X.shape[0])) # coarse search from the bottom while (abs(W).sum(1) > 0).sum() < n: lda /= 10. model = MultiTaskLasso(alpha=lda,max_iter=100,tol=.001,selection='random',warm_start=True) model.fit(X.T,X.T) W = model.coef_.T #print len(np.nonzero(abs(W).sum(1))[0]),model.score(X.T,X.T) # fine search from the top while (abs(W).sum(1) > 0).sum() > n*1.2: lda *= 2. model.set_params(alpha=lda) model.fit(X.T,X.T) W = model.coef_.T #print len(np.nonzero(abs(W).sum(1))[0]),model.score(X.T,X.T) # finer search while (abs(W).sum(1) > 0).sum() > n: lda *= 1.1 model.set_params(alpha=lda) model.fit(X.T,X.T) W = model.coef_.T #print len(np.nonzero(abs(W).sum(1))[0]),model.score(X.T,X.T) return np.nonzero(abs(W).sum(1))[0]
def rargmax(vector): # random argmax m = np.max(vector) indices = np.nonzero(vector == m)[0] return pr.choice(indices) # Reward Update Q # Algorithm # For each s,a initialize table entry Q(s,a)<-0 # Observe current stat s # Do foever: # select an action a and execute it # receive immediate reward # observe the new state # update the table entry for Q(s,a) # update the state # Non-deterministic environment
def rargmax(vector): # random argmax m = np.max(vector) indices = np.nonzero(vector == m)[0] return pr.choice(indices) # Reward Update Q # Algorithm # For each s,a initialize table entry Q(s,a)<-0 # Observe current stat s # Do foever: # select an action a and execute it # receive immediate reward # observe the new state # update the table entry for Q(s,a) # update the state
def mg(x, xmf, umf=[0, 1, 1, 0]): """Function to compute the membership grades of each x on a T1 FS x: list of x values xmf: x parameters of the membership function umf: u parameters of the membership function """ items = [item for item in sorted(zip(xmf, umf))] xmf = [i[0] for i in items] umf = [i[1] for i in items] u = [None] * len(x) # membership grade of x for i, p in enumerate(x): if p <= xmf[0] or p >= xmf[-1]: u[i] = 0 else: x_mf = np.array(xmf) left = np.nonzero(x_mf < p)[0][-1] right = left + 1 u[i] = umf[left] + (umf[right] - umf[left]) * (p - xmf[left]) / (xmf[right] - xmf[left]) return u
def ber(x, y, m=2): """Measure bit error rate between symbols in x and y. :param x: symbol array #1 :param y: symbol array #2 :param m: symbol alphabet size (maximum 64) :returns: bit error rate >>> import arlpy >>> arlpy.comms.ber([0,1,2,3], [0,1,2,2], m=4) 0.125 """ x = _np.asarray(x, dtype=_np.int) y = _np.asarray(y, dtype=_np.int) if _np.any(x >= m) or _np.any(y >= m) or _np.any(x < 0) or _np.any(y < 0): raise ValueError('Invalid data for specified m') if m == 2: return ser(x, y) if m > _MAX_M: raise ValueError('m > %d not supported' % (_MAX_M)) n = _np.product(_np.shape(x))*_np.log2(m) e = x^y e = e[_np.nonzero(e)] e = _np.sum(_popcount[e]) return float(e)/n
def flip_axes(data, perms, flips): """ Flip a data array along specified axes Parameters ---------- data : 3D array perms : (3,) sequence of ints Axis permutations to perform flips : (3,) sequence of bools Sequence of indicators for whether to flip along each axis Returns ------- 3D array """ data = np.transpose(data, perms) for axis in np.nonzero(flips)[0]: data = nb.orientations.flip_axis(data, axis) return data
def draw_links(self,n=1,log_sampling=False): """ Draw multiple random links. """ urls = [] domain_array = np.array([dmn for dmn in self.domain_links]) domain_count = np.array([len(self.domain_links[domain_array[k]]) for k in range(domain_array.shape[0])]) p = np.array([np.float(c) for c in domain_count]) count_total = p.sum() if log_sampling: # log-sampling [log(x+1)] to bias lower count domains p = np.fromiter((np.log1p(x) for x in p), dtype=p.dtype) if count_total > 0: p = p/p.sum() cnts = npr.multinomial(n, pvals=p) if n > 1: for k in range(cnts.shape[0]): domain = domain_array[k] cnt = min(cnts[k],domain_count[k]) for url in random.sample(self.domain_links[domain],cnt): urls.append(url) else: k = int(np.nonzero(cnts)[0]) domain = domain_array[k] url = random.sample(self.domain_links[domain],1)[0] urls.append(url) return urls
def _get_features(self, item, user_id): '''Change a tuple (item_id, rating) into a list of features to feed into the RNN features have the following structure: [one_hot_encoding, personal_rating on a scale of ten, average_rating on a scale of ten, popularity on a log scale of ten] ''' item_id, rating = item if self.use_movies_features: one_hot_encoding = np.zeros(self.n_items) one_hot_encoding[item_id] = 1 return np.concatenate((one_hot_encoding, self._get_optional_features(item, user_id))) else: one_hot_encoding = [item_id] optional_features = self._get_optional_features(item, user_id) optional_features_ids = np.nonzero(optional_features)[0] return np.concatenate((one_hot_encoding, optional_features_ids + self.n_items))
def _sample_discrete_actions(batch_probs): """Sample a batch of actions from a batch of action probabilities. Args: batch_probs (ndarray): batch of action probabilities BxA Returns: List consisting of sampled actions """ action_indices = [] # Subtract a tiny value from probabilities in order to avoid # "ValueError: sum(pvals[:-1]) > 1.0" in numpy.multinomial batch_probs = batch_probs - np.finfo(np.float32).epsneg for i in range(batch_probs.shape[0]): histogram = np.random.multinomial(1, batch_probs[i]) action_indices.append(int(np.nonzero(histogram)[0])) return action_indices
def get_major_minor_axis(img): """ Finds the major and minor axis as 3d vectors of the passed in image :param img: CZYX numpy array :return: tuple containing two numpy arrays representing the major and minor axis as 3d vectors """ # do a mean projection if more than 3 axes if img.ndim > 3: z, y, x = np.nonzero(np.mean(img, axis=tuple(range(img.ndim - 3)))) else: z, y, x = np.nonzero(img) coords = np.stack([x - np.mean(x), y - np.mean(y), z - np.mean(z)]) # eigenvectors and values of the covariance matrix evals, evecs = np.linalg.eig(np.cov(coords)) # return largest and smallest eigenvectors (major and minor axis) order = np.argsort(evals) return (evecs[:, order[-1]], evecs[:, order[0]])
def multilabel_to_multiclass (array): array = binarization (array) return np.array([np.nonzero(array[i,:])[0][0] for i in range (len(array))])
def tp_filter(X, Y, feat_num=1000, verbose=True): ''' TP feature selection in the spirit of the winners of the KDD cup 2001 Only for binary classification and sparse matrices''' if issparse(X) and len(Y.shape)==1 and len(set(Y))==2 and (sum(Y)/Y.shape[0])<0.1: if verbose: print("========= Filtering features...") Posidx=Y>0 #npos = sum(Posidx) #Negidx=Y<=0 #nneg = sum(Negidx) nz=X.nonzero() mx=X[nz].max() if X[nz].min()==mx: # sparse binary if mx!=1: X[nz]=1 tp=csr_matrix.sum(X[Posidx,:], axis=0) #fn=npos-tp #fp=csr_matrix.sum(X[Negidx,:], axis=0) #tn=nneg-fp else: tp=np.sum(X[Posidx,:]>0, axis=0) #tn=np.sum(X[Negidx,:]<=0, axis=0) #fn=np.sum(X[Posidx,:]<=0, axis=0) #fp=np.sum(X[Negidx,:]>0, axis=0) tp=np.ravel(tp) idx=sorted(range(len(tp)), key=tp.__getitem__, reverse=True) return idx[0:feat_num] else: feat_num = X.shape[1] return range(feat_num)
def callback_lasso(self, verts): p = mpl.path.Path(verts) in_selection = p.contains_points(self.lasso_selector.points) indices = np.nonzero(in_selection)[0] if len(self.lasso_selector.points) != len(self.points[1]): self.update_inspect(indices, self.lasso_selector.add_or_remove) else: self.update_inspect_template(indices, self.lasso_selector.add_or_remove)
def callback_rect(self, eclick, erelease): xmin, xmax, ymin, ymax = eclick.xdata, erelease.xdata, eclick.ydata, erelease.ydata if xmin > xmax: xmin, xmax = xmax, xmin if ymin > ymax: ymin, ymax = ymax, ymin self.score_ax = eclick.inaxes if self.score_ax == self.score_ax1: score_x, score_y = self.score_x, self.score_y elif self.score_ax == self.score_ax2: score_x, score_y = self.norms[self.to_consider], self.rates[self.to_consider] elif self.score_ax == self.score_ax3: score_x, score_y = self.score_z, self.score_y in_selection = ((score_x >= xmin) & (score_x <= xmax) & (score_y >= ymin) & (score_y <= ymax)) indices = np.nonzero(in_selection)[0] add_or_remove = None if erelease.key == 'shift': add_or_remove = 'add' elif erelease.key == 'control': add_or_remove = 'remove' if self.score_ax != self.score_ax2: self.update_inspect(indices, add_or_remove) else: self.update_inspect_template(indices, add_or_remove)
def callback_lasso(self, verts): p = mpl.path.Path(verts) in_selection = p.contains_points(self.lasso_selector.points) indices = np.nonzero(in_selection)[0] self.update_inspect(indices, self.lasso_selector.add_or_remove)
def filter_prediction(self, boxes, probs, cls_idx): """Filter bounding box predictions with probability threshold and non-maximum supression. Args: boxes: array of [cx, cy, w, h]. probs: array of probabilities cls_idx: array of class indices Returns: final_boxes: array of filtered bounding boxes. final_probs: array of filtered probabilities final_cls_idx: array of filtered class indices """ mc = self.mc if mc.TOP_N_DETECTION < len(probs) and mc.TOP_N_DETECTION > 0: order = probs.argsort()[:-mc.TOP_N_DETECTION-1:-1] probs = probs[order] boxes = boxes[order] cls_idx = cls_idx[order] else: filtered_idx = np.nonzero(probs>mc.PROB_THRESH)[0] probs = probs[filtered_idx] boxes = boxes[filtered_idx] cls_idx = cls_idx[filtered_idx] final_boxes = [] final_probs = [] final_cls_idx = [] for c in range(mc.CLASSES): idx_per_class = [i for i in range(len(probs)) if cls_idx[i] == c] keep = util.nms(boxes[idx_per_class], probs[idx_per_class], mc.NMS_THRESH) for i in range(len(keep)): if keep[i]: final_boxes.append(boxes[idx_per_class[i]]) final_probs.append(probs[idx_per_class[i]]) final_cls_idx.append(c) return final_boxes, final_probs, final_cls_idx
def write_to_record(id_batch, label_batch, predictions, filenum, num_examples_processed): writer = tf.python_io.TFRecordWriter(FLAGS.output_dir + '/' + 'predictions-%03d.tfrecord' % filenum) for i in range(num_examples_processed): video_id = id_batch[i] label = np.nonzero(label_batch[i,:])[0] example = get_output_feature(video_id, label, [predictions[i,:]], ['predictions']) serialized = example.SerializeToString() writer.write(serialized) writer.close()
def write_to_record(id_batch, label_batch, input_batch, predictions, filenum, num_examples_processed): writer = tf.python_io.TFRecordWriter(FLAGS.output_dir + '/' + 'predictions-%03d.tfrecord' % filenum) for i in range(num_examples_processed): video_id = id_batch[i] label = np.nonzero(label_batch[i,:])[0] example = get_output_feature(video_id, label, [predictions[i,:]], ['predictions']) serialized = example.SerializeToString() writer.write(serialized) writer.close()
def write_to_record(id_batch, label_batch, predictions, filenum, num_examples_processed): writer = tf.python_io.TFRecordWriter(FLAGS.output_dir + '/' + 'predictions-%04d.tfrecord' % filenum) for i in range(num_examples_processed): video_id = id_batch[i] label = np.nonzero(label_batch[i,:])[0] example = get_output_feature(video_id, label, [predictions[i,:]], ['predictions']) serialized = example.SerializeToString() writer.write(serialized) writer.close()
def write_to_record(id_batch, label_batch, input_batch, filenum, num_examples_processed): writer = tf.python_io.TFRecordWriter(FLAGS.output_dir + '/' + 'predictions-%04d.tfrecord' % filenum) for i in range(num_examples_processed): video_id = id_batch[i] label = np.nonzero(label_batch[i,:])[0] example = get_output_feature(video_id, label, [input_batch[i,:]], ['input']) serialized = example.SerializeToString() writer.write(serialized) writer.close()
