def get_mistakes(truth_mask: torch.ByteTensor, dataset: MorphoDataset,
inputs: torch.LongTensor, predictions: torch.LongTensor,
targets: torch.LongTensor) -> List[List[str]]:
inputs, predictions, targets = inputs.numpy(), predictions.numpy(
), targets.numpy()
mistakes = []
for i in range(inputs.shape[0]):
if truth_mask[i].item() == 1: continue
before = ""
for k in range(max(0, i - 4), i):
before += get_example(inputs[k, :],
dataset.data[dataset.FORMS].alphabet) + ' '
form = get_example(inputs[i, :], dataset.data[dataset.FORMS].alphabet)
gold_lemma = get_example(targets[i, :],
dataset.data[dataset.LEMMAS].alphabet)
system_lemma = get_example(predictions[i, :],
dataset.data[dataset.LEMMAS].alphabet)
after = ""
for k in range(min(inputs.shape[0] - 1, i + 1),
min(inputs.shape[0] - 1, i + 5)):
after += get_example(inputs[k, :],
dataset.data[dataset.FORMS].alphabet) + ' '
mistakes.append([before, form, gold_lemma, system_lemma, after])
return mistakes
def resample(train, val, test : torch.LongTensor, path, idx_map, rewrite=True):
if os.path.exists(path+'train_inductive.map'):
rewrite = False
filenames = ['train', 'unlabeled', 'vali', 'test']
ans = []
for file in filenames:
with open(path+file+'_inductive.map', 'r') as f:
cache = []
for line in f:
cache.append(idx_map.get(int(line)))
ans.append(torch.LongTensor(cache))
return ans
idx_train = train
idx_test = val
cache = list(test.numpy())
shuffle(cache)
idx_val = cache[: idx_train.shape[0]]
idx_unlabeled = cache[idx_train.shape[0]: ]
idx_val = torch.LongTensor(idx_val)
idx_unlabeled = torch.LongTensor(idx_unlabeled)
print("\n\ttrain: ", idx_train.shape[0],
"\n\tunlabeled: ", idx_unlabeled.shape[0],
"\n\tvali: ", idx_val.shape[0],
"\n\ttest: ", idx_test.shape[0])
if rewrite:
idx_map_reverse = dict(map(lambda t: (t[1], t[0]), idx_map.items()))
filenames = ['train', 'unlabeled', 'vali', 'test']
ans = [idx_train, idx_unlabeled, idx_val, idx_test]
for i in range(4):
with open(path+filenames[i]+'_inductive.map', 'w') as f:
f.write("\n".join(map(str, map(idx_map_reverse.get, ans[i].numpy()))))
return idx_train, idx_unlabeled, idx_val, idx_test
def decode(
self,
tokens: torch.LongTensor,
skip_special_tokens: bool = True,
remove_bpe: bool = True,
) -> Union[str, List]:
assert tokens.dim() == 1
tokens = tokens.numpy()
if tokens[0] == self.task.source_dictionary.bos(
) and skip_special_tokens:
tokens = tokens[1:] # remove <s>
eos_mask = tokens == self.task.source_dictionary.eos()
doc_mask = eos_mask[1:] & eos_mask[:-1]
sentences = np.split(tokens, doc_mask.nonzero()[0] + 1)
if skip_special_tokens:
sentences = [
np.array(
[c for c in s if c != self.task.source_dictionary.eos()])
for s in sentences
]
sentences = [
" ".join([self.task.source_dictionary.symbols[c] for c in s])
for s in sentences
]
if remove_bpe:
sentences = [self.bpe.decode(s) for s in sentences]
if len(sentences) == 1:
return sentences[0]
return sentences
def xtrans(self, Xc: FloatTensor, Xe: LongTensor) -> FeaturesData:
num_feature_data = Xc.numpy().astype(
np.float32) if self.num_cont != 0 else None
cat_feature_data = Xe.numpy().astype(str).astype(
object) if self.num_enum != 0 else None
return FeaturesData(num_feature_data=num_feature_data,
cat_feature_data=cat_feature_data)
def decode(self, tokens: torch.LongTensor):
assert tokens.dim() == 1
tokens = tokens.numpy()
if tokens[0] == self.task.source_dictionary.bos():
tokens = tokens[1:] # remove <s>
eos_mask = (tokens == self.task.source_dictionary.eos())
doc_mask = eos_mask[1:] & eos_mask[:-1]
sentences = np.split(tokens, doc_mask.nonzero()[0] + 1)
sentences = [self.bpe.decode(self.task.source_dictionary.string(s)) for s in sentences]
if len(sentences) == 1:
return sentences[0]
return sentences
def call(
self, # type: ignore
tokens: Dict[str, torch.LongTensor],
verb_indicator: torch.LongTensor,
training: bool = False,
tags: torch.LongTensor = None,
metadata: List[Dict[str, Any]] = None) -> Dict[str, np.ndarray]:
"""
x2_b is an array where each row is a one hot vector,
where the hot index is the position of the verb in the sequence.
this means x2_b should be embedded, retrieving either a vector with a single 1 or single 0.
"""
# convert torch tensor to numpy
x1_b = tokens['tokens'].numpy()
x2_b = verb_indicator.numpy()
# embed
embedded1 = self.embedding1(x1_b)
embedded2 = self.embedding1(
x2_b
) # returns one of two trainable vectors of length params.binary_feature_dim
mask = self.embedding1.compute_mask(x1_b)
# encode
encoded_lm0 = tf.concat(
[embedded1, embedded2],
axis=2) # [batch_size, max_seq_len, embed_size + feature dim]
encoded_lm1 = None # encoding at layer minus 1
for layer, lstm in enumerate(self.lstms):
encoded_lm2 = encoded_lm1 # in current layer (loop), what was previously 1 layer back is now 2 layers back
encoded_lm1 = encoded_lm0 # in current layer (loop), what was previously 0 layer back is now 1 layers back
if encoded_lm2 is None or tf.shape(
encoded_lm2)[2] != self.params.hidden_size:
encoded_lm2 = 0 # in layer 1 and 2, there should be no contribution from previous layers
encoded_lm0 = lstm(encoded_lm1 + encoded_lm2,
mask=mask,
training=training)
# output projection
encoded_2d = tf.reshape(encoded_lm0 + encoded_lm1,
[-1, self.params.hidden_size])
softmax_2d = self.dense_output(
encoded_2d) # [num_words_in_batch, num_labels]
softmax_3d = np.reshape(
softmax_2d,
(*np.shape(x1_b), self.num_classes)) # 1st dim is batch_size
output_dict = {'softmax_2d': softmax_2d, 'softmax_3d': softmax_3d}
return output_dict
def decode(self, tokens: torch.LongTensor, remove_underscore=True):
assert tokens.dim() == 1
tokens = tokens.numpy()
if tokens[0] == self.dictionary.bos():
tokens = tokens[1:] # remove <s>
eos_mask = (tokens == self.dictionary.eos())
doc_mask = eos_mask[1:] & eos_mask[:-1]
sentences = np.split(tokens, doc_mask.nonzero()[0] + 1)
if remove_underscore:
sentences = [self.bpe.decode(self.dictionary.string(s)).replace("_", " ") for s in sentences]
else:
sentences = [self.bpe.decode(self.dictionary.string(s)) for s in sentences]
if len(sentences) == 1:
return sentences[0]
return sentences
def select_action(self, state):
state = torch.from_numpy(state)
sample = random.random()
# Set the present epsilon threshold and anneal
self.eps_threshold = self.eps_end + (self.eps_start - self.eps_end) * \
math.exp(-1. * self.steps_done / self.eps_decay)
self.steps_done += 1
if sample > self.eps_threshold:
# Choose Max(Q|s)
action = self.model(
Variable(
state,
volatile=True).type(FloatTensor))[0].data.max(1)[1].view(
1, 1)
else:
# Choose a random action
action = LongTensor([[random.randrange(self.nActions)]])
return action.numpy()
def _sample_edges_for_layer(
self, __current_layer_target_nodes_indexes: torch.LongTensor,
__top_layer_target_nodes_indexes: torch.LongTensor,
layer_argument: _typing.Any, *args, **kwargs
) -> _typing.Tuple[torch.LongTensor, _typing.Optional[torch.Tensor]]:
"""
Sample edges for one specific layer, expected to be implemented in subclass.
Parameters
------------
__current_layer_target_nodes_indexes:
target nodes for current layer
__top_layer_target_nodes_indexes:
target nodes for top layer
layer_argument:
argument for current layer
args:
remaining positional arguments
kwargs:
remaining keyword arguments
Returns
--------
edge_id_in_integral_graph:
the corresponding positional indexes for the `edge_index` of integral graph
edge_weight:
the optional `edge_weight` for aggregation
"""
__wrapped_result: _typing.Tuple[
np.ndarray, np.ndarray, np.ndarray] = self.__sample_edges(
__current_layer_target_nodes_indexes.numpy(),
__top_layer_target_nodes_indexes.numpy(),
layer_argument,
)
_sampled_edges_indexes: torch.Tensor = torch.from_numpy(
__wrapped_result[0])
_selected_source_nodes: torch.Tensor = torch.from_numpy(
__wrapped_result[1])
_selected_source_nodes_probabilities: torch.Tensor = torch.from_numpy(
__wrapped_result[2])
""" Multiply corresponding discount weights """
__selected_source_node_probability_mapping: _typing.Dict[
int, float] = dict(
zip(
_selected_source_nodes.tolist(),
_selected_source_nodes_probabilities.tolist(),
))
_selected_edges_weight: torch.Tensor = self.__edge_weight[
_sampled_edges_indexes]
_selected_edges_weight: torch.Tensor = _selected_edges_weight / torch.tensor(
[
__selected_source_node_probability_mapping.get(
_current_source_node_index) for _current_source_node_index
in self._edge_index[0, _sampled_edges_indexes].tolist()
])
""" Normalize edge weight for selected edges by target nodes """
for _current_target_node_index in (
self._edge_index[1, _sampled_edges_indexes].unique().tolist()):
_current_mask_for_selected_edges: torch.BoolTensor = (
self._edge_index[
1, _sampled_edges_indexes] == _current_target_node_index)
_selected_edges_weight[
_current_mask_for_selected_edges] = _selected_edges_weight[
_current_mask_for_selected_edges] / torch.sum(
_selected_edges_weight[
_current_mask_for_selected_edges])
_sampled_edges_indexes: _typing.Union[
torch.LongTensor, torch.Tensor] = _sampled_edges_indexes
return _sampled_edges_indexes, _selected_edges_weight
def torch_indices_to_tokens(self, indices: torch.LongTensor) -> np.array:
"""Converts arbitrary shape long tensor of indices into an array of vocab type"""
return self.itos[indices.numpy()]
def torch_indices_to_tokens(self, indices: torch.LongTensor) -> np.array:
return self.itos[indices.numpy()]
