Python numpy 模块，index_exp() 实例源码
我们从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]
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())
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 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