def predictKTacticsWithLoss_batch(self, in_data : List[TacticContext], k : int, corrects : List[str]) -> \ Tuple[List[List[Prediction]], float]: assert self._embedding assert self.training_args with self._lock: prediction_distributions = self._predictDistributions(in_data) correct_stems = [serapi_instance.get_stem(correct) for correct in corrects] output_var = maybe_cuda(Variable( LongTensor([self._embedding.encode_token(correct_stem) if self._embedding.has_token(correct_stem) else 0 for correct_stem in correct_stems]))) loss = self._criterion(prediction_distributions, output_var).item() if k > self._embedding.num_tokens(): k = self._embedding.num_tokens() certainties_and_idxs_list = \ [single_distribution.view(-1).topk(k) if len(context.hypotheses) > 0 else topk_with_filter(single_distribution.view(-1), k, lambda certainty, idx: not serapi_instance.tacticTakesHypArgs( cast(Embedding, self._embedding).decode_token(idx))) for single_distribution, context in zip(prediction_distributions, in_data)] results = [[Prediction(self.add_arg(self._embedding.decode_token(stem_idx.item()), in_datum.goal, in_datum.hypotheses, self.training_args.max_length), math.exp(certainty.item())) for certainty, stem_idx in zip(*certainties_and_idxs)] for certainties_and_idxs, in_datum in zip(certainties_and_idxs_list, in_data)] return results, loss
def predictKTacticsWithLoss(self, in_data : TacticContext, k : int, correct : str) -> \ Tuple[List[Prediction], float]: assert self.training_args assert self._embedding with self._lock: prediction_distribution = self._predictDistributions([in_data])[0] if k > self._embedding.num_tokens(): k = self._embedding.num_tokens() correct_stem = serapi_instance.get_stem(correct) if self._embedding.has_token(correct_stem): output_var = maybe_cuda(Variable( LongTensor([self._embedding.encode_token(correct_stem)]))) loss = self._criterion(prediction_distribution.view(1, -1), output_var).item() else: loss = 0 if len(in_data.hypotheses) == 0: certainties, idxs = topk_with_filter( prediction_distribution.view(-1), k, lambda certainty, idx: not serapi_instance.tacticTakesHypArgs( cast(Embedding, self._embedding).decode_token(idx))) else: certainties, idxs = prediction_distribution.view(-1).topk(k) results = [Prediction(self.add_arg(self._embedding.decode_token(stem_idx.item()), in_data.goal, in_data.hypotheses, self.training_args.max_length), math.exp(certainty.item())) for certainty, stem_idx in zip(certainties, idxs)] return results, loss
def add_arg(self, tactic_stem : str, goal : str, hyps : List[str], max_length : int): if serapi_instance.tacticTakesHypArgs(tactic_stem): return tactic_stem + " " + \ serapi_instance.get_first_var_in_hyp(get_closest_hyp(hyps, goal, max_length)) \ + "." else: return tactic_stem + "."
def args_vars_in_list(tactic : str, context_list : List[str]) -> bool: stem, args_string = serapi_instance.split_tactic(tactic) args = args_string[:-1].split() if not serapi_instance.tacticTakesHypArgs(stem) and len(args) > 0: return False var_names = serapi_instance.get_vars_in_hyps(context_list) for arg in args: if not arg in var_names: return False return True
def add_args(self, stem_predictions : List[Prediction], goal : str, hyps : List[str], max_length : int): possibilities : List[Prediction] = [] for stem, stem_score in stem_predictions: if serapi_instance.tacticTakesHypArgs(stem): for hyp, hyp_score in get_closest_hyps(hyps, goal, len(stem_predictions), max_length): possibilities.append( Prediction(stem + " " + serapi_instance.get_first_var_in_hyp(hyp) + ".", hyp_score * stem_score)) else: possibilities.append(Prediction(stem + ".", stem_score * 0.5)) return list(sorted(possibilities, key=lambda pred: pred.certainty, reverse=True)[:len(stem_predictions)])
def predictKTacticsWithLoss(self, in_data : TacticContext, k : int, correct : str) -> Tuple[List[Prediction], float]: with self._lock: distribution, hyp_var = self._predictDistribution(in_data) correct_stem = serapi_instance.get_stem(correct) if self._embedding.has_token(correct_stem): loss = self._criterion(distribution.view(1, -1), Variable(LongTensor([self._embedding.encode_token(correct_stem)]))).item() else: loss = float("+inf") indices, probabilities = list_topk(list(distribution), k) predictions : List[Prediction] = [] for certainty, idx in zip(probabilities, indices): stem = self._embedding.decode_token(idx) if serapi_instance.tacticTakesHypArgs(stem): predictions.append(Prediction(stem + " " + hyp_var + ".", math.exp(certainty))) else: predictions.append(Prediction(stem + ".", math.exp(certainty))) return predictions, loss
def predictKTactics(self, in_data : TacticContext, k : int) \ -> List[Prediction]: assert self.training_args assert self._embedding with self._lock: prediction_distribution = self._predictDistributions([in_data])[0] if k > self._embedding.num_tokens(): k = self._embedding.num_tokens() if len(in_data.hypotheses) == 0: certainties, idxs = topk_with_filter( prediction_distribution.view(-1), k, lambda certainty, idx: not serapi_instance.tacticTakesHypArgs( cast(Embedding, self._embedding).decode_token(idx))) else: certainties, idxs = prediction_distribution.view(-1).topk(k) results = self.add_args([Prediction(self._embedding.decode_token(stem_idx.item()), math.exp(certainty.item())) for certainty, stem_idx in zip(certainties, idxs)], in_data.goal, in_data.hypotheses, self.training_args.max_length) return results