我们从Python开源项目中，提取了以下19个代码示例，用于说明如何使用numpy.extract()。
def seperateDataX(self, breaks, x): # a function that seperates the data based on the breaks for given x numberOfParameters = len(breaks) numberOfSegments = numberOfParameters - 1 self.numberOfParameters = numberOfParameters self.numberOfSegments = numberOfSegments # Seperate Data into Segments sepDataX = [[] for i in range(self.numberOfSegments)] for i in range(0, self.numberOfSegments): dataX = [] if i == 0: # the first index should always be inclusive aTest = x >= breaks[i] else: # the rest of the indexies should be exclusive aTest = x > breaks[i] dataX = np.extract(aTest, x) bTest = dataX <= breaks[i+1] dataX = np.extract(bTest, dataX) sepDataX[i] = np.array(dataX) return(sepDataX)
def place(arr, mask, vals): """ Change elements of an array based on conditional and input values. Similar to ``np.copyto(arr, vals, where=mask)``, the difference is that `place` uses the first N elements of `vals`, where N is the number of True values in `mask`, while `copyto` uses the elements where `mask` is True. Note that `extract` does the exact opposite of `place`. Parameters ---------- arr : ndarray Array to put data into. mask : array_like Boolean mask array. Must have the same size as `a`. vals : 1-D sequence Values to put into `a`. Only the first N elements are used, where N is the number of True values in `mask`. If `vals` is smaller than N it will be repeated. See Also -------- copyto, put, take, extract Examples -------- >>> arr = np.arange(6).reshape(2, 3) >>> np.place(arr, arr>2, [44, 55]) >>> arr array([[ 0, 1, 2], [44, 55, 44]]) """ if not isinstance(arr, np.ndarray): raise TypeError("argument 1 must be numpy.ndarray, " "not {name}".format(name=type(arr).__name__)) return _insert(arr, mask, vals)
def seperateData(self, breaks): # a function that seperates the data based on the breaks numberOfParameters = len(breaks) numberOfSegments = numberOfParameters - 1 self.numberOfParameters = numberOfParameters self.numberOfSegments = numberOfSegments # Seperate Data into Segments sepDataX = [[] for i in range(self.numberOfSegments)] sepDataY = [[] for i in range(self.numberOfSegments)] for i in range(0, self.numberOfSegments): dataX = [] dataY = [] if i == 0: # the first index should always be inclusive aTest = self.xData >= breaks[i] else: # the rest of the indexies should be exclusive aTest = self.xData > breaks[i] dataX = np.extract(aTest, self.xData) dataY = np.extract(aTest, self.yData) bTest = dataX <= breaks[i+1] dataX = np.extract(bTest, dataX) dataY = np.extract(bTest, dataY) sepDataX[i] = np.array(dataX) sepDataY[i] = np.array(dataY) return(sepDataX, sepDataY)
def place(arr, mask, vals): """ Change elements of an array based on conditional and input values. Similar to ``np.copyto(arr, vals, where=mask)``, the difference is that `place` uses the first N elements of `vals`, where N is the number of True values in `mask`, while `copyto` uses the elements where `mask` is True. Note that `extract` does the exact opposite of `place`. Parameters ---------- arr : array_like Array to put data into. mask : array_like Boolean mask array. Must have the same size as `a`. vals : 1-D sequence Values to put into `a`. Only the first N elements are used, where N is the number of True values in `mask`. If `vals` is smaller than N it will be repeated. See Also -------- copyto, put, take, extract Examples -------- >>> arr = np.arange(6).reshape(2, 3) >>> np.place(arr, arr>2, [44, 55]) >>> arr array([[ 0, 1, 2], [44, 55, 44]]) """ return _insert(arr, mask, vals)
def extract_off_diag(mtx): """ extract off diagonal entries in mtx. The output vector is order in a column major manner. :param mtx: input matrix to extract the off diagonal entries :return: """ # we transpose the matrix because the function np.extract will first flatten the matrix # withe ordering convention 'C' instead of 'F'!! extract_cond = np.reshape((1 - np.eye(*mtx.shape)).T.astype(bool), (-1, 1), order='F') return np.reshape(np.extract(extract_cond, mtx.T), (-1, 1), order='F')
def place(arr, mask, vals): """ Change elements of an array based on conditional and input values. Similar to ``np.copyto(arr, vals, where=mask)``, the difference is that `place` uses the first N elements of `vals`, where N is the number of True values in `mask`, while `copyto` uses the elements where `mask` is True. Note that `extract` does the exact opposite of `place`. Parameters ---------- arr : ndarray Array to put data into. mask : array_like Boolean mask array. Must have the same size as `a`. vals : 1-D sequence Values to put into `a`. Only the first N elements are used, where N is the number of True values in `mask`. If `vals` is smaller than N, it will be repeated, and if elements of `a` are to be masked, this sequence must be non-empty. See Also -------- copyto, put, take, extract Examples -------- >>> arr = np.arange(6).reshape(2, 3) >>> np.place(arr, arr>2, [44, 55]) >>> arr array([[ 0, 1, 2], [44, 55, 44]]) """ if not isinstance(arr, np.ndarray): raise TypeError("argument 1 must be numpy.ndarray, " "not {name}".format(name=type(arr).__name__)) return _insert(arr, mask, vals)
def computeSumWithThreshold( dataNumpyArray, threshold): # convert to a mesh grid grid = numpy.meshgrid(dataNumpyArray) # Logical comparison # 1) compute a boolean array of values less than the threshold compareThreshold = numpy.less (grid , threshold) # 2) compare and extract # TODO Not elegant, but works. found this at http://stackoverflow.com/a/26511354 boolThreshold = numpy.logical_and(compareThreshold , grid) # Create new array lowPlank = numpy.extract(boolThreshold, grid) return numpy.sum(lowPlank)
def __call__(self, data): if data.domain != self.pca.pre_domain: data = data.from_table(self.pca.pre_domain, data) pca_space = self.pca.transform(data.X) if self.components is not None: #set unused components to zero remove = np.ones(pca_space.shape[1]) remove[self.components] = 0 remove = np.extract(remove, np.arange(pca_space.shape[1])) pca_space[:,remove] = 0 return self.pca.proj.inverse_transform(pca_space)
def extract(condition, arr): """ Return the elements of an array that satisfy some condition. This is equivalent to ``np.compress(ravel(condition), ravel(arr))``. If `condition` is boolean ``np.extract`` is equivalent to ``arr[condition]``. Note that `place` does the exact opposite of `extract`. Parameters ---------- condition : array_like An array whose nonzero or True entries indicate the elements of `arr` to extract. arr : array_like Input array of the same size as `condition`. Returns ------- extract : ndarray Rank 1 array of values from `arr` where `condition` is True. See Also -------- take, put, copyto, compress, place Examples -------- >>> arr = np.arange(12).reshape((3, 4)) >>> arr array([[ 0, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11]]) >>> condition = np.mod(arr, 3)==0 >>> condition array([[ True, False, False, True], [False, False, True, False], [False, True, False, False]], dtype=bool) >>> np.extract(condition, arr) array([0, 3, 6, 9]) If `condition` is boolean: >>> arr[condition] array([0, 3, 6, 9]) """ return _nx.take(ravel(arr), nonzero(ravel(condition))[0])
def single_metrics(gt, pred, num_cl): t_px = np.zeros(num_cl) n_px = np.zeros(num_cl) n1_px = np.zeros(num_cl) px_class = np.unique(gt) error = np.subtract(gt, pred) for i in px_class: t_px[i] += (np.where(gt == i)[0]).shape[0] n_px[i] += (np.where((gt == i) & (error == 0))[0]).shape[0] n1_px[i] += (np.where(pred == i)[0]).shape[0] return t_px, n_px, n1_px # if __name__ == "__main__": # pic_start = int(sys.argv[1]) # pic_end = int(sys.argv[2]) # num_cl = 22 # t_px = np.zeros(num_cl) # n_px = np.zeros(num_cl) # n1_px = np.zeros(num_cl) # for idx in range(pic_start, pic_end+1): # tmp_t, tmp_n, tmp_n1 = save_result(str(idx), num_cl, True) # t_px += tmp_t # n_px += tmp_n # n1_px += tmp_n1 # t_sum = np.sum(t_px) # n_sum = np.sum(n_px) # px_acc = n_sum/t_sum # condition_1 = t_px != 0 # c_n1 = np.extract(condition_1, n_px) # c_t1 = np.extract(condition_1, t_px) # condition_2 = (np.subtract(np.add(t_px, n1_px), n_px)) != 0 # c_n2 = np.extract(condition_2, n_px) # c_d2 = np.extract(condition_2, (np.subtract(np.add(t_px, n1_px), n_px))) # mean_acc = np.sum(np.divide(c_n1, c_t1))/num_cl # mean_IU = np.sum(np.divide(c_n2, c_d2))/num_cl # fw_IU = np.sum(np.divide(np.extract(condition_2, np.multiply(t_px, n_px)), c_d2))/t_sum # print("========= metrics =========") # print("pixel accuracy: " + str(px_acc)) # print("mean accuracy: " + str(mean_acc)) # print("mean IU: " + str(mean_IU)) # print("frequency weighted IU: " + str(fw_IU)) # print("") # if __name__ == "__main__": # num_cl = 22 # pic_id = int(sys.argv[1]) # save_compare_results(pic_id, num_cl)
def compress(condition, a, axis=None, out=None): """ Return selected slices of an array along given axis. When working along a given axis, a slice along that axis is returned in `output` for each index where `condition` evaluates to True. When working on a 1-D array, `compress` is equivalent to `extract`. Parameters ---------- condition : 1-D array of bools Array that selects which entries to return. If len(condition) is less than the size of `a` along the given axis, then output is truncated to the length of the condition array. a : array_like Array from which to extract a part. axis : int, optional Axis along which to take slices. If None (default), work on the flattened array. out : ndarray, optional Output array. Its type is preserved and it must be of the right shape to hold the output. Returns ------- compressed_array : ndarray A copy of `a` without the slices along axis for which `condition` is false. See Also -------- take, choose, diag, diagonal, select ndarray.compress : Equivalent method in ndarray np.extract: Equivalent method when working on 1-D arrays numpy.doc.ufuncs : Section "Output arguments" Examples -------- >>> a = np.array([[1, 2], [3, 4], [5, 6]]) >>> a array([[1, 2], [3, 4], [5, 6]]) >>> np.compress([0, 1], a, axis=0) array([[3, 4]]) >>> np.compress([False, True, True], a, axis=0) array([[3, 4], [5, 6]]) >>> np.compress([False, True], a, axis=1) array([[2], [4], [6]]) Working on the flattened array does not return slices along an axis but selects elements. >>> np.compress([False, True], a) array([2]) """ return _wrapfunc(a, 'compress', condition, axis=axis, out=out)
