def mask_prev_h(self, prev_h):
if self.len_wave_mask is not None:
if self.use_gpu:
self.len_wave_mask = self.len_wave_mask.cuda()
h_att, h_dec1, h_dec2 = prev_h
h_att = torch.index_select(h_att.data, 1, self.len_wave_mask) # batch idx is
h_dec1 = torch.index_select(h_dec1.data, 1, self.len_wave_mask)
h_dec2 = torch.index_select(h_dec2.data, 1, self.len_wave_mask)
prev_h = (Variable(h_att), Variable(h_dec1), Variable(h_dec2))
else:
prev_h = prev_h
return prev_h
python类index_select()的实例源码
def updateOutput(self, input):
self.renorm(input)
input = self._makeInputContiguous(input)
if input.dim() == 1:
torch.index_select(self.weight, 0, input, out=self.output)
elif input.dim() == 2:
torch.index_select(self.weight, 0, input.view(-1), out=self.output)
self.output = self.output.view(input.size(0), input.size(1), self.weight.size(1))
else:
raise RuntimeError("input must be a vector or matrix")
return self.output
def updateOutput(self, input):
t = input[0]
index = input[1]
torch.index_select(t, self.dimension, index, out=self.output)
return self.output
def updateOutput(self, input):
self.output.set_(self.network.forward([input, self.partition]))
if self.bias is not None:
self.output.add_(torch.index_select(self.bias, 1, self.partition).expand_as(self.output))
if self.addBuffer is None:
self.addBuffer = input.new()
if self.addBuffer.nelement() != input.size(0):
self.addBuffer.resize_(input.size(0)).fill_(1)
return self.output
def th_gather_2d(input, coords):
inds = coords[:, 0]*input.size(1) + coords[:, 1]
x = torch.index_select(th_flatten(input), 0, inds)
return x.view(coords.size(0))
def updateOutput(self, input):
self.renorm(input)
input = self._makeInputContiguous(input)
if input.dim() == 1:
torch.index_select(self.weight, 0, input, out=self.output)
elif input.dim() == 2:
torch.index_select(self.weight, 0, input.view(-1), out=self.output)
self.output = self.output.view(input.size(0), input.size(1), self.weight.size(1))
else:
raise RuntimeError("input must be a vector or matrix")
return self.output
def updateOutput(self, input):
t = input[0]
index = input[1]
torch.index_select(t, self.dimension, index, out=self.output)
return self.output
def updateOutput(self, input):
self.output.set_(self.network.forward([input, self.partition]))
if self.bias is not None:
self.output.add_(torch.index_select(self.bias, 1, self.partition).expand_as(self.output))
if self.addBuffer is None:
self.addBuffer = input.new()
if self.addBuffer.nelement() != input.size(0):
self.addBuffer.resize_(input.size(0)).fill_(1)
return self.output
def _get_hashed_indices(self, original_indices):
def _hash(x, seed):
# TODO: integrate with padding index
result = murmurhash3_32(x, seed=seed)
result[self.padding_idx] = 0
return result % self.compressed_num_embeddings
if self._hashes is None:
indices = np.arange(self.num_embeddings, dtype=np.int32)
hashes = np.stack([_hash(indices, seed)
for seed in self._masks],
axis=1).astype(np.int64)
assert hashes[self.padding_idx].sum() == 0
self._hashes = torch.from_numpy(hashes)
if original_indices.is_cuda:
self._hashes = self._hashes.cuda()
hashed_indices = torch.index_select(self._hashes,
0,
original_indices.squeeze())
return hashed_indices
def exp6(num_data=1000):
if num_data < 2:
raise ValueError('num_data should be larger than 2. (num_data = {})'.format(num_data))
center = -5
sigma_x = 7
sigma_y = 7
n1 = num_data
# init data
d1x = torch.FloatTensor(n1, 1)
d1y = torch.FloatTensor(n1, 1)
d1x.normal_(center, sigma_x)
d1y.normal_(center, sigma_y)
d1 = torch.cat((d1x, d1y), 1)
d = d1
# label
label = torch.IntTensor(num_data).zero_()
label[:] = 0
# shuffle
#shuffle = torch.randperm(d.size()[0])
#d = torch.index_select(d, 0, shuffle)
#label = torch.index_select(label, 0, shuffle)
# pdf
rv1 = multivariate_normal([ center, center], [[math.pow(sigma_x, 2), 0.0], [0.0, math.pow(sigma_y, 2)]])
def pdf(x):
prob = (float(n1) / float(num_data)) * rv1.pdf(x)
return prob
def sumloglikelihood(x):
return np.sum(np.log((pdf(x) + 1e-10)))
return d, label, sumloglikelihood
def forward(cls, ctx, indices, weight, padding_idx, max_norm, norm_type, scale_grad_by_freq,
sparse=False):
ctx.padding_idx = padding_idx
ctx.scale_grad_by_freq = scale_grad_by_freq
ctx._indices = None
ctx.sparse = sparse
assert indices.dim() <= 2
assert not ctx.needs_input_grad[0], "Embedding doesn't " \
"compute the gradient w.r.t. the indices"
ctx._backend = type2backend[type(weight)]
ctx._weight_size = weight.size()
if not indices.is_contiguous():
ctx._indices = indices.contiguous()
indices = ctx._indices
else:
ctx.save_for_backward(indices)
output = weight.new()
if max_norm is not None:
cls._renorm(ctx, indices, weight, max_norm, norm_type)
if indices.dim() == 1:
output = torch.index_select(weight, 0, indices)
else:
output = torch.index_select(weight, 0, indices.view(-1))
output = output.view(indices.size(0), indices.size(1), weight.size(1))
return output
def updateOutput(self, input):
self.renorm(input)
input = self._makeInputContiguous(input)
if input.dim() == 1:
torch.index_select(self.weight, 0, input, out=self.output)
elif input.dim() == 2:
torch.index_select(self.weight, 0, input.view(-1), out=self.output)
self.output = self.output.view(input.size(0), input.size(1), self.weight.size(1))
else:
raise RuntimeError("input must be a vector or matrix")
return self.output
def updateOutput(self, input):
t = input[0]
index = input[1]
torch.index_select(t, self.dimension, index, out=self.output)
return self.output
def updateOutput(self, input):
self.output.set_(self.network.forward([input, self.partition]))
if self.bias is not None:
self.output.add_(torch.index_select(self.bias, 1, self.partition).expand_as(self.output))
if self.addBuffer is None:
self.addBuffer = input.new()
if self.addBuffer.nelement() != input.size(0):
self.addBuffer.resize_(input.size(0)).fill_(1)
return self.output
def reverse(input, dim=0):
"""
Reverses a tensor
Args:
- input: tensor to reverse
- dim: dimension to reverse on
Returns:
- reversed input
"""
reverse_index = input.new(input.size(dim)).long()
torch.arange(1 - input.size(dim), 1, out=reverse_index)
reverse_index.mul_(-1)
return input.index_select(dim, reverse_index)
def rcumsum(input, dim=0):
"""
Computes a reverse cumulative sum
Args:
- input: tensor
- dim: dimension to reverse on
Returns:
- rcumsum on input
"""
reverse_index = torch.LongTensor(list(range(input.size(dim))[::-1]))
return torch.index_select(input, dim, reverse_index).cumsum(dim).index_select(dim, reverse_index)
def form_mixtures(digit1, digit2, loader, arguments):
dataset1, dataset2 = [], []
for i, (ft, tar) in enumerate(loader):
# digit 1
mask = torch.eq(tar, digit1)
inds = torch.nonzero(mask).squeeze()
ft1 = torch.index_select(ft, dim=0, index=inds)
dataset1.append(ft1)
# digit 2
mask = torch.eq(tar, digit2)
inds = torch.nonzero(mask).squeeze()
ft2 = torch.index_select(ft, dim=0, index=inds)
dataset2.append(ft2)
print(i)
dataset1 = torch.cat(dataset1, dim=0)
dataset2 = torch.cat(dataset2, dim=0)
if arguments.input_type == 'noise':
inp1 = torch.randn(dataset1.size(0), arguments.L1)
inp2 = torch.randn(dataset2.size(0), arguments.L1)
elif arguments.input_type == 'autoenc':
inp1 = dataset1
inp2 = dataset2
else:
raise ValueError('Whaaaaaat input_type?')
N1, N2 = dataset1.size(0), dataset2.size(0)
Nmix = min([N1, N2])
dataset_mix = dataset1[:Nmix] + dataset2[:Nmix]
dataset1 = TensorDataset(data_tensor=inp1,
target_tensor=dataset1,
lens=[1]*Nmix)
dataset2 = data_utils.TensorDataset(data_tensor=inp2,
target_tensor=dataset2)
dataset_mix = data_utils.TensorDataset(data_tensor=dataset_mix,
target_tensor=torch.ones(Nmix))
kwargs = {'num_workers': 1, 'pin_memory': True} if arguments.cuda else {}
loader1 = data_utils.DataLoader(dataset1, batch_size=arguments.batch_size, shuffle=False, **kwargs)
loader2 = data_utils.DataLoader(dataset2, batch_size=arguments.batch_size, shuffle=False, **kwargs)
loader_mix = data_utils.DataLoader(dataset_mix, batch_size=arguments.batch_size, shuffle=False, **kwargs)
return loader1, loader2, loader_mix
def th_gather_nd(x, coords):
x = x.contiguous()
inds = coords.mv(th.LongTensor(x.stride()))
x_gather = th.index_select(th_flatten(x), 0, inds)
return x_gather
def forward(cls, ctx, indices, weight, padding_idx, max_norm, norm_type, scale_grad_by_freq,
sparse=False):
ctx.padding_idx = padding_idx
ctx.scale_grad_by_freq = scale_grad_by_freq
ctx._indices = None
ctx.sparse = sparse
assert indices.dim() <= 2
assert not ctx.needs_input_grad[0], "Embedding doesn't " \
"compute the gradient w.r.t. the indices"
ctx._backend = type2backend[type(weight)]
ctx._weight_size = weight.size()
if not indices.is_contiguous():
ctx._indices = indices.contiguous()
indices = ctx._indices
else:
ctx.save_for_backward(indices)
output = weight.new()
if max_norm is not None:
cls._renorm(ctx, indices, weight, max_norm, norm_type)
if indices.dim() == 1:
output = torch.index_select(weight, 0, indices)
else:
output = torch.index_select(weight, 0, indices.view(-1))
output = output.view(indices.size(0), indices.size(1), weight.size(1))
return output
def updateOutput(self, input):
self.renorm(input)
input = self._makeInputContiguous(input)
if input.dim() == 1:
torch.index_select(self.weight, 0, input, out=self.output)
elif input.dim() == 2:
torch.index_select(self.weight, 0, input.view(-1), out=self.output)
self.output = self.output.view(input.size(0), input.size(1), self.weight.size(1))
else:
raise RuntimeError("input must be a vector or matrix")
return self.output
