def test_padded_tensor(self):
# list of lists
lol = [[1, 2], [3, 4, 5]]
output, lens = padded_tensor(lol)
assert np.all(output.numpy() == np.array([[1, 2, 0], [3, 4, 5]]))
assert lens == [2, 3]
output, _ = padded_tensor(lol, left_padded=True)
assert np.all(output.numpy() == np.array([[0, 1, 2], [3, 4, 5]]))
output, _ = padded_tensor(lol, pad_idx=99)
assert np.all(output.numpy() == np.array([[1, 2, 99], [3, 4, 5]]))
def batchify(self, obs_batch, sort=False):
batch = super().batchify(obs_batch, sort)
valid_obs = [(i, ex) for i, ex in enumerate(obs_batch)
if self.is_valid(ex)]
valid_inds, exs = zip(*valid_obs)
# TEXT
xs, x_lens = None, None
if any('support_vec' in ex for ex in exs):
_xs = [ex.get('support_vec', self.EMPTY) for ex in exs]
xs, x_lens = padded_tensor(_xs,
self.NULL_IDX,
self.use_cuda,
fp16friendly=self.opt.get('fp16'))
if sort:
sort = False # now we won't sort on labels
xs, x_lens, valid_inds, exs = argsort(x_lens,
xs,
x_lens,
valid_inds,
exs,
descending=True)
qs, q_lens = None, None
if any('query_vec' in ex for ex in exs):
_qs = [ex.get('query_vec', self.EMPTY) for ex in exs]
qs, q_lens = padded_tensor(_qs,
self.NULL_IDX,
self.use_cuda,
fp16friendly=self.opt.get('fp16'))
if sort:
sort = False # now we won't sort on labels
qs, q_lens, valid_inds, exs = argsort(q_lens,
qs,
q_lens,
valid_inds,
exs,
descending=True)
batch.query_vec = qs
batch.query_lengths = q_lens
batch.supports_vec = xs
batch.supports_lengths = x_lens
return batch
def _pad_tensor(self, items):
"""
Override to always set fp16friendly to False and left_pad to True.
"""
return padded_tensor(
items, pad_idx=self.NULL_IDX, left_padded=True, fp16friendly=False
)
def _add_prev_responses(self, batch, cands, cand_vecs, label_inds, source):
assert source not in ['fixed', 'vocab']
self._extract_prev_responses(batch)
# Add prev_responses as negatives
prev_cands = self.prev_responses
prev_cand_vecs = [
torch.Tensor(self.dict.txt2vec(cand)) for cand in prev_cands
]
if source == 'batch':
# Option 1: Change from one set of shared candidates to separate per example
# cands = [cands + [prev_cand] for prev_cand in prev_cands]
# list_of_lists_of_cand_vecs = [[vec for vec in cand_vecs] + [prev_cand_vec]
# for prev_cand_vec in prev_cand_vecs]
# cand_vecs = padded_3d(list_of_lists_of_cand_vecs, use_cuda=self.use_cuda,
# dtype=cand_vecs[0].dtype)
# Option 2: Just add all prev responses for the whole batch (doubles bs)
cands += prev_cands
cand_vecs, _ = padded_tensor([vec for vec in cand_vecs] +
prev_cand_vecs,
use_cuda=self.use_cuda)
elif source == 'inline':
raise NotImplementedError
return cands, cand_vecs
def vectorize_texts(
self,
input_text: List[str],
tokenizer: RagRetrieverTokenizer,
max_len: Optional[int] = None,
) -> torch.LongTensor:
"""
Vectorize a set of input texts with an arbitrary RagRetrieverTokenizer.
:param input_text:
list of input strings
:param tokenizer:
tokenizer that encodes the input strings
:param max_len:
max length to tokenize
:return vecs:
returns a stacked padded tensor of tokens.
"""
vecs = [tokenizer.encode(q) for q in input_text]
if max_len:
vecs = [v[:max_len] for v in vecs]
vecs, _ = padded_tensor(
vecs,
fp16friendly=self.fp16,
pad_idx=tokenizer.get_pad_idx(),
max_len=max_len,
)
return vecs
def _build_candidates_tensor(self, batch):
if not batch.candidates:
return None, None
cand_inds = [
i for i in range(len(batch.candidates)) if batch.candidates[i]
]
cands = [batch.candidate_vecs[i] for i in cand_inds]
# get the length of the longest candidate in the batch
max_cand_len = max(
[max([cand.size(0) for cand in cands_i]) for cands_i in cands])
for i, c in enumerate(
cands
): # make each instance in batch.cands to a padded tensor
cands[i] = padded_tensor(c,
use_cuda=self.use_cuda,
max_len=max_cand_len,
fp16friendly=self.fp16)[0].unsqueeze(0)
# (batchsize, num_cands, max_len + a) +a due to fp16
cands = torch.cat(cands, 0)
return cands, cand_inds
def _pad_tensor(self, items):
"""
Override to always set fp16friendly to False.
"""
return padded_tensor(
items, pad_idx=self.NULL_IDX, use_cuda=self.use_cuda, fp16friendly=False,
)
def thorough_generation(
cls,
hyps: List[torch.LongTensor],
new_input: torch.LongTensor,
null_idx: int,
model: RagModel,
) -> List[Tuple[torch.LongTensor, torch.Tensor]]:
"""
Apply RAG-sequence thorough generation for a single batch item.
Recomputes model scores with given hypotheses, sorts accordingly.
:param hyps:
list of candidate hypotheses
:param new_input:
input for the model
:return sorted_hyps:
return list of (hyp, score) tuples, sorted by their score.
"""
# deduplicate, exclude BOS Token
hyps = list({str(h.tolist()): h[1:] for h in hyps}.values()) # type: ignore
new_input = new_input.repeat(len(hyps), 1) # type: ignore
new_ys, _ = padded_tensor(
hyps, fp16friendly=new_input.size(1) % FP16_PAD_SIZE == 0, pad_idx=null_idx
)
new_ys = new_ys.to(new_input.device)
scores, *_ = model.seq2seq_forward_pass(new_input, new_ys)
loss = cls._rag_sequence_loss(
new_ys.unsqueeze(1).unsqueeze(-1), scores.unsqueeze(1), null_idx
) # type: ignore
sorted_by_score = [
(hyps[idx], loss[idx]) for idx in loss.sort()[-1]
] # sort ascending
return sorted_by_score
def predict_satisfaction_by_uncertainty(self, batch):
# Use the dialog model's confidence to predict the rating on previous response
# HACK: this test is run using a model that was trained on dialog but is now
# being evaluated on satisfaction. We use a satisfaction dataset so that we have
# access to the satisfaction labels. Therefore, we do a sloppy hack here to pull
# out what would have been the candidates for the dialog task. We use histsz=4
# and ignore the last response (the user's feedback) and use the penultimate
# utterances as the candidates. The (up to) two utterances before that are
# context.
# pull out dialog candidates from text_vecs since this is a satisfaction task
assert self.opt['history_size'] > 2
text_vecs = []
cand_vecs = []
for vec in batch.text_vec:
last_p1 = (
vec == self.dict.txt2vec('__p1__')[0]).nonzero()[-1].item()
last_p2 = (
vec == self.dict.txt2vec('__p2__')[0]).nonzero()[-1].item()
text_vecs.append(vec[:last_p2])
cand_vecs.append(vec[last_p2 + 1:last_p1])
text_padded, _ = padded_tensor(text_vecs)
cand_padded, _ = padded_tensor(cand_vecs)
scores = self.model.score_dialog(text_padded, cand_padded)
confidences = F.softmax(scores, dim=1).cpu().detach().numpy()
preds = []
for example in confidences:
ranked_confidences = sorted(list(example), reverse=True)
if self.opt['uncertainty_style'] == 'mag':
# If the most confident choice isn't confident enough, predict that
# the response the bot gives will be bad (pred=0)
mag = ranked_confidences[0]
preds.append(mag > self.opt['uncertainty_threshold'])
elif self.opt['uncertainty_style'] == 'gap':
# If the gap between the first and second most confident choices isn't
# large enough, predict that the response the bot gives will be bad
# (pred=0)
gap = ranked_confidences[0] - ranked_confidences[1]
preds.append(gap > self.opt['uncertainty_threshold'])
loss = torch.tensor(0)
preds = torch.LongTensor(preds)
labels = torch.LongTensor([int(l) == 1 for l in batch.labels])
batchsize = len(labels)
self.update_sat_metrics(loss, preds, labels, batchsize)
return preds
def eval_step(self, batch):
"""
Evaluate a single batch of examples.
"""
if batch.text_vec is None:
return
bsz = batch.text_vec.size(0)
self.model.eval()
cand_scores = None
token_losses = None
if batch.label_vec is not None:
# calculate loss on targets with teacher forcing
loss, model_output = self.compute_loss(batch, return_output=True)
self.metrics['loss'] += loss.item()
if self.output_token_losses:
token_losses = self._construct_token_losses(
batch.label_vec, model_output)
preds = None
if self.skip_generation:
warn_once(
"--skip-generation does not produce accurate metrics beyond ppl",
RuntimeWarning,
)
else:
maxlen = self.label_truncate or 256
beam_preds_scores, _ = self._generate(batch, self.beam_size,
maxlen)
preds, scores = zip(*beam_preds_scores)
cand_choices = None
# TODO: abstract out the scoring here
if self.rank_candidates:
# compute roughly ppl to rank candidates
cand_choices = []
encoder_states = self.model.encoder(*self._model_input(batch))
for i in range(bsz):
num_cands = len(batch.candidate_vecs[i])
enc = self.model.reorder_encoder_states(
encoder_states, [i] * num_cands)
cands, _ = padded_tensor(batch.candidate_vecs[i],
self.NULL_IDX, self.use_cuda)
scores, _ = self.model.decode_forced(enc, cands)
cand_losses = F.cross_entropy(
scores.view(num_cands * cands.size(1), -1),
cands.view(-1),
reduction='none',
).view(num_cands, cands.size(1))
# now cand_losses is cands x seqlen size, but we still need to
# check padding and such
mask = (cands != self.NULL_IDX).float()
cand_scores = (cand_losses *
mask).sum(dim=1) / (mask.sum(dim=1) + 1e-9)
_, ordering = cand_scores.sort()
cand_choices.append([batch.candidates[i][o] for o in ordering])
text = [self._v2t(p) for p in preds] if preds is not None else None
return Output(text, cand_choices, token_losses=token_losses)
def batchify(self, obs_batch):
"""
Air custom batchify, which passes along the intent.
Following the docstring of TorchAgent.batchify, it calls super, then
uses an extended version of the torch_agent.Batch namedtuple.
The purpose of extending the info is to keep track of some custom
metrics.
"""
# import ipdb; ipdb.set_trace()
batch = super().batchify(obs_batch)
reordered_observations = [obs_batch[i] for i in batch.valid_indices]
is_training = 'labels' in reordered_observations[0]
# first parse and compile all the knowledge together
all_knowledges = [
] # list-of-lists knowledge items for each observation
for obs in reordered_observations:
obs_know = [obs.get('intent')]
all_knowledges.append(obs_know)
# now we want to actually pack this into a tensor, along with the mask
N = len(reordered_observations)
K = 1
flattened_knowledge = list(chain(*all_knowledges))
knowledge_vec = [
self._vectorize_text(
# the beginning of the sentence is more useful
k,
truncate=self.truncate,
add_end=True,
truncate_left=False,
) for k in flattened_knowledge
]
knowledge_vec, _ = padded_tensor(knowledge_vec, self.NULL_IDX,
self.use_cuda)
T = knowledge_vec.size(-1)
knowledge_vec = knowledge_vec.view(N, K, T)
# knowledge mask is a N x K tensor saying which items we're allowed to
# attend over
ck_mask = th.ones(N, K, dtype=th.uint8)
ck_mask = ck_mask != 0 # for pytorch 1.0/1.2 uint8/bool compatibility
if self.use_cuda:
knowledge_vec = knowledge_vec.cuda()
ck_mask = ck_mask.cuda()
batch['know_vec'] = knowledge_vec
batch['ck_mask'] = ck_mask
batch['knowledge'] = np.array(flattened_knowledge).reshape(N, K)
return batch
def _dummy_batch(self, batchsize, maxlen):
context_lens = torch.LongTensor([3] * batchsize)
return Batch(text_vec=torch.ones(batchsize, 3, maxlen).long().cuda(),
text_lengths=(torch.ones(batchsize, 3) *
maxlen).long().cuda(),
context_lens=context_lens.cuda(),
floors=padded_tensor(
[make_floor(c_len.item()) for c_len in context_lens],
use_cuda=self.use_cuda)[0],
label_vec=torch.ones(batchsize, 2).long().cuda(),
label_lengths=torch.LongTensor([2] * batchsize).cuda())
def _add_prev_responses(self, batch, cands, cand_vecs, label_inds, source):
assert source not in ['fixed', 'vocab']
self._extract_prev_responses(batch)
# Add prev_responses as negatives
prev_cands = self.prev_responses
prev_cand_vecs = [
torch.Tensor(self.dict.txt2vec(cand)) for cand in prev_cands
]
if source == 'batch':
# Option 2: Just add all prev responses for the whole batch (doubles bs)
cands += prev_cands
cand_vecs, _ = padded_tensor([vec for vec in cand_vecs] +
prev_cand_vecs)
elif source == 'inline':
raise NotImplementedError
return cands, cand_vecs
def retrieve_and_score(
self, query: torch.LongTensor
) -> Tuple[List[List[Document]], torch.Tensor]:
"""
Retrieves from the FAISS index using a search query.
This methods relies on the `retrieve_and_score` method in `RagRetriever`
ancestor class. It receive the query (conversation context) and generatess the
search term queries based on them. Then uses those search quries (instead of the
the query text itself) to retrieve from the FAISS index.
"""
search_queries = self.generate_search_query(query)
tokenized_search_queries, _ = padded_tensor(
[self._tokenizer.encode(sq) for sq in search_queries])
top_docs, top_doc_scores = DPRRetriever.retrieve_and_score(
self, tokenized_search_queries.to(query.device))
for query_id in range(len(top_docs)):
if search_queries[query_id] == NO_SEARCH_QUERY:
top_docs[query_id] = [BLANK_DOC for _ in range(self.n_docs)]
return top_docs, top_doc_scores
def test_summarization(self):
"""
From Huggingface.
"""
cfg_name = 'summarization'
cfg = TASK_CONFIGS[cfg_name]
self.agent.opt['t5_generation_config'] = cfg_name
FRANCE_ARTICLE = 'Marseille, France (CNN)The French prosecutor leading an investigation into the crash of Germanwings Flight 9525 insisted Wednesday that he was not aware of any video footage from on board the plane. Marseille prosecutor Brice Robin told CNN that "so far no videos were used in the crash investigation." He added, "A person who has such a video needs to immediately give it to the investigators." Robin\'s comments follow claims by two magazines, German daily Bild and French Paris Match, of a cell phone video showing the harrowing final seconds from on board Germanwings Flight 9525 as it crashed into the French Alps. All 150 on board were killed. Paris Match and Bild reported that the video was recovered from a phone at the wreckage site. The two publications described the supposed video, but did not post it on their websites. The publications said that they watched the video, which was found by a source close to the investigation. "One can hear cries of \'My God\' in several languages," Paris Match reported. "Metallic banging can also be heard more than three times, perhaps of the pilot trying to open the cockpit door with a heavy object. Towards the end, after a heavy shake, stronger than the others, the screaming intensifies. Then nothing." "It is a very disturbing scene," said Julian Reichelt, editor-in-chief of Bild online. An official with France\'s accident investigation agency, the BEA, said the agency is not aware of any such video. Lt. Col. Jean-Marc Menichini, a French Gendarmerie spokesman in charge of communications on rescue efforts around the Germanwings crash site, told CNN that the reports were "completely wrong" and "unwarranted." Cell phones have been collected at the site, he said, but that they "hadn\'t been exploited yet." Menichini said he believed the cell phones would need to be sent to the Criminal Research Institute in Rosny sous-Bois, near Paris, in order to be analyzed by specialized technicians working hand-in-hand with investigators. But none of the cell phones found so far have been sent to the institute, Menichini said. Asked whether staff involved in the search could have leaked a memory card to the media, Menichini answered with a categorical "no." Reichelt told "Erin Burnett: Outfront" that he had watched the video and stood by the report, saying Bild and Paris Match are "very confident" that the clip is real. He noted that investigators only revealed they\'d recovered cell phones from the crash site after Bild and Paris Match published their reports. "That is something we did not know before. ... Overall we can say many things of the investigation weren\'t revealed by the investigation at the beginning," he said. What was mental state of Germanwings co-pilot? German airline Lufthansa confirmed Tuesday that co-pilot Andreas Lubitz had battled depression years before he took the controls of Germanwings Flight 9525, which he\'s accused of deliberately crashing last week in the French Alps. Lubitz told his Lufthansa flight training school in 2009 that he had a "previous episode of severe depression," the airline said Tuesday. Email correspondence between Lubitz and the school discovered in an internal investigation, Lufthansa said, included medical documents he submitted in connection with resuming his flight training. The announcement indicates that Lufthansa, the parent company of Germanwings, knew of Lubitz\'s battle with depression, allowed him to continue training and ultimately put him in the cockpit. Lufthansa, whose CEO Carsten Spohr previously said Lubitz was 100% fit to fly, described its statement Tuesday as a "swift and seamless clarification" and said it was sharing the information and documents -- including training and medical records -- with public prosecutors. Spohr traveled to the crash site Wednesday, where recovery teams have been working for the past week to recover human remains and plane debris scattered across a steep mountainside. He saw the crisis center set up in Seyne-les-Alpes, laid a wreath in the village of Le Vernet, closer to the crash site, where grieving families have left flowers at a simple stone memorial. Menichini told CNN late Tuesday that no visible human remains were left at the site but recovery teams would keep searching. French President Francois Hollande, speaking Tuesday, said that it should be possible to identify all the victims using DNA analysis by the end of the week, sooner than authorities had previously suggested. In the meantime, the recovery of the victims\' personal belongings will start Wednesday, Menichini said. Among those personal belongings could be more cell phones belonging to the 144 passengers and six crew on board. Check out the latest from our correspondents . The details about Lubitz\'s correspondence with the flight school during his training were among several developments as investigators continued to delve into what caused the crash and Lubitz\'s possible motive for downing the jet. A Lufthansa spokesperson told CNN on Tuesday that Lubitz had a valid medical certificate, had passed all his examinations and "held all the licenses required." Earlier, a spokesman for the prosecutor\'s office in Dusseldorf, Christoph Kumpa, said medical records reveal Lubitz suffered from suicidal tendencies at some point before his aviation career and underwent psychotherapy before he got his pilot\'s license. Kumpa emphasized there\'s no evidence suggesting Lubitz was suicidal or acting aggressively before the crash. Investigators are looking into whether Lubitz feared his medical condition would cause him to lose his pilot\'s license, a European government official briefed on the investigation told CNN on Tuesday. While flying was "a big part of his life," the source said, it\'s only one theory being considered. Another source, a law enforcement official briefed on the investigation, also told CNN that authorities believe the primary motive for Lubitz to bring down the plane was that he feared he would not be allowed to fly because of his medical problems. Lubitz\'s girlfriend told investigators he had seen an eye doctor and a neuropsychologist, both of whom deemed him unfit to work recently and concluded he had psychological issues, the European government official said. But no matter what details emerge about his previous mental health struggles, there\'s more to the story, said Brian Russell, a forensic psychologist. "Psychology can explain why somebody would turn rage inward on themselves about the fact that maybe they weren\'t going to keep doing their job and they\'re upset about that and so they\'re suicidal," he said. "But there is no mental illness that explains why somebody then feels entitled to also take that rage and turn it outward on 149 other people who had nothing to do with the person\'s problems." Germanwings crash compensation: What we know . Who was the captain of Germanwings Flight 9525? CNN\'s Margot Haddad reported from Marseille and Pamela Brown from Dusseldorf, while Laura Smith-Spark wrote from London. CNN\'s Frederik Pleitgen, Pamela Boykoff, Antonia Mortensen, Sandrine Amiel and Anna-Maja Rappard contributed to this report.' # @noqa
SHORTER_ARTICLE = '(CNN)The Palestinian Authority officially became the 123rd member of the International Criminal Court on Wednesday, a step that gives the court jurisdiction over alleged crimes in Palestinian territories. The formal accession was marked with a ceremony at The Hague, in the Netherlands, where the court is based. The Palestinians signed the ICC\'s founding Rome Statute in January, when they also accepted its jurisdiction over alleged crimes committed "in the occupied Palestinian territory, including East Jerusalem, since June 13, 2014." Later that month, the ICC opened a preliminary examination into the situation in Palestinian territories, paving the way for possible war crimes investigations against Israelis. As members of the court, Palestinians may be subject to counter-charges as well. Israel and the United States, neither of which is an ICC member, opposed the Palestinians\' efforts to join the body. But Palestinian Foreign Minister Riad al-Malki, speaking at Wednesday\'s ceremony, said it was a move toward greater justice. "As Palestine formally becomes a State Party to the Rome Statute today, the world is also a step closer to ending a long era of impunity and injustice," he said, according to an ICC news release. "Indeed, today brings us closer to our shared goals of justice and peace." Judge Kuniko Ozaki, a vice president of the ICC, said acceding to the treaty was just the first step for the Palestinians. "As the Rome Statute today enters into force for the State of Palestine, Palestine acquires all the rights as well as responsibilities that come with being a State Party to the Statute. These are substantive commitments, which cannot be taken lightly," she said. Rights group Human Rights Watch welcomed the development. "Governments seeking to penalize Palestine for joining the ICC should immediately end their pressure, and countries that support universal acceptance of the court\'s treaty should speak out to welcome its membership," said Balkees Jarrah, international justice counsel for the group. "What\'s objectionable is the attempts to undermine international justice, not Palestine\'s decision to join a treaty to which over 100 countries around the world are members." In January, when the preliminary ICC examination was opened, Israeli Prime Minister Benjamin Netanyahu described it as an outrage, saying the court was overstepping its boundaries. The United States also said it "strongly" disagreed with the court\'s decision. "As we have said repeatedly, we do not believe that Palestine is a state and therefore we do not believe that it is eligible to join the ICC," the State Department said in a statement. It urged the warring sides to resolve their differences through direct negotiations. "We will continue to oppose actions against Israel at the ICC as counterproductive to the cause of peace," it said. But the ICC begs to differ with the definition of a state for its purposes and refers to the territories as "Palestine." While a preliminary examination is not a formal investigation, it allows the court to review evidence and determine whether to investigate suspects on both sides. Prosecutor Fatou Bensouda said her office would "conduct its analysis in full independence and impartiality." The war between Israel and Hamas militants in Gaza last summer left more than 2,000 people dead. The inquiry will include alleged war crimes committed since June. The International Criminal Court was set up in 2002 to prosecute genocide, crimes against humanity and war crimes. CNN\'s Vasco Cotovio, Kareem Khadder and Faith Karimi contributed to this report.'
IRAN_ARTICLE = "(CNN)The United States and its negotiating partners reached a very strong framework agreement with Iran in Lausanne, Switzerland, on Thursday that limits Iran's nuclear program in such a way as to effectively block it from building a nuclear weapon. Expect pushback anyway, if the recent past is any harbinger. Just last month, in an attempt to head off such an agreement, House Speaker John Boehner invited Israeli Prime Minister Benjamin Netanyahu to preemptively blast it before Congress, and 47 senators sent a letter to the Iranian leadership warning them away from a deal. The debate that has already begun since the announcement of the new framework will likely result in more heat than light. It will not be helped by the gathering swirl of dubious assumptions and doubtful assertions. Let us address some of these: . The most misleading assertion, despite universal rejection by experts, is that the negotiations' objective at the outset was the total elimination of any nuclear program in Iran. That is the position of Netanyahu and his acolytes in the U.S. Congress. But that is not and never was the objective. If it had been, there would have been no Iranian team at the negotiating table. Rather, the objective has always been to structure an agreement or series of agreements so that Iran could not covertly develop a nuclear arsenal before the United States and its allies could respond. The new framework has exceeded expectations in achieving that goal. It would reduce Iran's low-enriched uranium stockpile, cut by two-thirds its number of installed centrifuges and implement a rigorous inspection regime. Another dubious assumption of opponents is that the Iranian nuclear program is a covert weapons program. Despite sharp accusations by some in the United States and its allies, Iran denies having such a program, and U.S. intelligence contends that Iran has not yet made the decision to build a nuclear weapon. Iran's continued cooperation with International Atomic Energy Agency inspections is further evidence on this point, and we'll know even more about Iran's program in the coming months and years because of the deal. In fact, the inspections provisions that are part of this agreement are designed to protect against any covert action by the Iranians. What's more, the rhetoric of some members of Congress has implied that the negotiations have been between only the United States and Iran (i.e., the 47 senators' letter warning that a deal might be killed by Congress or a future president). This of course is not the case. The talks were between Iran and the five permanent members of the U.N. Security Council (United States, United Kingdom, France, China and Russia) plus Germany, dubbed the P5+1. While the United States has played a leading role in the effort, it negotiated the terms alongside its partners. If the agreement reached by the P5+1 is rejected by Congress, it could result in an unraveling of the sanctions on Iran and threaten NATO cohesion in other areas. Another questionable assertion is that this agreement contains a sunset clause, after which Iran will be free to do as it pleases. Again, this is not the case. Some of the restrictions on Iran's nuclear activities, such as uranium enrichment, will be eased or eliminated over time, as long as 15 years. But most importantly, the framework agreement includes Iran's ratification of the Additional Protocol, which allows IAEA inspectors expanded access to nuclear sites both declared and nondeclared. This provision will be permanent. It does not sunset. Thus, going forward, if Iran decides to enrich uranium to weapons-grade levels, monitors will be able to detect such a move in a matter of days and alert the U.N. Security Council. Many in Congress have said that the agreement should be a formal treaty requiring the Senate to \"advise and consent.\" But the issue is not suited for a treaty. Treaties impose equivalent obligations on all signatories. For example, the New START treaty limits Russia and the United States to 1,550 deployed strategic warheads. But any agreement with Iran will not be so balanced. The restrictions and obligations in the final framework agreement will be imposed almost exclusively on Iran. The P5+1 are obligated only to ease and eventually remove most but not all economic sanctions, which were imposed as leverage to gain this final deal. Finally some insist that any agreement must address Iranian missile programs, human rights violations or support for Hamas or Hezbollah. As important as these issues are, and they must indeed be addressed, they are unrelated to the most important aim of a nuclear deal: preventing a nuclear Iran. To include them in the negotiations would be a poison pill. This agreement should be judged on its merits and on how it affects the security of our negotiating partners and allies, including Israel. Those judgments should be fact-based, not based on questionable assertions or dubious assumptions."
ARTICLE_SUBWAY = 'New York (CNN)When Liana Barrientos was 23 years old, she got married in Westchester County, New York. A year later, she got married again in Westchester County, but to a different man and without divorcing her first husband. Only 18 days after that marriage, she got hitched yet again. Then, Barrientos declared "I do" five more times, sometimes only within two weeks of each other. In 2010, she married once more, this time in the Bronx. In an application for a marriage license, she stated it was her "first and only" marriage. Barrientos, now 39, is facing two criminal counts of "offering a false instrument for filing in the first degree," referring to her false statements on the 2010 marriage license application, according to court documents. Prosecutors said the marriages were part of an immigration scam. On Friday, she pleaded not guilty at State Supreme Court in the Bronx, according to her attorney, Christopher Wright, who declined to comment further. After leaving court, Barrientos was arrested and charged with theft of service and criminal trespass for allegedly sneaking into the New York subway through an emergency exit, said Detective Annette Markowski, a police spokeswoman. In total, Barrientos has been married 10 times, with nine of her marriages occurring between 1999 and 2002. All occurred either in Westchester County, Long Island, New Jersey or the Bronx. She is believed to still be married to four men, and at one time, she was married to eight men at once, prosecutors say. Prosecutors said the immigration scam involved some of her husbands, who filed for permanent residence status shortly after the marriages. Any divorces happened only after such filings were approved. It was unclear whether any of the men will be prosecuted. The case was referred to the Bronx District Attorney\'s Office by Immigration and Customs Enforcement and the Department of Homeland Security\'s Investigation Division. Seven of the men are from so-called "red-flagged" countries, including Egypt, Turkey, Georgia, Pakistan and Mali. Her eighth husband, Rashid Rajput, was deported in 2006 to his native Pakistan after an investigation by the Joint Terrorism Task Force. If convicted, Barrientos faces up to four years in prison. Her next court appearance is scheduled for May 18.'
expected_summaries = [
'prosecutor: "so far no videos were used in the crash investigation" two magazines claim to have found a cell phone video of the final seconds . "one can hear cries of \'My God\' in several languages," one magazine says .',
"the formal accession was marked by a ceremony at The Hague, in the Netherlands . the ICC opened a preliminary examination into the situation in the occupied Palestinian territory . as members of the court, Palestinians may be subject to counter-charges as well .",
"the u.s. and its negotiating partners reached a very strong framework agreement with Iran . aaron miller: the debate that has already begun since the announcement of the new framework will likely result in more heat than light . the deal would reduce Iran's low-enriched uranium stockpile, cut centrifuges and implement a rigorous inspection regime .",
'prosecutors say the marriages were part of an immigration scam . if convicted, barrientos faces two criminal counts of "offering a false instrument for filing in the first degree" she has been married 10 times, with nine of her marriages occurring between 1999 and 2002 .',
]
text_vec, _ = padded_tensor([
self.agent.dict.txt2vec(cfg['prefix'] + s) for s in
[FRANCE_ARTICLE, SHORTER_ARTICLE, IRAN_ARTICLE, ARTICLE_SUBWAY]
])
self.assertEqual(512, text_vec.shape[1])
generations, _ = self.agent._generate(
Batch(text_vec=text_vec.to(device)),
beam_size=4,
max_ts=142,
overrides={
'max_length': 142,
'min_length': 56
},
)
decoded = [
self.agent.dict.vec2txt(g[0], clean_up_tokenization_spaces=False)
for g in generations
]
self.assertListEqual(expected_summaries, decoded)
def batchify(self, obs_batch):
"""
Air custom batchify, which passes along the intent.
Following the docstring of TorchAgent.batchify, it calls super, then
uses an extended version of the torch_agent.Batch namedtuple.
The purpose of extending the info is to keep track of some custom
metrics.
"""
#import ipdb; ipdb.set_trace()
batch = super().batchify(obs_batch)
reordered_observations = [obs_batch[i] for i in batch.valid_indices]
is_training = 'labels' in reordered_observations[0]
# first parse and compile all the knowledge together
all_knowledges = [
] # list-of-lists knowledge items for each observation
all_reservations = [] # list of reservations for each observation
knowledge_counts = [] # how much knowledge each observation gets
for obs in reordered_observations:
all_knowledges.append(obs['tickets'])
all_reservations.append(obs['reservation'])
knowledge_counts.append(len(obs['tickets']))
# now we want to actually pack this into a tensor, along with the mask
N = len(reordered_observations)
K = max(knowledge_counts)
# round out the array so everything is equally sized
for i in range(N):
all_knowledges[i] += [''] * (K - knowledge_counts[i])
flattened_knowledge = list(chain(*all_knowledges))
knowledge_vec = [
self._vectorize_text(
# the beginning of the sentence is more useful
k,
truncate=self.truncate,
add_end=True,
truncate_left=False,
) for k in flattened_knowledge
]
knowledge_vec, _ = padded_tensor(knowledge_vec, self.NULL_IDX,
self.use_cuda)
#import ipdb; ipdb.set_trace() # check if the following line is valid
T = knowledge_vec.size(-1)
knowledge_vec = knowledge_vec.view(N, K, T)
# knowledge mask is a N x K tensor saying which items we're allowed to
# attend over
ck_mask = th.zeros(N, K, dtype=th.uint8)
for i, klen in enumerate(knowledge_counts):
ck_mask[i, :klen] = 1
ck_mask = ck_mask != 0 # for pytorch 1.0/1.2 uint8/bool compatibility
# and the correct labels
# gather reservation vector
reservation_vec = [
self._vectorize_text(
# the beginning of the sentence is more useful
r,
truncate=self.truncate,
add_end=True,
truncate_left=False,
) for r in all_reservations
]
reservation_vec, _ = padded_tensor(reservation_vec, self.NULL_IDX,
self.use_cuda)
# gather action
intent_ids = []
status_ids = []
flight_ids = []
is_outputact = []
name_vec = []
has_res = []
for obs in reordered_observations:
intent_ids.append(INTENT_DICT[obs['action_intent']])
if obs['action_status'] == 'change':
import ipdb
ipdb.set_trace()
status_ids.append(STATUS_DICT[obs['action_status']])
if len(obs['action_flight']) == 0:
flight_ids.append(0)
else:
flight_ids.append(obs['action_flight'][0] - 1000 + 1)
name_vec.append(
self._vectorize_text(
obs['action_name'],
truncate=self.name_vec_len,
truncate_left=False,
))
is_outputact.append(obs['episode_done'])
has_res.append(False if obs['reservation'].lower().
startswith('reservation none') else True)
intent_ids = th.LongTensor(intent_ids)
status_ids = th.LongTensor(status_ids)
flight_ids = th.LongTensor(flight_ids)
is_outputact = th.BoolTensor(is_outputact)
has_res = th.BoolTensor(has_res)
name_vec, name_vec_len = padded_tensor(name_vec,
self.NULL_IDX,
self.use_cuda,
max_len=self.name_vec_len)
if max(name_vec_len) > self.name_vec_len:
print(f"OOD Name! {name_vec.shape[1]} increase name-vec-len")
import ipdb
ipdb.set_trace()
# cuda
if self.use_cuda:
knowledge_vec = knowledge_vec.cuda()
reservation_vec = reservation_vec.cuda()
ck_mask = ck_mask.cuda()
intent_ids = intent_ids.cuda()
status_ids = status_ids.cuda()
flight_ids = flight_ids.cuda()
name_vec = name_vec.cuda()
is_outputact = is_outputact.cuda()
has_res = has_res.cuda()
batch['know_vec'] = knowledge_vec
batch['ck_mask'] = ck_mask
batch['knowledge'] = np.array(flattened_knowledge).reshape(N, K)
batch['res_vec'] = reservation_vec
batch['intent_ids'] = intent_ids
batch['status_ids'] = status_ids
batch['flight_ids'] = flight_ids
batch['name_vec'] = name_vec
batch['is_outputact'] = is_outputact
batch['has_res'] = has_res
# import ipdb; ipdb.set_trace()
return batch
def access_long_term_memory(
self,
query_vec: torch.LongTensor,
memory_indices: torch.LongTensor,
memory_vec: Optional[torch.LongTensor],
num_memories: torch.LongTensor,
memory_decoder_vec: Optional[torch.LongTensor],
generated_memories: List[List[str]],
) -> Tuple[Optional[List[List[Document]]], Optional[torch.Tensor]]:
"""
Access long term memory.
:param query_vec:
retrieval vector for the long-term memory
:param memory_indices:
indices to access memory slots
:param memory_vec:
extracted memories from the observation
:param num_memories:
bsz-length tensor corresponding to number of memories per batch item
:param memory_decoder_vec:
input to the memory decoder
:param generated_memories:
memories generated by the memory decoder
:return memories, memory_scores:
return memories and memory scores, if there are memories retrieved
"""
start = time.time()
memories = None
memory_scores = None
memory_dict = {}
indices = memory_indices.tolist()
if memory_vec is not None:
# Only look in memory_vec for batch elements with memories
memory_ids = [m for m in indices if num_memories[m] > 0]
memory_dict = {
batch_id: memory_vec[batch_id, :num_memories[mem_id]]
for batch_id, mem_id in enumerate(memory_ids)
}
if memory_decoder_vec is not None:
for batch_id in indices:
new_mems_i = generated_memories[batch_id]
if not new_mems_i:
continue
tokenized = [
self.long_term_memory.tokenize_query(m)
for m in generated_memories[batch_id]
]
if batch_id in memory_dict:
tokenized += memory_dict[batch_id].tolist()
new_mems_i, _ = padded_tensor(
tokenized,
pad_idx=self.dict[self.dict.null_token] # type: ignore
)
memory_dict[batch_id] = new_mems_i.to(query_vec)
if self.knowledge_access_method in [
KnowledgeAccessMethod.ALL,
KnowledgeAccessMethod.MEMORY_ONLY,
]:
# Add dummy memories just in case we are retrieving from memories
if memory_vec is not None:
seqlen = memory_vec.size(-1)
elif memory_decoder_vec is not None:
seqlen = memory_decoder_vec.size(-1)
else:
seqlen = query_vec.size(-1)
for batch_id in indices:
if batch_id not in memory_dict:
memory_dict[batch_id] = torch.zeros(1,
seqlen).to(query_vec)
if memory_dict:
# first make sure all memories are padded to the same length.
max_length = max([m.size(-1) for m in memory_dict.values()])
for batch_id in memory_dict:
vec = memory_dict[batch_id]
if vec.size(-1) < max_length:
memory_dict[batch_id] = torch.cat(
[
vec,
torch.zeros(
(*vec.shape[:-1],
max_length - vec.size(-1))).fill_(
self.dict[self.dict.null_token]).to(vec),
],
dim=1,
)
self.long_term_memory.write_memory(memory_dict) # type: ignore
logging.debug(f'Write Memory Complete: {time.time() - start:.2f}')
if self.long_term_memory.has_memory():
memories, memory_scores = self.long_term_memory.retrieve(
query_vec[memory_indices] # type: ignore
)
logging.debug(
f'Memory Retrieval Complete: {time.time() - start:.2f}')
logging.debug(f'memories: {memories}')
logging.verbose('Reading from Memory')
return memories, memory_scores
def batchify(self, obs_batch, sort=False):
"""
Create a batch of valid observations from an unchecked batch.
A valid observation is one that passes the lambda provided to the
function, which defaults to checking if the preprocessed 'text_vec'
field is present which would have been set by this agent's 'vectorize'
function.
Returns a namedtuple Batch. See original definition above for in-depth
explanation of each field.
If you want to include additonal fields in the batch, you can subclass
this function and return your own "Batch" namedtuple: copy the Batch
namedtuple at the top of this class, and then add whatever additional
fields that you want to be able to access. You can then call
super().batchify(...) to set up the original fields and then set up the
additional fields in your subclass and return that batch instead.
:param obs_batch:
List of vectorized observations
:param sort:
Default False, orders the observations by length of vectors. Set to
true when using torch.nn.utils.rnn.pack_padded_sequence. Uses the text
vectors if available, otherwise uses the label vectors if available.
"""
if len(obs_batch) == 0:
return Batch()
valid_obs = [(i, ex) for i, ex in enumerate(obs_batch)
if self.is_valid(ex)]
if len(valid_obs) == 0:
return Batch()
valid_inds, exs = zip(*valid_obs)
# TEXT
xs, x_lens, context_lens, floors = None, None, None, None
if any('text_vec' in ex for ex in exs):
_xs = [ex.get('text_vec', [self.EMPTY]) for ex in exs]
xs = padded_3d(
_xs,
self.NULL_IDX,
self.use_cuda,
fp16friendly=self.opt.get('fp16'),
)
x_lens = (xs != self.NULL_IDX).sum(dim=-1) # bsz, context_len
context_lens = (x_lens != 0).sum(dim=-1) # bsz
floors, _ = padded_tensor(
[make_floor(c_len.item()) for c_len in context_lens],
use_cuda=self.use_cuda)
# We do not sort on the xs which in the shape of [bsz, context_len, utt_len] is this agent
# if sort:
# sort = False # now we won't sort on labels
# xs, x_lens, valid_inds, exs = argsort(
# x_lens, xs, x_lens, valid_inds, exs, descending=True
# )
# LABELS
labels_avail = any('labels_vec' in ex for ex in exs)
some_labels_avail = (labels_avail
or any('eval_labels_vec' in ex for ex in exs))
ys, y_lens, labels = None, None, None
if some_labels_avail:
field = 'labels' if labels_avail else 'eval_labels'
label_vecs = [ex.get(field + '_vec', self.EMPTY) for ex in exs]
labels = [ex.get(field + '_choice') for ex in exs]
y_lens = [y.shape[0] for y in label_vecs]
ys, y_lens = padded_tensor(label_vecs,
self.NULL_IDX,
self.use_cuda,
fp16friendly=self.opt.get('fp16'))
y_lens = torch.LongTensor(y_lens)
if self.use_cuda:
y_lens = y_lens.cuda()
# We do not sort examples in batch for this agent
# if sort and xs is None:
# ys, valid_inds, label_vecs, labels, y_lens = argsort(
# y_lens, ys, valid_inds, label_vecs, labels, y_lens,
# descending=True
# )
# LABEL_CANDIDATES
cands, cand_vecs = None, None
if any('label_candidates_vecs' in ex for ex in exs):
cands = [ex.get('label_candidates', None) for ex in exs]
cand_vecs = [ex.get('label_candidates_vecs', None) for ex in exs]
# IMAGE
imgs = None
if any('image' in ex for ex in exs):
imgs = [ex.get('image', None) for ex in exs]
return Batch(text_vec=xs,
text_lengths=x_lens,
context_lens=context_lens,
floors=floors,
label_vec=ys,
label_lengths=y_lens,
labels=labels,
valid_indices=valid_inds,
candidates=cands,
candidate_vecs=cand_vecs,
image=imgs,
observations=exs)
def batchify(self, obs_batch):
"""
Wizard custom batchify, which passes along the knowledge/title.
Following the docstring of TorchAgent.batchify, it calls super, then
uses an extended version of the torch_agent.Batch namedtuple.
The purpose of extending the info is to keep track of some custom
metrics.
"""
batch = super().batchify(obs_batch)
reordered_observations = [obs_batch[i] for i in batch.valid_indices]
is_training = 'labels' in reordered_observations[0]
# first parse and compile all the knowledge together
all_knowledges = [
] # list-of-lists knowledge items for each observation
knowledge_counts = [] # how much knowledge each observation gets
for obs in reordered_observations:
obs_know = self._parse_knowledge(obs)
# downsample if desired
if (is_training and self.max_knowledge
and len(obs_know) > self.max_knowledge):
# offset by one so that we don't choose 0
keepers = 1 + np.random.choice(
len(obs_know) - 1, self.max_knowledge, False)
# correct answer is always the first one
keepers[0] = 0
obs_know = [obs_know[i] for i in keepers]
all_knowledges.append(obs_know)
knowledge_counts.append(len(obs_know))
# now we want to actually pack this into a tensor, along with the mask
N = len(reordered_observations)
K = max(knowledge_counts)
# round out the array so everything is equally sized
for i in range(N):
all_knowledges[i] += [''] * (K - knowledge_counts[i])
flattened_knowledge = list(chain(*all_knowledges))
knowledge_vec = [
self._vectorize_text(
# the beginning of the sentence is more useful
k,
truncate=self.knowledge_truncate,
add_end=True,
truncate_left=False,
) for k in flattened_knowledge
]
knowledge_vec, _ = padded_tensor(knowledge_vec,
self.NULL_IDX,
self.use_cuda,
left_padded=True)
knowledge_vec[:, -1] = self.END_IDX
T = knowledge_vec.size(-1)
knowledge_vec = knowledge_vec.view(N, K, T)
# knowledge mask is a N x K tensor saying which items we're allowed to
# attend over
bsz = len(reordered_observations)
ck_mask = th.zeros(bsz, K, dtype=th.uint8)
for i, klen in enumerate(knowledge_counts):
ck_mask[i, :klen] = 1
ck_mask = ck_mask != 0 # for pytorch 1.0/1.2 uint8/bool compatibility
# and the correct labels
cs_ids = th.LongTensor(bsz).zero_()
if self.use_cuda:
knowledge_vec = knowledge_vec.cuda()
ck_mask = ck_mask.cuda()
cs_ids = cs_ids.cuda()
batch['know_vec'] = knowledge_vec
batch['ck_mask'] = ck_mask
batch['cs_ids'] = cs_ids
batch['use_cs_ids'] = is_training
batch['knowledge'] = np.array(flattened_knowledge).reshape(N, K)
return batch
samp_response_ids = _check_truncate([
vocab.get(token.strip(), vocab['<UNK>'])
for token in samp_response.split()
],
max_len,
truncate_left=False)
samples_context_ids_arr.append(samp_context_ids)
samples_response_ids_arr.append(samp_response_ids)
# padding
# max_len = max(max([len(u) for u in context_ids]), len(response_ids))
# max_len = max(max_len, max([len(u) for c in samples_context_ids_arr for u in c]))
# max_len = max(max_len, max([len(r) for r in samples_response_ids_arr]))
context_ids_duplicated = [
padded_tensor(context_ids, max_len=max_len,
left_padded=True)[0]
for _ in samples_context_ids_arr
]
response_ids_duplicated = [
response_ids for _ in samples_response_ids_arr
]
samples_context_ids_arr = [
padded_tensor(samp_context_ids,
max_len=max_len,
left_padded=True)[0]
for samp_context_ids in samples_context_ids_arr
]
context_ids_duplicated_padded = padded_3d(context_ids_duplicated,
max_len=max_len,
def concat_docs_and_input(
self,
input: torch.LongTensor,
input_lengths: torch.LongTensor,
top_docs: List[List[Document]],
max_num_docs: int,
right_padded: bool = True,
) -> torch.LongTensor:
"""
Add document tokens to input tokens.
:param input:
original input tokens
:param input_lengths:
original input lengths
:param top_docs:
list of n_docs top documents for each input sequence
:param max_num_docs:
maximum number of docs out of all examples
:param right_padded:
whether the input is right padded.
:return (tokens, lengths):
return expanded token vectors & corresponding lengths
"""
max_len = self.expanded_input_truncate
expanded_input = []
for i, docs in enumerate(top_docs):
for rank in range(len(docs)):
input_i = input[i, :]
doc = docs[rank]
doc_tokens = self.dict.txt2vec(doc.get_passage_str())
if self.generation_model == 'bart' and self.n_extra_positions <= 0:
# move SOS to start of passage since we append question to end
input_i = input_i[1:]
sample_doc_tokens = torch.LongTensor([self.start_idx] +
doc_tokens).to(input)
else:
sample_doc_tokens = torch.LongTensor(doc_tokens).to(input)
if self.n_extra_positions <= 0:
# Prepend document to text
input_i_len = input_lengths[i]
new_input_length = min(
self.expanded_input_truncate -
self.min_doc_token_length,
input_i_len,
)
if right_padded:
input_i = input_i[input_i_len -
new_input_length:input_i_len]
else:
input_i = input_i[input_i.size(0) - new_input_length:]
doc_max_len = max(max_len - len(input_i), 0)
sample_doc_tokens = sample_doc_tokens[:doc_max_len]
expanded_input.append(
torch.cat([sample_doc_tokens, input_i])[:max_len])
else:
# Append Document to text
sample_doc_tokens = sample_doc_tokens[:max_len]
input_i_new = input_i.new(self.n_positions -
self.n_extra_positions).fill_(
self.pad_idx)
input_i_new[input_i_new.size(0) -
input_i.size(0):] = input_i
expanded_input.append(
torch.cat([input_i_new, sample_doc_tokens]))
# append extra null inputs if there are diff # of docs per input
expanded_input += [
input[i, :].new(input[i, :].size()).fill_(self.pad_idx)
] * (max_num_docs - len(docs))
expanded_input, _ = padded_tensor(
expanded_input,
fp16friendly=self.fp16 and right_padded,
max_len=max_len if self.n_extra_positions <= 0 else None,
pad_idx=self.pad_idx,
left_padded=not right_padded,
)
expanded_input = expanded_input.to(input.device)
return expanded_input # type: ignore
def _build_candidates(self, batch, source, mode):
"""
Build a candidate set for this batch.
:param batch:
a Batch object (defined in torch_agent.py)
:param source:
the source from which candidates should be built, one of
['batch', 'batch-all-cands', 'inline', 'fixed']
:param mode:
'train' or 'eval'
:return: tuple of tensors (label_inds, cands, cand_vecs)
label_inds: A [bsz] LongTensor of the indices of the labels for each
example from its respective candidate set
cands: A [num_cands] list of (text) candidates
OR a [batchsize] list of such lists if source=='inline'
cand_vecs: A padded [num_cands, seqlen] LongTensor of vectorized candidates
OR a [batchsize, num_cands, seqlen] LongTensor if source=='inline'
Possible sources of candidates:
* batch: the set of all labels in this batch
Use all labels in the batch as the candidate set (with all but the
example's label being treated as negatives).
Note: with this setting, the candidate set is identical for all
examples in a batch. This option may be undesirable if it is possible
for duplicate labels to occur in a batch, since the second instance of
the correct label will be treated as a negative.
* batch-all-cands: the set of all candidates in this batch
Use all candidates in the batch as candidate set.
Note 1: This can result in a very large number of candidates.
Note 2: In this case we will deduplicate candidates.
Note 3: just like with 'batch' the candidate set is identical
for all examples in a batch.
* inline: batch_size lists, one list per example
If each example comes with a list of possible candidates, use those.
Note: With this setting, each example will have its own candidate set.
* fixed: one global candidate list, provided in a file from the user
If self.fixed_candidates is not None, use a set of fixed candidates for
all examples.
Note: this setting is not recommended for training unless the
universe of possible candidates is very small.
* vocab: one global candidate list, extracted from the vocabulary with the
exception of self.NULL_IDX.
"""
label_vecs = batch.label_vec # [bsz] list of lists of LongTensors
label_inds = None
batchsize = (
batch.text_vec.size(0)
if batch.text_vec is not None
else batch.image.size(0)
)
if label_vecs is not None:
assert label_vecs.dim() == 2
if source == 'batch':
warn_once(
'[ Executing {} mode with batch labels as set of candidates. ]'
''.format(mode)
)
if batchsize == 1:
warn_once(
"[ Warning: using candidate source 'batch' and observed a "
"batch of size 1. This may be due to uneven batch sizes at "
"the end of an epoch. ]"
)
if label_vecs is None:
raise ValueError(
"If using candidate source 'batch', then batch.label_vec cannot be "
"None."
)
cands = batch.labels
cand_vecs = label_vecs
label_inds = label_vecs.new_tensor(range(batchsize))
elif source == 'batch-all-cands':
warn_once(
'[ Executing {} mode with all candidates provided in the batch ]'
''.format(mode)
)
if batch.candidate_vecs is None:
raise ValueError(
"If using candidate source 'batch-all-cands', then batch."
"candidate_vecs cannot be None. If your task does not have "
"inline candidates, consider using one of "
"--{m}={{'batch','fixed','vocab'}}."
"".format(m='candidates' if mode == 'train' else 'eval-candidates')
)
# initialize the list of cands with the labels
cands = []
all_cands_vecs = []
# dictionary used for deduplication
cands_to_id = {}
for i, cands_for_sample in enumerate(batch.candidates):
for j, cand in enumerate(cands_for_sample):
if cand not in cands_to_id:
cands.append(cand)
cands_to_id[cand] = len(cands_to_id)
all_cands_vecs.append(batch.candidate_vecs[i][j])
cand_vecs, _ = padded_tensor(
all_cands_vecs,
self.NULL_IDX,
use_cuda=self.use_cuda,
fp16friendly=self.fp16,
)
label_inds = label_vecs.new_tensor(
[cands_to_id[label] for label in batch.labels]
)
elif source == 'inline':
warn_once(
'[ Executing mode with provided inline set of candidates ]'
)
warn_once(mode)
print(batch.candidates)
if batch.candidate_vecs is None:
raise ValueError(
"If using candidate source 'inline', then batch.candidate_vecs "
"cannot be None. If your task does not have inline candidates, "
"consider using one of --{m}={{'batch','fixed','vocab'}}."
"".format(m='candidates' if mode == 'train' else 'eval-candidates')
)
cands = batch.candidates
cand_vecs = padded_3d(
batch.candidate_vecs,
self.NULL_IDX,
use_cuda=self.use_cuda,
fp16friendly=self.fp16,
)
if label_vecs is not None:
label_inds = label_vecs.new_empty((batchsize))
bad_batch = False
for i, label_vec in enumerate(label_vecs):
label_vec_pad = label_vec.new_zeros(cand_vecs[i].size(1)).fill_(
self.NULL_IDX
)
if cand_vecs[i].size(1) < len(label_vec):
label_vec = label_vec[0 : cand_vecs[i].size(1)]
label_vec_pad[0 : label_vec.size(0)] = label_vec
label_inds[i] = self._find_match(cand_vecs[i], label_vec_pad)
if label_inds[i] == -1:
bad_batch = True
if bad_batch:
if self.ignore_bad_candidates and not self.is_training:
label_inds = None
else:
raise RuntimeError(
'At least one of your examples has a set of label candidates '
'that does not contain the label. To ignore this error '
'set `--ignore-bad-candidates True`.'
)
elif source == 'fixed':
if self.fixed_candidates is None:
raise ValueError(
"If using candidate source 'fixed', then you must provide the path "
"to a file of candidates with the flag --fixed-candidates-path or "
"the name of a task with --fixed-candidates-task."
)
warn_once(
"[ Executing {} mode with a common set of fixed candidates "
"(n = {}). ]".format(mode, len(self.fixed_candidates))
)
cands = self.fixed_candidates
cand_vecs = self.fixed_candidate_vecs
if label_vecs is not None:
label_inds = label_vecs.new_empty((batchsize))
bad_batch = False
for batch_idx, label_vec in enumerate(label_vecs):
max_c_len = cand_vecs.size(1)
label_vec_pad = label_vec.new_zeros(max_c_len).fill_(self.NULL_IDX)
if max_c_len < len(label_vec):
label_vec = label_vec[0:max_c_len]
label_vec_pad[0 : label_vec.size(0)] = label_vec
label_inds[batch_idx] = self._find_match(cand_vecs, label_vec_pad)
if label_inds[batch_idx] == -1:
bad_batch = True
if bad_batch:
if self.ignore_bad_candidates and not self.is_training:
label_inds = None
else:
raise RuntimeError(
'At least one of your examples has a set of label candidates '
'that does not contain the label. To ignore this error '
'set `--ignore-bad-candidates True`.'
)
elif source == 'vocab':
warn_once(
'[ Executing {} mode with tokens from vocabulary as candidates. ]'
''.format(mode)
)
cands = self.vocab_candidates
cand_vecs = self.vocab_candidate_vecs
# NOTE: label_inds is None here, as we will not find the label in
# the set of vocab candidates
else:
raise Exception("Unrecognized source: %s" % source)
return (cands, cand_vecs, label_inds)
