我们从Python开源项目中，提取了以下13个代码示例，用于说明如何使用numpy.index_exp()。
def test(self, test_data, batch_size): # ???????? questions_ok, documents_ok, context_mask, candidates_ok, y_true = self.preprocess_input_sequences(test_data) logging.info("Test on {} samples, {} per batch.".format(len(questions_ok), batch_size)) # ?? batch_num = len(questions_ok) // batch_size batch_idx = np.arange(batch_num) correct_num, total_num = 0, 0 for i in range(batch_num): start = batch_idx[i % batch_num] * batch_size stop = (batch_idx[i % batch_num] + 1) * batch_size _slice = np.index_exp[start:stop] data = {self.q_input: questions_ok[_slice], self.d_input: documents_ok[_slice], self.context_mask_bt: context_mask[_slice], self.candidates_bi: candidates_ok[_slice], self.y_true: y_true[_slice]} correct, = self.sess.run([self.correct_prediction], feed_dict=data) correct_num, total_num = correct_num + correct, total_num + batch_size test_acc = correct_num / total_num logging.info("Test accuracy is : {:.5f}".format(test_acc))
def get_next_batch(self, mode, idx): """ return next batch of data samples """ batch_size = self.args.batch_size if mode == "train": dataset = self.train_data sample_num = self.train_sample_num elif mode == "valid": dataset = self.valid_data sample_num = self.valid_sample_num else: dataset = self.test_data sample_num = self.test_sample_num if mode == "train": start = self.train_idx[idx] * batch_size stop = (self.train_idx[idx] + 1) * batch_size else: start = idx * batch_size stop = (idx + 1) * batch_size if start < sample_num and (idx + 1) * batch_size < sample_num else -1 samples = batch_size if stop != -1 else len(dataset[0]) - start _slice = np.index_exp[start:stop] return self.next_batch_feed_dict_by_dataset(dataset, _slice, samples)
def trajectory_set_item(self, idx, value): """ :param self: mdtraj.Trajectory :param idx: possible slices over frames, :param value: :return: """ import mdtraj assert isinstance(self, mdtraj.Trajectory), type(self) if not isinstance(value, mdtraj.Trajectory): raise TypeError("value to assign is of incorrect type(%s). Should be mdtraj.Trajectory" % type(value)) idx = np.index_exp[idx] frames, atoms = None, None if isinstance(idx, (list, tuple)): if len(idx) == 1: frames, atoms = idx[0], slice(None, None, None) if len(idx) == 2: frames, atoms = idx[0], idx[1] if len(idx) >= 3 or len(idx) == 0: raise IndexError("invalid slice by %s" % idx) self.xyz[frames, atoms] = value.xyz self._time[frames] = value.time self.unitcell_lengths[frames] = value.unitcell_lengths self.unitcell_angles[frames] = value.unitcell_angles
def _handle_slice(self, idx): idx = np.index_exp[idx] itrajs, frames, dims = None, None, None if isinstance(idx, (list, tuple)): if len(idx) == 1: itrajs, frames, dims = idx[0], slice(None, None, None), slice(None, None, None) if len(idx) == 2: itrajs, frames, dims = idx[0], idx[1], slice(None, None, None) if len(idx) == 3: itrajs, frames, dims = idx[0], idx[1], idx[2] if len(idx) > 3 or len(idx) == 0: raise IndexError("invalid slice by %s" % idx) return self._get_itraj_random_accessible(itrajs, frames, dims)
def _handle_slice(self, idx): idx = np.index_exp[idx] frames, dims = None, None if isinstance(idx, (tuple, list)): if len(idx) == 1: frames, dims = idx[0], slice(None, None, None) if len(idx) == 2: frames, dims = idx[0], idx[1] if len(idx) > 2: raise IndexError("Slice was more than two-dimensional, not supported.") cumsum = np.cumsum(self._source.trajectory_lengths()) if not isinstance(frames, (list, np.ndarray)): frames = self._get_indices(frames, cumsum[-1]) dims = self._get_indices(dims, self._source.ndim) nframes = len(frames) ndims = len(dims) data = np.empty((nframes, ndims), dtype=self._source.output_type()) from chainsaw.clustering import UniformTimeClustering for i, x in enumerate(frames): traj, idx = UniformTimeClustering._idx_to_traj_idx(x, cumsum) data[i, :] = self._source.data[traj][idx, dims] return data
def _handle_slice(self, idx): idx = np.index_exp[idx] frames, dims = None, None if isinstance(idx, (tuple, list)): if len(idx) == 1: frames, dims = idx[0], slice(None, None, None) if len(idx) == 2: frames, dims = idx[0], idx[1] if len(idx) > 2: raise IndexError("Slice was more than two-dimensional, not supported.") cumsum = np.cumsum(self._source.trajectory_lengths()) frames = self._get_indices(frames, cumsum[-1]) dims = self._get_indices(dims, self._source.ndim) nframes = len(frames) ndims = len(dims) frames_order = frames.argsort().argsort() frames_sorted = np.sort(frames) from chainsaw.clustering import UniformTimeClustering ra_stride = np.array([UniformTimeClustering._idx_to_traj_idx(x, cumsum) for x in frames_sorted]) data = np.empty((nframes, ndims), dtype=self._source.output_type()) offset = 0 for X in self._source.iterator(stride=ra_stride, lag=0, chunk=0, return_trajindex=False): L = len(X) data[offset:offset + L, :] = X[:, dims] offset += L return data[frames_order]
def grey_blit(src, dst, blend_mode=MJBLEND_NORMAL): """ This is for grey + alpha images """ # http://stackoverflow.com/a/3375291/190597 # http://stackoverflow.com/a/9166671/190597 # blending with alpha http://stackoverflow.com/questions/1613600/direct3d-rendering-2d-images-with-multiply-blending-mode-and-alpha # blending modes from: http://www.linuxtopia.org/online_books/graphics_tools/gimp_advanced_guide/gimp_guide_node55.html dt = dst.dtype src = src.astype(n.single) dst = dst.astype(n.single) out = n.empty(src.shape, dtype = 'float') alpha = n.index_exp[:, :, 1] rgb = n.index_exp[:, :, 0] src_a = src[alpha]/255.0 dst_a = dst[alpha]/255.0 out[alpha] = src_a+dst_a*(1-src_a) old_setting = n.seterr(invalid = 'ignore') src_pre = src[rgb]*src_a dst_pre = dst[rgb]*dst_a # blend: blendfuncs = { MJBLEND_NORMAL: lambda s, d, sa_: s + d*sa_, MJBLEND_ADD: lambda s, d, sa_: n.minimum(255, s + d), MJBLEND_SUB: lambda s, d, sa_: n.maximum(0, s - d), MJBLEND_MULT: lambda s, d, sa_: s*d*sa_ / 255.0, MJBLEND_MULTINV: lambda s, d, sa_: (255.0 - s)*d*sa_ / 255.0, MJBLEND_SCREEN: lambda s, d, sa_: 255 - (1.0/255.0)*(255.0 - s)*(255.0 - d*sa_), MJBLEND_DIVIDE: lambda s, d, sa_: n.minimum(255, d*sa_*256.0 / (s + 1.0)), MJBLEND_MIN: lambda s, d, sa_: n.minimum(d*sa_, s), MJBLEND_MAX: lambda s, d, sa_: n.maximum(d*sa_, s), } out[rgb] = blendfuncs[blend_mode](src_pre, dst_pre, (1-src_a)) out[rgb] /= out[alpha] n.seterr(**old_setting) out[alpha] *= 255 n.clip(out,0,255) # astype('uint8') maps np.nan (and np.inf) to 0 out = out.astype(dt) return out
def __init__(self, inputA=None, indexExp=None): if indexExp is None: raise ValueError("Must provide index Expression as numpy.index_exp!") self.indexExp = indexExp super().__init__(inputA)
def test_ellipsis(self): numpy_n = numpy.arange(24, dtype=self.dtype).reshape((2, 3, 4)) n = self.shared(numpy_n) test_cases = [ (0, Subtensor, self.sub, numpy.index_exp[...]), (1, Subtensor, self.sub, numpy.index_exp[..., 1]), (1, Subtensor, self.sub, numpy.index_exp[1, ...]), (1, Subtensor, self.sub, numpy.index_exp[..., 1, 2, 3]), (1, Subtensor, self.sub, numpy.index_exp[1, ..., 2, 3]), (1, Subtensor, self.sub, numpy.index_exp[1, 2, 3, ...]), (3, DimShuffle, self.dimshuffle, numpy.index_exp[..., [0, 2, 3]]), (1, DimShuffle, self.dimshuffle, numpy.index_exp[numpy.newaxis, ...]), (1, AdvancedSubtensor, self.adv_sub, numpy.index_exp[..., numpy.newaxis, [1, 2]])] for length, op_type, op_type_opt, slice_ in test_cases: numpy_tval = numpy_n[slice_] t = n[slice_] self.assertTrue(isinstance(t.owner.op, op_type)) tval = self.eval_output_and_check(t, op_type=op_type_opt, length=length) assert_equal(tval.shape, numpy_tval.shape) assert_array_equal(tval, numpy_tval)
def grey_blit(src, dst, blend_mode=MJBLEND_NORMAL): """ This is for grey + alpha images """ # http://stackoverflow.com/a/3375291/190597 # http://stackoverflow.com/a/9166671/190597 # blending with alpha http://stackoverflow.com/questions/1613600/direct3d-rendering-2d-images-with-multiply-blending-mode-and-alpha # blending modes from: http://www.linuxtopia.org/online_books/graphics_tools/gimp_advanced_guide/gimp_guide_node55.html dt = dst.dtype src = src.astype(n.single) dst = dst.astype(n.single) out = n.empty(src.shape, dtype='float') alpha = n.index_exp[:, :, 1] rgb = n.index_exp[:, :, 0] src_a = src[alpha] / 255.0 dst_a = dst[alpha] / 255.0 out[alpha] = src_a + dst_a * (1 - src_a) old_setting = n.seterr(invalid='ignore') src_pre = src[rgb] * src_a dst_pre = dst[rgb] * dst_a # blend: blendfuncs = { MJBLEND_NORMAL: lambda s, d, sa_: s + d * sa_, MJBLEND_ADD: lambda s, d, sa_: n.minimum(255, s + d), MJBLEND_SUB: lambda s, d, sa_: n.maximum(0, s - d), MJBLEND_MULT: lambda s, d, sa_: s * d * sa_ / 255.0, MJBLEND_MULTINV: lambda s, d, sa_: (255.0 - s) * d * sa_ / 255.0, MJBLEND_SCREEN: lambda s, d, sa_: 255 - (1.0 / 255.0) * (255.0 - s) * (255.0 - d * sa_), MJBLEND_DIVIDE: lambda s, d, sa_: n.minimum(255, d * sa_ * 256.0 / (s + 1.0)), MJBLEND_MIN: lambda s, d, sa_: n.minimum(d * sa_, s), MJBLEND_MAX: lambda s, d, sa_: n.maximum(d * sa_, s), } out[rgb] = blendfuncs[blend_mode](src_pre, dst_pre, (1 - src_a)) out[rgb] /= out[alpha] n.seterr(**old_setting) out[alpha] *= 255 n.clip(out, 0, 255) # astype('uint8') maps np.nan (and np.inf) to 0 out = out.astype(dt) return out
def addInitialRNNLayer(mainGraph, inputOperation=None, activation=TanhActivation, nHidden=100): """Add a RNN layer to input data Parameters ---------- mainGraph : ga.Graph computation graph to which append the dense layer inputOperation : ga.Operation operation feeding the data to the layer, must have a shape of (nExamples, seriesLength, nFeatures) activation : ga.SingleInputOperation [class] activatin operation for hidden units nHidden : int number of hidden units Returns ------- list(ga.Operation) List of activation operations from the RNN layer """ nExamples, seriesLength, nFeatures = inputOperation.shape h0 = generateZeroVariable(shape=(nExamples, nHidden), transpose=False) W = generateRandomVariable(shape=(nFeatures, nHidden), transpose=False, nInputs=nFeatures * seriesLength ** 3) U = generateRandomVariable(shape=(nHidden, nHidden), transpose=False, nInputs=nHidden * seriesLength ** 3) B = generateRandomVariable(shape=(1, nHidden), transpose=False, nInputs=nHidden * seriesLength ** 3) h0op = mainGraph.addOperation(h0) Wop = mainGraph.addOperation(W, doGradient=True) Uop = mainGraph.addOperation(U, doGradient=True) Bop = mainGraph.addOperation(B, doGradient=True) hactivations = [h0op] # ------ append activation gates for indexRNN in range(seriesLength): xSliceop = mainGraph.addOperation(SliceOperation(inputOperation, np.index_exp[:, indexRNN, :])) newHActiv = createRNNgate(mainGraph, xSliceop, hactivations[-1], Wop, Uop, Bop, activation) hactivations.append(newHActiv) return hactivations
