def test_make_variable(self):
t = [{'k': torch.rand(5, 5)}]
v = utils.make_variable(t)[0]['k']
self.assertTrue(isinstance(v, Variable))
self.assertFalse(v.data.is_cuda)
v = utils.make_variable(t, cuda=True)[0]['k']
self.assertEqual(v.data.is_cuda, torch.cuda.is_available())
def generate_batched_itr(self, data_itr, beam_size=None, maxlen_a=0.0, maxlen_b=None,
cuda=False, timer=None, prefix_size=0):
"""Iterate over a batched dataset and yield individual translations.
Args:
maxlen_a/b: generate sequences of maximum length ax + b,
where x is the source sentence length.
cuda: use GPU for generation
timer: StopwatchMeter for timing generations.
"""
if maxlen_b is None:
maxlen_b = self.maxlen
for sample in data_itr:
s = utils.make_variable(sample, volatile=True, cuda=cuda)
input = s['net_input']
srclen = input['src_tokens'].size(1)
if timer is not None:
timer.start()
with utils.maybe_no_grad():
hypos = self.generate(
input['src_tokens'],
input['src_lengths'],
beam_size=beam_size,
maxlen=int(maxlen_a*srclen + maxlen_b),
prefix_tokens=s['target'][:, :prefix_size] if prefix_size > 0 else None,
)
if timer is not None:
timer.stop(sum([len(h[0]['tokens']) for h in hypos]))
for i, id in enumerate(s['id'].data):
src = input['src_tokens'].data[i, :]
# remove padding from ref
ref = utils.strip_pad(s['target'].data[i, :], self.pad) if s['target'] is not None else None
yield id, src, ref, hypos[i]
def score_batched_itr(self, data_itr, cuda=False, timer=None):
"""Iterate over a batched dataset and yield scored translations."""
for sample in data_itr:
s = utils.make_variable(sample, volatile=True, cuda=cuda)
if timer is not None:
timer.start()
pos_scores, attn = self.score(s)
if timer is not None:
timer.stop(s['ntokens'])
for i, id in enumerate(s['id'].data):
src = s['net_input']['src_tokens'].data[i, :]
# remove padding from ref
ref = utils.strip_pad(s['target'].data[i, :], self.pad)
tgt_len = ref.numel()
pos_scores_i = pos_scores[i][:tgt_len]
score_i = pos_scores_i.sum() / tgt_len
attn_i = attn[i]
_, alignment = attn_i.max(dim=0)
hypos = [{
'tokens': ref,
'score': score_i,
'attention': attn_i,
'alignment': alignment,
'positional_scores': pos_scores_i,
}]
# return results in the same format as SequenceGenerator
yield id, src, ref, hypos
def _prepare_sample(self, sample, volatile):
if sample is None or len(sample) == 0:
return None
if hasattr(torch.cuda, 'empty_cache'):
# clear the caching allocator if this is the largest sample we've seen
if sample['target'].size(0) > self._max_bsz_seen:
self._max_bsz_seen = sample['target'].size(0)
torch.cuda.empty_cache()
return utils.make_variable(sample, volatile=volatile, cuda=True)
def generate_batched_itr(
self,
data_itr,
beam_size=None,
maxlen_a=0.0,
maxlen_b=None,
cuda=False,
timer=None,
prefix_size=0,
):
"""Iterate over a batched dataset and yield individual translations.
Args:
maxlen_a/b: generate sequences of maximum length ax + b,
where x is the source sentence length.
cuda: use GPU for generation
timer: StopwatchMeter for timing generations.
"""
if maxlen_b is None:
maxlen_b = self.maxlen
for sample in data_itr:
s = utils.make_variable(sample, volatile=True, cuda=cuda)
input = s["net_input"]
# Take the max source length to compute the max target length
srclen = input["src_tokens"].size(1)
# FIXME: handle characters properly
if self.use_char_source:
raise ValueError(
"Character level encoder is not supported yet for "
"multisource sentences."
)
encoder_inputs = (input["src_tokens"], input["src_lengths"])
if timer is not None:
timer.start()
with utils.maybe_no_grad():
hypos = self.generate(
encoder_inputs,
srcs_ids=input["src_ids"],
beam_size=beam_size,
maxlen=int(maxlen_a * srclen + maxlen_b),
prefix_tokens=s["target"][:, :prefix_size]
if prefix_size > 0
else None,
)
if timer is not None:
timer.stop(s["ntokens"])
for i, id in enumerate(s["id"]):
src = input["src_tokens"].index_select(
0,
input['src_ids'][self.align_to]
)
# remove padding from ref
ref = utils.strip_pad(s["target"][i, :], self.pad)
yield id, src, ref, hypos[i]
def _async_prepare_sample(self, rank, device_id, sample, volatile):
if sample is None:
self._sample = None
else:
if hasattr(torch.cuda, 'empty_cache'):
# clear the caching allocator if this is the largest sample we've seen
if sample['target'].size(0) > self._max_bsz_seen:
self._max_bsz_seen = sample['target'].size(0)
torch.cuda.empty_cache()
self._sample = utils.make_variable(sample, volatile=volatile, cuda_device=device_id)
def generate_batched_itr(
self,
data_itr,
beam_size=None,
maxlen_a=0.0,
maxlen_b=None,
cuda=False,
timer=None,
prefix_size=0,
):
"""Iterate over a batched dataset and yield individual translations.
Args:
maxlen_a/b: generate sequences of maximum length ax + b,
where x is the source sentence length.
cuda: use GPU for generation
timer: StopwatchMeter for timing generations.
"""
if maxlen_b is None:
maxlen_b = self.maxlen
for sample in data_itr:
s = utils.make_variable(sample, volatile=True, cuda=cuda)
input = s["net_input"]
srclen = input["src_tokens"].size(1)
if self.use_char_source:
encoder_input = (
input["src_tokens"],
input["src_lengths"],
input["char_inds"],
input["word_lengths"],
)
else:
encoder_input = (input["src_tokens"], input["src_lengths"])
if timer is not None:
timer.start()
with utils.maybe_no_grad():
hypos = self.generate(
encoder_input,
beam_size=beam_size,
maxlen=int(maxlen_a * srclen + maxlen_b),
prefix_tokens=s["target"][:, :prefix_size]
if prefix_size > 0
else None,
)
if timer is not None:
timer.stop(s["ntokens"])
for i, id in enumerate(s["id"].data):
src = input["src_tokens"].data[i, :]
# remove padding from ref
ref = utils.strip_pad(s["target"].data[i, :], self.pad)
yield id, src, ref, hypos[i]
def generate_batched_itr(self,
data_itr,
beam_size=None,
maxlen_a=0.0,
maxlen_b=None,
cuda_device=None,
timer=None):
"""Iterate over a batched dataset and yield individual translations.
Args:
maxlen_a/b: generate sequences of maximum length ax + b,
where x is the source sentence length.
cuda_device: GPU on which to do generation.
timer: StopwatchMeter for timing generations.
"""
if maxlen_b is None:
maxlen_b = self.maxlen
for sample in data_itr:
s = utils.make_variable(sample,
volatile=True,
cuda_device=cuda_device)
input = s['net_input']
srclen = input['src_tokens'].size(1)
if timer is not None:
timer.start()
with utils.maybe_no_grad():
hypos = self.generate(input['src_tokens'],
beam_size=beam_size,
maxlen=int(maxlen_a * srclen + maxlen_b))
if timer is not None:
timer.stop(s['ntokens'])
for i, id in enumerate(s['id'].data):
src = input['src_tokens'].data[i, :]
# remove padding from ref
ref = utils.strip_pad(s['target'].data[i, :], self.pad)
yield id, src, ref, hypos[i]
