def sort_scores(self):
"Sort the scores."
return torch.sort(self.scores, 0, True)
python类sort()的实例源码
def sample_from_probs(probs, top_n=10):
"""
truncated weighted random choice.
"""
_, indices = torch.sort(probs)
# set probabilities after top_n to 0
probs[indices.data[:-top_n]] = 0
sampled_index = torch.multinomial(probs, 1)
return sampled_index
def __init__(self, tensor, lengths):
self.original_lengths = lengths
sorted_lengths_tensor, self.sorted_idx = torch.sort(torch.LongTensor(lengths), dim=0, descending=True)
self.tensor = tensor.index_select(dim=0, index=self.sorted_idx)
self.lengths = list(sorted_lengths_tensor)
self.original_idx = torch.LongTensor(sort_idx(self.sorted_idx))
self.mask_original = torch.zeros(*self.tensor.size())
for i, length in enumerate(self.original_lengths):
self.mask_original[i][:length].fill_(1)
def sort_batch(data, seq_len):
sorted_seq_len, sorted_idx = torch.sort(seq_len, dim=0, descending=True)
sorted_data = data[sorted_idx.data]
_, reverse_idx = torch.sort(sorted_idx, dim=0, descending=False)
return sorted_data, sorted_seq_len.cuda(), reverse_idx.cuda()
def _prepare_corpora(self, corpora, bpe_encoder, src_vocab, trg_vocab):
src, trg = [], []
sizes = []
count, ignored = 0, 0
for corpus in corpora:
with corpus.reader([self._source_lang, self._target_lang]) as reader:
for source, target in reader:
src_words = bpe_encoder.encode_line(source, is_source=True)
trg_words = bpe_encoder.encode_line(target, is_source=False)
if len(src_words) > 0 and len(trg_words) > 0:
src.append(src_vocab.convertToIdx(src_words,
onmt.Constants.UNK_WORD))
trg.append(trg_vocab.convertToIdx(trg_words,
onmt.Constants.UNK_WORD,
onmt.Constants.BOS_WORD,
onmt.Constants.EOS_WORD))
sizes.append(len(src_words))
else:
ignored += 1
count += 1
if count % 100000 == 0:
self._logger.info(' %d sentences prepared' % count)
self._logger.info('Shuffling sentences')
perm = torch.randperm(len(src))
src = [src[idx] for idx in perm]
trg = [trg[idx] for idx in perm]
sizes = [sizes[idx] for idx in perm]
self._logger.info('Sorting sentences by size')
_, perm = torch.sort(torch.Tensor(sizes))
src = [src[idx] for idx in perm]
trg = [trg[idx] for idx in perm]
self._logger.info('Prepared %d sentences (%d ignored due to length == 0)' % (len(src), ignored))
return src, trg
def sortBest(self):
return torch.sort(self.scores, 0, True)
def sortBest(self):
return torch.sort(self.scores, 0, True)
# Get the score of the best in the beam.
def assertIsOrdered(self, order, x, mxx, ixx, task):
SIZE = 4
if order == 'descending':
def check_order(a, b):
return a >= b
elif order == 'ascending':
def check_order(a, b):
return a <= b
else:
error('unknown order "{}", must be "ascending" or "descending"'.format(order))
are_ordered = True
for j, k in product(range(SIZE), range(1, SIZE)):
self.assertTrue(check_order(mxx[j][k - 1], mxx[j][k]),
'torch.sort ({}) values unordered for {}'.format(order, task))
seen = set()
indicesCorrect = True
size = x.size(x.dim() - 1)
for k in range(size):
seen.clear()
for j in range(size):
self.assertEqual(x[k][ixx[k][j]], mxx[k][j],
'torch.sort ({}) indices wrong for {}'.format(order, task))
seen.add(ixx[k][j])
self.assertEqual(len(seen), size)
def test_median(self):
for size in (155, 156):
x = torch.rand(size, size)
x0 = x.clone()
res1val, res1ind = torch.median(x)
res2val, res2ind = torch.sort(x)
ind = int(math.floor((size + 1) / 2) - 1)
self.assertEqual(res2val.select(1, ind), res1val.select(1, 0), 0)
self.assertEqual(res2val.select(1, ind), res1val.select(1, 0), 0)
# Test use of result tensor
res2val = torch.Tensor()
res2ind = torch.LongTensor()
torch.median(x, out=(res2val, res2ind))
self.assertEqual(res2val, res1val, 0)
self.assertEqual(res2ind, res1ind, 0)
# Test non-default dim
res1val, res1ind = torch.median(x, 0)
res2val, res2ind = torch.sort(x, 0)
self.assertEqual(res1val[0], res2val[ind], 0)
self.assertEqual(res1ind[0], res2ind[ind], 0)
# input unchanged
self.assertEqual(x, x0, 0)
def sort_best(self):
"""Sort the beam."""
return torch.sort(self.scores, 0, True)
# Get the score of the best in the beam.
def assertIsOrdered(self, order, x, mxx, ixx, task):
SIZE = 4
if order == 'descending':
def check_order(a, b):
return a >= b
elif order == 'ascending':
def check_order(a, b):
return a <= b
else:
error('unknown order "{}", must be "ascending" or "descending"'.format(order))
are_ordered = True
for j, k in product(range(SIZE), range(1, SIZE)):
self.assertTrue(check_order(mxx[j][k - 1], mxx[j][k]),
'torch.sort ({}) values unordered for {}'.format(order, task))
seen = set()
indicesCorrect = True
size = x.size(x.dim() - 1)
for k in range(size):
seen.clear()
for j in range(size):
self.assertEqual(x[k][ixx[k][j]], mxx[k][j],
'torch.sort ({}) indices wrong for {}'.format(order, task))
seen.add(ixx[k][j])
self.assertEqual(len(seen), size)
def test_median(self):
for size in (155, 156):
x = torch.rand(size, size)
x0 = x.clone()
res1val, res1ind = torch.median(x, keepdim=False)
res2val, res2ind = torch.sort(x)
ind = int(math.floor((size + 1) / 2) - 1)
self.assertEqual(res2val.select(1, ind), res1val, 0)
self.assertEqual(res2val.select(1, ind), res1val, 0)
# Test use of result tensor
res2val = torch.Tensor()
res2ind = torch.LongTensor()
torch.median(x, keepdim=False, out=(res2val, res2ind))
self.assertEqual(res2val, res1val, 0)
self.assertEqual(res2ind, res1ind, 0)
# Test non-default dim
res1val, res1ind = torch.median(x, 0, keepdim=False)
res2val, res2ind = torch.sort(x, 0)
self.assertEqual(res1val, res2val[ind], 0)
self.assertEqual(res1ind, res2ind[ind], 0)
# input unchanged
self.assertEqual(x, x0, 0)
def eval_model(dataset, dataset_loader, standard_encoding, model_encoding, model, trustedEncoder = False, image_group = {}):
model.eval()
print "evaluating model..."
if trustedEncoder == False:
print "not using trusted encoder. This may take signficantly longer as predictions are converted to other encoding."
mx = len(dataset_loader)
batches = []
top1 = imSituTensorEvaluation(1, 3, image_group)
top5 = imSituTensorEvaluation(5, 3, image_group)
for i, (indexes, input, target) in enumerate(dataset_loader):
if True or i % 10 == 0: print "batch {} out of {}\r".format(i+1,mx),
input_var = torch.autograd.Variable(input.cuda(), volatile = True)
#target_var = torch.autograd.Variable(target.cuda(), volatile = True)
(scores,predictions) = model.forward_max(input_var)
(s_sorted, idx) = torch.sort(scores, 1, True)
if not trustedEncoder:
predictions = standard_encoding.to_tensor(model_encoding.to_situation(predictions), False, False)
predictions = predictions.view(target.size()[0], standard_encoding.n_verbs(), -1)
else:
predictions = predictions.data
#(s_sorted, idx) = torch.sort(scores, 1, True)
top1.add_point(target, predictions, idx.data, dataset.index_image(indexes))
top5.add_point(target, predictions, idx.data, dataset.index_image(indexes))
return (top1, top5)
#assumes the predictions are grouped by image, and sorted
def predict_human_readable (dataset_loader, simple_dataset, model, outdir, top_k):
model.eval()
print "predicting..."
mx = len(dataset_loader)
for i, (input, index) in enumerate(dataset_loader):
print "{}/{} batches".format(i+1,mx)
input_var = torch.autograd.Variable(input.cuda(), volatile = True)
(scores,predictions) = model.forward_max(input_var)
#(s_sorted, idx) = torch.sort(scores, 1, True)
human = encoder.to_situation(predictions)
(b,p,d) = predictions.size()
for _b in range(0,b):
items = []
offset = _b *p
for _p in range(0, p):
items.append(human[offset + _p])
items[-1]["score"] = scores.data[_b][_p]
items = sorted(items, key = lambda x: -x["score"])[:top_k]
name = simple_dataset.images[index[_b][0]].split(".")[:-1]
name.append("predictions")
outfile = outdir + ".".join(name)
json.dump(items,open(outfile,"w"))
def assertIsOrdered(self, order, x, mxx, ixx, task):
SIZE = 4
if order == 'descending':
def check_order(a, b):
return a >= b
elif order == 'ascending':
def check_order(a, b):
return a <= b
else:
error('unknown order "{}", must be "ascending" or "descending"'.format(order))
are_ordered = True
for j, k in product(range(SIZE), range(1, SIZE)):
self.assertTrue(check_order(mxx[j][k - 1], mxx[j][k]),
'torch.sort ({}) values unordered for {}'.format(order, task))
seen = set()
indicesCorrect = True
size = x.size(x.dim() - 1)
for k in range(size):
seen.clear()
for j in range(size):
self.assertEqual(x[k][ixx[k][j]], mxx[k][j],
'torch.sort ({}) indices wrong for {}'.format(order, task))
seen.add(ixx[k][j])
self.assertEqual(len(seen), size)
def test_median(self):
for size in (155, 156):
x = torch.rand(size, size)
x0 = x.clone()
nelem = x.nelement()
res1val = torch.median(x)
res2val, _ = torch.sort(x.view(nelem))
ind = int(math.floor((nelem + 1) / 2) - 1)
self.assertEqual(res2val[ind], res1val, 0)
res1val, res1ind = torch.median(x, dim=1, keepdim=False)
res2val, res2ind = torch.sort(x)
ind = int(math.floor((size + 1) / 2) - 1)
self.assertEqual(res2val.select(1, ind), res1val, 0)
self.assertEqual(res2val.select(1, ind), res1val, 0)
# Test use of result tensor
res2val = torch.Tensor()
res2ind = torch.LongTensor()
torch.median(x, keepdim=False, out=(res2val, res2ind))
self.assertEqual(res2val, res1val, 0)
self.assertEqual(res2ind, res1ind, 0)
# Test non-default dim
res1val, res1ind = torch.median(x, 0, keepdim=False)
res2val, res2ind = torch.sort(x, 0)
self.assertEqual(res1val, res2val[ind], 0)
self.assertEqual(res1ind, res2ind[ind], 0)
# input unchanged
self.assertEqual(x, x0, 0)
def sort_pack_tensors(ft, tar, lens):
_, inds = torch.sort(lens, dim=0, descending=True)
ft, tar, lens = ft[inds], tar[inds], list(lens[inds])
ft_packed = rnn_utils.pack_padded_sequence(ft, lens, batch_first=True)
tar_packed = rnn_utils.pack_padded_sequence(tar, lens, batch_first=True)
return ft_packed, tar_packed
def append_zeros_all(fls1, fls2, mode):
lens1, lens2 = [], []
for fl1, fl2 in zip(fls1, fls2):
if mode == 'audio':
lens1.append(fl1.shape[0]), lens2.append(fl2.shape[0])
elif mode == 'specs':
lens1.append(fl1.shape[0]), lens2.append(fl2.shape[0])
else:
raise ValueError('Whaaat?')
inds1, lens1 = list(np.flip(np.argsort(lens1),0)), np.flip(np.sort(lens1),0)
inds2, lens2 = list(np.flip(np.argsort(lens2),0)), np.flip(np.sort(lens2),0)
fls1, fls2 = np.array(fls1)[inds1], np.array(fls2)[inds2]
maxlen = max([max(lens1), max(lens2)])
mixes = []
for i, (fl1, fl2) in enumerate(zip(fls1, fls2)):
if mode == 'audio':
fls1[i] = np.pad(fl1, (0, maxlen - fl1.shape[0]), 'constant')
fls2[i] = np.pad(fl2, (0, maxlen - fl2.shape[0]), 'constant')
mixes.append(fls1[i] + fls2[i])
elif mode == 'specs':
fls1[i] = np.pad(fl1, ((0, maxlen - fl1.shape[0]), (0, 0)), 'constant')
fls2[i] = np.pad(fl2, ((0, maxlen - fl2.shape[0]), (0, 0)), 'constant')
else:
raise ValueError('Whaaat?')
return list(fls1), list(fls2), mixes, lens1, lens2
