repo
stringlengths 7
55
| path
stringlengths 4
223
| func_name
stringlengths 1
134
| original_string
stringlengths 75
104k
| language
stringclasses 1
value | code
stringlengths 75
104k
| code_tokens
listlengths 19
28.4k
| docstring
stringlengths 1
46.9k
| docstring_tokens
listlengths 1
1.97k
| sha
stringlengths 40
40
| url
stringlengths 87
315
| partition
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
allenai/allennlp
|
allennlp/semparse/worlds/world.py
|
World._add_name_mapping
|
def _add_name_mapping(self, name: str, translated_name: str, name_type: Type = None):
"""
Utility method to add a name and its translation to the local name mapping, and the corresponding
signature, if available to the local type signatures. This method also updates the reverse name
mapping.
"""
self.local_name_mapping[name] = translated_name
self.reverse_name_mapping[translated_name] = name
if name_type:
self.local_type_signatures[translated_name] = name_type
|
python
|
def _add_name_mapping(self, name: str, translated_name: str, name_type: Type = None):
"""
Utility method to add a name and its translation to the local name mapping, and the corresponding
signature, if available to the local type signatures. This method also updates the reverse name
mapping.
"""
self.local_name_mapping[name] = translated_name
self.reverse_name_mapping[translated_name] = name
if name_type:
self.local_type_signatures[translated_name] = name_type
|
[
"def",
"_add_name_mapping",
"(",
"self",
",",
"name",
":",
"str",
",",
"translated_name",
":",
"str",
",",
"name_type",
":",
"Type",
"=",
"None",
")",
":",
"self",
".",
"local_name_mapping",
"[",
"name",
"]",
"=",
"translated_name",
"self",
".",
"reverse_name_mapping",
"[",
"translated_name",
"]",
"=",
"name",
"if",
"name_type",
":",
"self",
".",
"local_type_signatures",
"[",
"translated_name",
"]",
"=",
"name_type"
] |
Utility method to add a name and its translation to the local name mapping, and the corresponding
signature, if available to the local type signatures. This method also updates the reverse name
mapping.
|
[
"Utility",
"method",
"to",
"add",
"a",
"name",
"and",
"its",
"translation",
"to",
"the",
"local",
"name",
"mapping",
"and",
"the",
"corresponding",
"signature",
"if",
"available",
"to",
"the",
"local",
"type",
"signatures",
".",
"This",
"method",
"also",
"updates",
"the",
"reverse",
"name",
"mapping",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/semparse/worlds/world.py#L434-L443
|
train
|
allenai/allennlp
|
allennlp/modules/augmented_lstm.py
|
AugmentedLstm.forward
|
def forward(self, # pylint: disable=arguments-differ
inputs: PackedSequence,
initial_state: Optional[Tuple[torch.Tensor, torch.Tensor]] = None):
"""
Parameters
----------
inputs : PackedSequence, required.
A tensor of shape (batch_size, num_timesteps, input_size)
to apply the LSTM over.
initial_state : Tuple[torch.Tensor, torch.Tensor], optional, (default = None)
A tuple (state, memory) representing the initial hidden state and memory
of the LSTM. Each tensor has shape (1, batch_size, output_dimension).
Returns
-------
A PackedSequence containing a torch.FloatTensor of shape
(batch_size, num_timesteps, output_dimension) representing
the outputs of the LSTM per timestep and a tuple containing
the LSTM state, with shape (1, batch_size, hidden_size) to
match the Pytorch API.
"""
if not isinstance(inputs, PackedSequence):
raise ConfigurationError('inputs must be PackedSequence but got %s' % (type(inputs)))
sequence_tensor, batch_lengths = pad_packed_sequence(inputs, batch_first=True)
batch_size = sequence_tensor.size()[0]
total_timesteps = sequence_tensor.size()[1]
output_accumulator = sequence_tensor.new_zeros(batch_size, total_timesteps, self.hidden_size)
if initial_state is None:
full_batch_previous_memory = sequence_tensor.new_zeros(batch_size, self.hidden_size)
full_batch_previous_state = sequence_tensor.new_zeros(batch_size, self.hidden_size)
else:
full_batch_previous_state = initial_state[0].squeeze(0)
full_batch_previous_memory = initial_state[1].squeeze(0)
current_length_index = batch_size - 1 if self.go_forward else 0
if self.recurrent_dropout_probability > 0.0:
dropout_mask = get_dropout_mask(self.recurrent_dropout_probability, full_batch_previous_memory)
else:
dropout_mask = None
for timestep in range(total_timesteps):
# The index depends on which end we start.
index = timestep if self.go_forward else total_timesteps - timestep - 1
# What we are doing here is finding the index into the batch dimension
# which we need to use for this timestep, because the sequences have
# variable length, so once the index is greater than the length of this
# particular batch sequence, we no longer need to do the computation for
# this sequence. The key thing to recognise here is that the batch inputs
# must be _ordered_ by length from longest (first in batch) to shortest
# (last) so initially, we are going forwards with every sequence and as we
# pass the index at which the shortest elements of the batch finish,
# we stop picking them up for the computation.
if self.go_forward:
while batch_lengths[current_length_index] <= index:
current_length_index -= 1
# If we're going backwards, we are _picking up_ more indices.
else:
# First conditional: Are we already at the maximum number of elements in the batch?
# Second conditional: Does the next shortest sequence beyond the current batch
# index require computation use this timestep?
while current_length_index < (len(batch_lengths) - 1) and \
batch_lengths[current_length_index + 1] > index:
current_length_index += 1
# Actually get the slices of the batch which we need for the computation at this timestep.
previous_memory = full_batch_previous_memory[0: current_length_index + 1].clone()
previous_state = full_batch_previous_state[0: current_length_index + 1].clone()
# Only do recurrent dropout if the dropout prob is > 0.0 and we are in training mode.
if dropout_mask is not None and self.training:
previous_state = previous_state * dropout_mask[0: current_length_index + 1]
timestep_input = sequence_tensor[0: current_length_index + 1, index]
# Do the projections for all the gates all at once.
projected_input = self.input_linearity(timestep_input)
projected_state = self.state_linearity(previous_state)
# Main LSTM equations using relevant chunks of the big linear
# projections of the hidden state and inputs.
input_gate = torch.sigmoid(projected_input[:, 0 * self.hidden_size:1 * self.hidden_size] +
projected_state[:, 0 * self.hidden_size:1 * self.hidden_size])
forget_gate = torch.sigmoid(projected_input[:, 1 * self.hidden_size:2 * self.hidden_size] +
projected_state[:, 1 * self.hidden_size:2 * self.hidden_size])
memory_init = torch.tanh(projected_input[:, 2 * self.hidden_size:3 * self.hidden_size] +
projected_state[:, 2 * self.hidden_size:3 * self.hidden_size])
output_gate = torch.sigmoid(projected_input[:, 3 * self.hidden_size:4 * self.hidden_size] +
projected_state[:, 3 * self.hidden_size:4 * self.hidden_size])
memory = input_gate * memory_init + forget_gate * previous_memory
timestep_output = output_gate * torch.tanh(memory)
if self.use_highway:
highway_gate = torch.sigmoid(projected_input[:, 4 * self.hidden_size:5 * self.hidden_size] +
projected_state[:, 4 * self.hidden_size:5 * self.hidden_size])
highway_input_projection = projected_input[:, 5 * self.hidden_size:6 * self.hidden_size]
timestep_output = highway_gate * timestep_output + (1 - highway_gate) * highway_input_projection
# We've been doing computation with less than the full batch, so here we create a new
# variable for the the whole batch at this timestep and insert the result for the
# relevant elements of the batch into it.
full_batch_previous_memory = full_batch_previous_memory.clone()
full_batch_previous_state = full_batch_previous_state.clone()
full_batch_previous_memory[0:current_length_index + 1] = memory
full_batch_previous_state[0:current_length_index + 1] = timestep_output
output_accumulator[0:current_length_index + 1, index] = timestep_output
output_accumulator = pack_padded_sequence(output_accumulator, batch_lengths, batch_first=True)
# Mimic the pytorch API by returning state in the following shape:
# (num_layers * num_directions, batch_size, hidden_size). As this
# LSTM cannot be stacked, the first dimension here is just 1.
final_state = (full_batch_previous_state.unsqueeze(0),
full_batch_previous_memory.unsqueeze(0))
return output_accumulator, final_state
|
python
|
def forward(self, # pylint: disable=arguments-differ
inputs: PackedSequence,
initial_state: Optional[Tuple[torch.Tensor, torch.Tensor]] = None):
"""
Parameters
----------
inputs : PackedSequence, required.
A tensor of shape (batch_size, num_timesteps, input_size)
to apply the LSTM over.
initial_state : Tuple[torch.Tensor, torch.Tensor], optional, (default = None)
A tuple (state, memory) representing the initial hidden state and memory
of the LSTM. Each tensor has shape (1, batch_size, output_dimension).
Returns
-------
A PackedSequence containing a torch.FloatTensor of shape
(batch_size, num_timesteps, output_dimension) representing
the outputs of the LSTM per timestep and a tuple containing
the LSTM state, with shape (1, batch_size, hidden_size) to
match the Pytorch API.
"""
if not isinstance(inputs, PackedSequence):
raise ConfigurationError('inputs must be PackedSequence but got %s' % (type(inputs)))
sequence_tensor, batch_lengths = pad_packed_sequence(inputs, batch_first=True)
batch_size = sequence_tensor.size()[0]
total_timesteps = sequence_tensor.size()[1]
output_accumulator = sequence_tensor.new_zeros(batch_size, total_timesteps, self.hidden_size)
if initial_state is None:
full_batch_previous_memory = sequence_tensor.new_zeros(batch_size, self.hidden_size)
full_batch_previous_state = sequence_tensor.new_zeros(batch_size, self.hidden_size)
else:
full_batch_previous_state = initial_state[0].squeeze(0)
full_batch_previous_memory = initial_state[1].squeeze(0)
current_length_index = batch_size - 1 if self.go_forward else 0
if self.recurrent_dropout_probability > 0.0:
dropout_mask = get_dropout_mask(self.recurrent_dropout_probability, full_batch_previous_memory)
else:
dropout_mask = None
for timestep in range(total_timesteps):
# The index depends on which end we start.
index = timestep if self.go_forward else total_timesteps - timestep - 1
# What we are doing here is finding the index into the batch dimension
# which we need to use for this timestep, because the sequences have
# variable length, so once the index is greater than the length of this
# particular batch sequence, we no longer need to do the computation for
# this sequence. The key thing to recognise here is that the batch inputs
# must be _ordered_ by length from longest (first in batch) to shortest
# (last) so initially, we are going forwards with every sequence and as we
# pass the index at which the shortest elements of the batch finish,
# we stop picking them up for the computation.
if self.go_forward:
while batch_lengths[current_length_index] <= index:
current_length_index -= 1
# If we're going backwards, we are _picking up_ more indices.
else:
# First conditional: Are we already at the maximum number of elements in the batch?
# Second conditional: Does the next shortest sequence beyond the current batch
# index require computation use this timestep?
while current_length_index < (len(batch_lengths) - 1) and \
batch_lengths[current_length_index + 1] > index:
current_length_index += 1
# Actually get the slices of the batch which we need for the computation at this timestep.
previous_memory = full_batch_previous_memory[0: current_length_index + 1].clone()
previous_state = full_batch_previous_state[0: current_length_index + 1].clone()
# Only do recurrent dropout if the dropout prob is > 0.0 and we are in training mode.
if dropout_mask is not None and self.training:
previous_state = previous_state * dropout_mask[0: current_length_index + 1]
timestep_input = sequence_tensor[0: current_length_index + 1, index]
# Do the projections for all the gates all at once.
projected_input = self.input_linearity(timestep_input)
projected_state = self.state_linearity(previous_state)
# Main LSTM equations using relevant chunks of the big linear
# projections of the hidden state and inputs.
input_gate = torch.sigmoid(projected_input[:, 0 * self.hidden_size:1 * self.hidden_size] +
projected_state[:, 0 * self.hidden_size:1 * self.hidden_size])
forget_gate = torch.sigmoid(projected_input[:, 1 * self.hidden_size:2 * self.hidden_size] +
projected_state[:, 1 * self.hidden_size:2 * self.hidden_size])
memory_init = torch.tanh(projected_input[:, 2 * self.hidden_size:3 * self.hidden_size] +
projected_state[:, 2 * self.hidden_size:3 * self.hidden_size])
output_gate = torch.sigmoid(projected_input[:, 3 * self.hidden_size:4 * self.hidden_size] +
projected_state[:, 3 * self.hidden_size:4 * self.hidden_size])
memory = input_gate * memory_init + forget_gate * previous_memory
timestep_output = output_gate * torch.tanh(memory)
if self.use_highway:
highway_gate = torch.sigmoid(projected_input[:, 4 * self.hidden_size:5 * self.hidden_size] +
projected_state[:, 4 * self.hidden_size:5 * self.hidden_size])
highway_input_projection = projected_input[:, 5 * self.hidden_size:6 * self.hidden_size]
timestep_output = highway_gate * timestep_output + (1 - highway_gate) * highway_input_projection
# We've been doing computation with less than the full batch, so here we create a new
# variable for the the whole batch at this timestep and insert the result for the
# relevant elements of the batch into it.
full_batch_previous_memory = full_batch_previous_memory.clone()
full_batch_previous_state = full_batch_previous_state.clone()
full_batch_previous_memory[0:current_length_index + 1] = memory
full_batch_previous_state[0:current_length_index + 1] = timestep_output
output_accumulator[0:current_length_index + 1, index] = timestep_output
output_accumulator = pack_padded_sequence(output_accumulator, batch_lengths, batch_first=True)
# Mimic the pytorch API by returning state in the following shape:
# (num_layers * num_directions, batch_size, hidden_size). As this
# LSTM cannot be stacked, the first dimension here is just 1.
final_state = (full_batch_previous_state.unsqueeze(0),
full_batch_previous_memory.unsqueeze(0))
return output_accumulator, final_state
|
[
"def",
"forward",
"(",
"self",
",",
"# pylint: disable=arguments-differ",
"inputs",
":",
"PackedSequence",
",",
"initial_state",
":",
"Optional",
"[",
"Tuple",
"[",
"torch",
".",
"Tensor",
",",
"torch",
".",
"Tensor",
"]",
"]",
"=",
"None",
")",
":",
"if",
"not",
"isinstance",
"(",
"inputs",
",",
"PackedSequence",
")",
":",
"raise",
"ConfigurationError",
"(",
"'inputs must be PackedSequence but got %s'",
"%",
"(",
"type",
"(",
"inputs",
")",
")",
")",
"sequence_tensor",
",",
"batch_lengths",
"=",
"pad_packed_sequence",
"(",
"inputs",
",",
"batch_first",
"=",
"True",
")",
"batch_size",
"=",
"sequence_tensor",
".",
"size",
"(",
")",
"[",
"0",
"]",
"total_timesteps",
"=",
"sequence_tensor",
".",
"size",
"(",
")",
"[",
"1",
"]",
"output_accumulator",
"=",
"sequence_tensor",
".",
"new_zeros",
"(",
"batch_size",
",",
"total_timesteps",
",",
"self",
".",
"hidden_size",
")",
"if",
"initial_state",
"is",
"None",
":",
"full_batch_previous_memory",
"=",
"sequence_tensor",
".",
"new_zeros",
"(",
"batch_size",
",",
"self",
".",
"hidden_size",
")",
"full_batch_previous_state",
"=",
"sequence_tensor",
".",
"new_zeros",
"(",
"batch_size",
",",
"self",
".",
"hidden_size",
")",
"else",
":",
"full_batch_previous_state",
"=",
"initial_state",
"[",
"0",
"]",
".",
"squeeze",
"(",
"0",
")",
"full_batch_previous_memory",
"=",
"initial_state",
"[",
"1",
"]",
".",
"squeeze",
"(",
"0",
")",
"current_length_index",
"=",
"batch_size",
"-",
"1",
"if",
"self",
".",
"go_forward",
"else",
"0",
"if",
"self",
".",
"recurrent_dropout_probability",
">",
"0.0",
":",
"dropout_mask",
"=",
"get_dropout_mask",
"(",
"self",
".",
"recurrent_dropout_probability",
",",
"full_batch_previous_memory",
")",
"else",
":",
"dropout_mask",
"=",
"None",
"for",
"timestep",
"in",
"range",
"(",
"total_timesteps",
")",
":",
"# The index depends on which end we start.",
"index",
"=",
"timestep",
"if",
"self",
".",
"go_forward",
"else",
"total_timesteps",
"-",
"timestep",
"-",
"1",
"# What we are doing here is finding the index into the batch dimension",
"# which we need to use for this timestep, because the sequences have",
"# variable length, so once the index is greater than the length of this",
"# particular batch sequence, we no longer need to do the computation for",
"# this sequence. The key thing to recognise here is that the batch inputs",
"# must be _ordered_ by length from longest (first in batch) to shortest",
"# (last) so initially, we are going forwards with every sequence and as we",
"# pass the index at which the shortest elements of the batch finish,",
"# we stop picking them up for the computation.",
"if",
"self",
".",
"go_forward",
":",
"while",
"batch_lengths",
"[",
"current_length_index",
"]",
"<=",
"index",
":",
"current_length_index",
"-=",
"1",
"# If we're going backwards, we are _picking up_ more indices.",
"else",
":",
"# First conditional: Are we already at the maximum number of elements in the batch?",
"# Second conditional: Does the next shortest sequence beyond the current batch",
"# index require computation use this timestep?",
"while",
"current_length_index",
"<",
"(",
"len",
"(",
"batch_lengths",
")",
"-",
"1",
")",
"and",
"batch_lengths",
"[",
"current_length_index",
"+",
"1",
"]",
">",
"index",
":",
"current_length_index",
"+=",
"1",
"# Actually get the slices of the batch which we need for the computation at this timestep.",
"previous_memory",
"=",
"full_batch_previous_memory",
"[",
"0",
":",
"current_length_index",
"+",
"1",
"]",
".",
"clone",
"(",
")",
"previous_state",
"=",
"full_batch_previous_state",
"[",
"0",
":",
"current_length_index",
"+",
"1",
"]",
".",
"clone",
"(",
")",
"# Only do recurrent dropout if the dropout prob is > 0.0 and we are in training mode.",
"if",
"dropout_mask",
"is",
"not",
"None",
"and",
"self",
".",
"training",
":",
"previous_state",
"=",
"previous_state",
"*",
"dropout_mask",
"[",
"0",
":",
"current_length_index",
"+",
"1",
"]",
"timestep_input",
"=",
"sequence_tensor",
"[",
"0",
":",
"current_length_index",
"+",
"1",
",",
"index",
"]",
"# Do the projections for all the gates all at once.",
"projected_input",
"=",
"self",
".",
"input_linearity",
"(",
"timestep_input",
")",
"projected_state",
"=",
"self",
".",
"state_linearity",
"(",
"previous_state",
")",
"# Main LSTM equations using relevant chunks of the big linear",
"# projections of the hidden state and inputs.",
"input_gate",
"=",
"torch",
".",
"sigmoid",
"(",
"projected_input",
"[",
":",
",",
"0",
"*",
"self",
".",
"hidden_size",
":",
"1",
"*",
"self",
".",
"hidden_size",
"]",
"+",
"projected_state",
"[",
":",
",",
"0",
"*",
"self",
".",
"hidden_size",
":",
"1",
"*",
"self",
".",
"hidden_size",
"]",
")",
"forget_gate",
"=",
"torch",
".",
"sigmoid",
"(",
"projected_input",
"[",
":",
",",
"1",
"*",
"self",
".",
"hidden_size",
":",
"2",
"*",
"self",
".",
"hidden_size",
"]",
"+",
"projected_state",
"[",
":",
",",
"1",
"*",
"self",
".",
"hidden_size",
":",
"2",
"*",
"self",
".",
"hidden_size",
"]",
")",
"memory_init",
"=",
"torch",
".",
"tanh",
"(",
"projected_input",
"[",
":",
",",
"2",
"*",
"self",
".",
"hidden_size",
":",
"3",
"*",
"self",
".",
"hidden_size",
"]",
"+",
"projected_state",
"[",
":",
",",
"2",
"*",
"self",
".",
"hidden_size",
":",
"3",
"*",
"self",
".",
"hidden_size",
"]",
")",
"output_gate",
"=",
"torch",
".",
"sigmoid",
"(",
"projected_input",
"[",
":",
",",
"3",
"*",
"self",
".",
"hidden_size",
":",
"4",
"*",
"self",
".",
"hidden_size",
"]",
"+",
"projected_state",
"[",
":",
",",
"3",
"*",
"self",
".",
"hidden_size",
":",
"4",
"*",
"self",
".",
"hidden_size",
"]",
")",
"memory",
"=",
"input_gate",
"*",
"memory_init",
"+",
"forget_gate",
"*",
"previous_memory",
"timestep_output",
"=",
"output_gate",
"*",
"torch",
".",
"tanh",
"(",
"memory",
")",
"if",
"self",
".",
"use_highway",
":",
"highway_gate",
"=",
"torch",
".",
"sigmoid",
"(",
"projected_input",
"[",
":",
",",
"4",
"*",
"self",
".",
"hidden_size",
":",
"5",
"*",
"self",
".",
"hidden_size",
"]",
"+",
"projected_state",
"[",
":",
",",
"4",
"*",
"self",
".",
"hidden_size",
":",
"5",
"*",
"self",
".",
"hidden_size",
"]",
")",
"highway_input_projection",
"=",
"projected_input",
"[",
":",
",",
"5",
"*",
"self",
".",
"hidden_size",
":",
"6",
"*",
"self",
".",
"hidden_size",
"]",
"timestep_output",
"=",
"highway_gate",
"*",
"timestep_output",
"+",
"(",
"1",
"-",
"highway_gate",
")",
"*",
"highway_input_projection",
"# We've been doing computation with less than the full batch, so here we create a new",
"# variable for the the whole batch at this timestep and insert the result for the",
"# relevant elements of the batch into it.",
"full_batch_previous_memory",
"=",
"full_batch_previous_memory",
".",
"clone",
"(",
")",
"full_batch_previous_state",
"=",
"full_batch_previous_state",
".",
"clone",
"(",
")",
"full_batch_previous_memory",
"[",
"0",
":",
"current_length_index",
"+",
"1",
"]",
"=",
"memory",
"full_batch_previous_state",
"[",
"0",
":",
"current_length_index",
"+",
"1",
"]",
"=",
"timestep_output",
"output_accumulator",
"[",
"0",
":",
"current_length_index",
"+",
"1",
",",
"index",
"]",
"=",
"timestep_output",
"output_accumulator",
"=",
"pack_padded_sequence",
"(",
"output_accumulator",
",",
"batch_lengths",
",",
"batch_first",
"=",
"True",
")",
"# Mimic the pytorch API by returning state in the following shape:",
"# (num_layers * num_directions, batch_size, hidden_size). As this",
"# LSTM cannot be stacked, the first dimension here is just 1.",
"final_state",
"=",
"(",
"full_batch_previous_state",
".",
"unsqueeze",
"(",
"0",
")",
",",
"full_batch_previous_memory",
".",
"unsqueeze",
"(",
"0",
")",
")",
"return",
"output_accumulator",
",",
"final_state"
] |
Parameters
----------
inputs : PackedSequence, required.
A tensor of shape (batch_size, num_timesteps, input_size)
to apply the LSTM over.
initial_state : Tuple[torch.Tensor, torch.Tensor], optional, (default = None)
A tuple (state, memory) representing the initial hidden state and memory
of the LSTM. Each tensor has shape (1, batch_size, output_dimension).
Returns
-------
A PackedSequence containing a torch.FloatTensor of shape
(batch_size, num_timesteps, output_dimension) representing
the outputs of the LSTM per timestep and a tuple containing
the LSTM state, with shape (1, batch_size, hidden_size) to
match the Pytorch API.
|
[
"Parameters",
"----------",
"inputs",
":",
"PackedSequence",
"required",
".",
"A",
"tensor",
"of",
"shape",
"(",
"batch_size",
"num_timesteps",
"input_size",
")",
"to",
"apply",
"the",
"LSTM",
"over",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/modules/augmented_lstm.py#L96-L212
|
train
|
allenai/allennlp
|
allennlp/semparse/executors/wikitables_sempre_executor.py
|
WikiTablesSempreExecutor._create_sempre_executor
|
def _create_sempre_executor(self) -> None:
"""
Creates a server running SEMPRE that we can send logical forms to for evaluation. This
uses inter-process communication, because SEMPRE is java code. We also need to be careful
to clean up the process when our program exits.
"""
if self._executor_process:
return
# It'd be much nicer to just use `cached_path` for these files. However, the SEMPRE jar
# that we're using expects to find these files in a particular location, so we need to make
# sure we put the files in that location.
os.makedirs(SEMPRE_DIR, exist_ok=True)
abbreviations_path = os.path.join(SEMPRE_DIR, 'abbreviations.tsv')
if not os.path.exists(abbreviations_path):
result = requests.get(ABBREVIATIONS_FILE)
with open(abbreviations_path, 'wb') as downloaded_file:
downloaded_file.write(result.content)
grammar_path = os.path.join(SEMPRE_DIR, 'grow.grammar')
if not os.path.exists(grammar_path):
result = requests.get(GROW_FILE)
with open(grammar_path, 'wb') as downloaded_file:
downloaded_file.write(result.content)
if not check_for_java():
raise RuntimeError('Java is not installed properly.')
args = ['java', '-jar', cached_path(SEMPRE_EXECUTOR_JAR), 'serve', self._table_directory]
self._executor_process = subprocess.Popen(args,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
bufsize=1)
lines = []
for _ in range(6):
# SEMPRE outputs six lines of stuff when it loads that I can't disable. So, we clear
# that here.
lines.append(str(self._executor_process.stdout.readline()))
assert 'Parser' in lines[-1], "SEMPRE server output unexpected; the server may have changed"
logger.info("Started SEMPRE server for evaluating logical forms")
# This is supposed to ensure that the subprocess gets killed when python exits.
atexit.register(self._stop_sempre_executor)
|
python
|
def _create_sempre_executor(self) -> None:
"""
Creates a server running SEMPRE that we can send logical forms to for evaluation. This
uses inter-process communication, because SEMPRE is java code. We also need to be careful
to clean up the process when our program exits.
"""
if self._executor_process:
return
# It'd be much nicer to just use `cached_path` for these files. However, the SEMPRE jar
# that we're using expects to find these files in a particular location, so we need to make
# sure we put the files in that location.
os.makedirs(SEMPRE_DIR, exist_ok=True)
abbreviations_path = os.path.join(SEMPRE_DIR, 'abbreviations.tsv')
if not os.path.exists(abbreviations_path):
result = requests.get(ABBREVIATIONS_FILE)
with open(abbreviations_path, 'wb') as downloaded_file:
downloaded_file.write(result.content)
grammar_path = os.path.join(SEMPRE_DIR, 'grow.grammar')
if not os.path.exists(grammar_path):
result = requests.get(GROW_FILE)
with open(grammar_path, 'wb') as downloaded_file:
downloaded_file.write(result.content)
if not check_for_java():
raise RuntimeError('Java is not installed properly.')
args = ['java', '-jar', cached_path(SEMPRE_EXECUTOR_JAR), 'serve', self._table_directory]
self._executor_process = subprocess.Popen(args,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
bufsize=1)
lines = []
for _ in range(6):
# SEMPRE outputs six lines of stuff when it loads that I can't disable. So, we clear
# that here.
lines.append(str(self._executor_process.stdout.readline()))
assert 'Parser' in lines[-1], "SEMPRE server output unexpected; the server may have changed"
logger.info("Started SEMPRE server for evaluating logical forms")
# This is supposed to ensure that the subprocess gets killed when python exits.
atexit.register(self._stop_sempre_executor)
|
[
"def",
"_create_sempre_executor",
"(",
"self",
")",
"->",
"None",
":",
"if",
"self",
".",
"_executor_process",
":",
"return",
"# It'd be much nicer to just use `cached_path` for these files. However, the SEMPRE jar",
"# that we're using expects to find these files in a particular location, so we need to make",
"# sure we put the files in that location.",
"os",
".",
"makedirs",
"(",
"SEMPRE_DIR",
",",
"exist_ok",
"=",
"True",
")",
"abbreviations_path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"SEMPRE_DIR",
",",
"'abbreviations.tsv'",
")",
"if",
"not",
"os",
".",
"path",
".",
"exists",
"(",
"abbreviations_path",
")",
":",
"result",
"=",
"requests",
".",
"get",
"(",
"ABBREVIATIONS_FILE",
")",
"with",
"open",
"(",
"abbreviations_path",
",",
"'wb'",
")",
"as",
"downloaded_file",
":",
"downloaded_file",
".",
"write",
"(",
"result",
".",
"content",
")",
"grammar_path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"SEMPRE_DIR",
",",
"'grow.grammar'",
")",
"if",
"not",
"os",
".",
"path",
".",
"exists",
"(",
"grammar_path",
")",
":",
"result",
"=",
"requests",
".",
"get",
"(",
"GROW_FILE",
")",
"with",
"open",
"(",
"grammar_path",
",",
"'wb'",
")",
"as",
"downloaded_file",
":",
"downloaded_file",
".",
"write",
"(",
"result",
".",
"content",
")",
"if",
"not",
"check_for_java",
"(",
")",
":",
"raise",
"RuntimeError",
"(",
"'Java is not installed properly.'",
")",
"args",
"=",
"[",
"'java'",
",",
"'-jar'",
",",
"cached_path",
"(",
"SEMPRE_EXECUTOR_JAR",
")",
",",
"'serve'",
",",
"self",
".",
"_table_directory",
"]",
"self",
".",
"_executor_process",
"=",
"subprocess",
".",
"Popen",
"(",
"args",
",",
"stdin",
"=",
"subprocess",
".",
"PIPE",
",",
"stdout",
"=",
"subprocess",
".",
"PIPE",
",",
"bufsize",
"=",
"1",
")",
"lines",
"=",
"[",
"]",
"for",
"_",
"in",
"range",
"(",
"6",
")",
":",
"# SEMPRE outputs six lines of stuff when it loads that I can't disable. So, we clear",
"# that here.",
"lines",
".",
"append",
"(",
"str",
"(",
"self",
".",
"_executor_process",
".",
"stdout",
".",
"readline",
"(",
")",
")",
")",
"assert",
"'Parser'",
"in",
"lines",
"[",
"-",
"1",
"]",
",",
"\"SEMPRE server output unexpected; the server may have changed\"",
"logger",
".",
"info",
"(",
"\"Started SEMPRE server for evaluating logical forms\"",
")",
"# This is supposed to ensure that the subprocess gets killed when python exits.",
"atexit",
".",
"register",
"(",
"self",
".",
"_stop_sempre_executor",
")"
] |
Creates a server running SEMPRE that we can send logical forms to for evaluation. This
uses inter-process communication, because SEMPRE is java code. We also need to be careful
to clean up the process when our program exits.
|
[
"Creates",
"a",
"server",
"running",
"SEMPRE",
"that",
"we",
"can",
"send",
"logical",
"forms",
"to",
"for",
"evaluation",
".",
"This",
"uses",
"inter",
"-",
"process",
"communication",
"because",
"SEMPRE",
"is",
"java",
"code",
".",
"We",
"also",
"need",
"to",
"be",
"careful",
"to",
"clean",
"up",
"the",
"process",
"when",
"our",
"program",
"exits",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/semparse/executors/wikitables_sempre_executor.py#L63-L105
|
train
|
allenai/allennlp
|
allennlp/training/metrics/conll_coref_scores.py
|
Scorer.b_cubed
|
def b_cubed(clusters, mention_to_gold):
"""
Averaged per-mention precision and recall.
<https://pdfs.semanticscholar.org/cfe3/c24695f1c14b78a5b8e95bcbd1c666140fd1.pdf>
"""
numerator, denominator = 0, 0
for cluster in clusters:
if len(cluster) == 1:
continue
gold_counts = Counter()
correct = 0
for mention in cluster:
if mention in mention_to_gold:
gold_counts[tuple(mention_to_gold[mention])] += 1
for cluster2, count in gold_counts.items():
if len(cluster2) != 1:
correct += count * count
numerator += correct / float(len(cluster))
denominator += len(cluster)
return numerator, denominator
|
python
|
def b_cubed(clusters, mention_to_gold):
"""
Averaged per-mention precision and recall.
<https://pdfs.semanticscholar.org/cfe3/c24695f1c14b78a5b8e95bcbd1c666140fd1.pdf>
"""
numerator, denominator = 0, 0
for cluster in clusters:
if len(cluster) == 1:
continue
gold_counts = Counter()
correct = 0
for mention in cluster:
if mention in mention_to_gold:
gold_counts[tuple(mention_to_gold[mention])] += 1
for cluster2, count in gold_counts.items():
if len(cluster2) != 1:
correct += count * count
numerator += correct / float(len(cluster))
denominator += len(cluster)
return numerator, denominator
|
[
"def",
"b_cubed",
"(",
"clusters",
",",
"mention_to_gold",
")",
":",
"numerator",
",",
"denominator",
"=",
"0",
",",
"0",
"for",
"cluster",
"in",
"clusters",
":",
"if",
"len",
"(",
"cluster",
")",
"==",
"1",
":",
"continue",
"gold_counts",
"=",
"Counter",
"(",
")",
"correct",
"=",
"0",
"for",
"mention",
"in",
"cluster",
":",
"if",
"mention",
"in",
"mention_to_gold",
":",
"gold_counts",
"[",
"tuple",
"(",
"mention_to_gold",
"[",
"mention",
"]",
")",
"]",
"+=",
"1",
"for",
"cluster2",
",",
"count",
"in",
"gold_counts",
".",
"items",
"(",
")",
":",
"if",
"len",
"(",
"cluster2",
")",
"!=",
"1",
":",
"correct",
"+=",
"count",
"*",
"count",
"numerator",
"+=",
"correct",
"/",
"float",
"(",
"len",
"(",
"cluster",
")",
")",
"denominator",
"+=",
"len",
"(",
"cluster",
")",
"return",
"numerator",
",",
"denominator"
] |
Averaged per-mention precision and recall.
<https://pdfs.semanticscholar.org/cfe3/c24695f1c14b78a5b8e95bcbd1c666140fd1.pdf>
|
[
"Averaged",
"per",
"-",
"mention",
"precision",
"and",
"recall",
".",
"<https",
":",
"//",
"pdfs",
".",
"semanticscholar",
".",
"org",
"/",
"cfe3",
"/",
"c24695f1c14b78a5b8e95bcbd1c666140fd1",
".",
"pdf",
">"
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/training/metrics/conll_coref_scores.py#L166-L185
|
train
|
allenai/allennlp
|
allennlp/training/metrics/conll_coref_scores.py
|
Scorer.muc
|
def muc(clusters, mention_to_gold):
"""
Counts the mentions in each predicted cluster which need to be re-allocated in
order for each predicted cluster to be contained by the respective gold cluster.
<http://aclweb.org/anthology/M/M95/M95-1005.pdf>
"""
true_p, all_p = 0, 0
for cluster in clusters:
all_p += len(cluster) - 1
true_p += len(cluster)
linked = set()
for mention in cluster:
if mention in mention_to_gold:
linked.add(mention_to_gold[mention])
else:
true_p -= 1
true_p -= len(linked)
return true_p, all_p
|
python
|
def muc(clusters, mention_to_gold):
"""
Counts the mentions in each predicted cluster which need to be re-allocated in
order for each predicted cluster to be contained by the respective gold cluster.
<http://aclweb.org/anthology/M/M95/M95-1005.pdf>
"""
true_p, all_p = 0, 0
for cluster in clusters:
all_p += len(cluster) - 1
true_p += len(cluster)
linked = set()
for mention in cluster:
if mention in mention_to_gold:
linked.add(mention_to_gold[mention])
else:
true_p -= 1
true_p -= len(linked)
return true_p, all_p
|
[
"def",
"muc",
"(",
"clusters",
",",
"mention_to_gold",
")",
":",
"true_p",
",",
"all_p",
"=",
"0",
",",
"0",
"for",
"cluster",
"in",
"clusters",
":",
"all_p",
"+=",
"len",
"(",
"cluster",
")",
"-",
"1",
"true_p",
"+=",
"len",
"(",
"cluster",
")",
"linked",
"=",
"set",
"(",
")",
"for",
"mention",
"in",
"cluster",
":",
"if",
"mention",
"in",
"mention_to_gold",
":",
"linked",
".",
"add",
"(",
"mention_to_gold",
"[",
"mention",
"]",
")",
"else",
":",
"true_p",
"-=",
"1",
"true_p",
"-=",
"len",
"(",
"linked",
")",
"return",
"true_p",
",",
"all_p"
] |
Counts the mentions in each predicted cluster which need to be re-allocated in
order for each predicted cluster to be contained by the respective gold cluster.
<http://aclweb.org/anthology/M/M95/M95-1005.pdf>
|
[
"Counts",
"the",
"mentions",
"in",
"each",
"predicted",
"cluster",
"which",
"need",
"to",
"be",
"re",
"-",
"allocated",
"in",
"order",
"for",
"each",
"predicted",
"cluster",
"to",
"be",
"contained",
"by",
"the",
"respective",
"gold",
"cluster",
".",
"<http",
":",
"//",
"aclweb",
".",
"org",
"/",
"anthology",
"/",
"M",
"/",
"M95",
"/",
"M95",
"-",
"1005",
".",
"pdf",
">"
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/training/metrics/conll_coref_scores.py#L188-L205
|
train
|
allenai/allennlp
|
allennlp/training/metrics/conll_coref_scores.py
|
Scorer.phi4
|
def phi4(gold_clustering, predicted_clustering):
"""
Subroutine for ceafe. Computes the mention F measure between gold and
predicted mentions in a cluster.
"""
return 2 * len([mention for mention in gold_clustering if mention in predicted_clustering]) \
/ float(len(gold_clustering) + len(predicted_clustering))
|
python
|
def phi4(gold_clustering, predicted_clustering):
"""
Subroutine for ceafe. Computes the mention F measure between gold and
predicted mentions in a cluster.
"""
return 2 * len([mention for mention in gold_clustering if mention in predicted_clustering]) \
/ float(len(gold_clustering) + len(predicted_clustering))
|
[
"def",
"phi4",
"(",
"gold_clustering",
",",
"predicted_clustering",
")",
":",
"return",
"2",
"*",
"len",
"(",
"[",
"mention",
"for",
"mention",
"in",
"gold_clustering",
"if",
"mention",
"in",
"predicted_clustering",
"]",
")",
"/",
"float",
"(",
"len",
"(",
"gold_clustering",
")",
"+",
"len",
"(",
"predicted_clustering",
")",
")"
] |
Subroutine for ceafe. Computes the mention F measure between gold and
predicted mentions in a cluster.
|
[
"Subroutine",
"for",
"ceafe",
".",
"Computes",
"the",
"mention",
"F",
"measure",
"between",
"gold",
"and",
"predicted",
"mentions",
"in",
"a",
"cluster",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/training/metrics/conll_coref_scores.py#L208-L214
|
train
|
allenai/allennlp
|
allennlp/training/metrics/conll_coref_scores.py
|
Scorer.ceafe
|
def ceafe(clusters, gold_clusters):
"""
Computes the Constrained EntityAlignment F-Measure (CEAF) for evaluating coreference.
Gold and predicted mentions are aligned into clusterings which maximise a metric - in
this case, the F measure between gold and predicted clusters.
<https://www.semanticscholar.org/paper/On-Coreference-Resolution-Performance-Metrics-Luo/de133c1f22d0dfe12539e25dda70f28672459b99>
"""
clusters = [cluster for cluster in clusters if len(cluster) != 1]
scores = np.zeros((len(gold_clusters), len(clusters)))
for i, gold_cluster in enumerate(gold_clusters):
for j, cluster in enumerate(clusters):
scores[i, j] = Scorer.phi4(gold_cluster, cluster)
matching = linear_assignment(-scores)
similarity = sum(scores[matching[:, 0], matching[:, 1]])
return similarity, len(clusters), similarity, len(gold_clusters)
|
python
|
def ceafe(clusters, gold_clusters):
"""
Computes the Constrained EntityAlignment F-Measure (CEAF) for evaluating coreference.
Gold and predicted mentions are aligned into clusterings which maximise a metric - in
this case, the F measure between gold and predicted clusters.
<https://www.semanticscholar.org/paper/On-Coreference-Resolution-Performance-Metrics-Luo/de133c1f22d0dfe12539e25dda70f28672459b99>
"""
clusters = [cluster for cluster in clusters if len(cluster) != 1]
scores = np.zeros((len(gold_clusters), len(clusters)))
for i, gold_cluster in enumerate(gold_clusters):
for j, cluster in enumerate(clusters):
scores[i, j] = Scorer.phi4(gold_cluster, cluster)
matching = linear_assignment(-scores)
similarity = sum(scores[matching[:, 0], matching[:, 1]])
return similarity, len(clusters), similarity, len(gold_clusters)
|
[
"def",
"ceafe",
"(",
"clusters",
",",
"gold_clusters",
")",
":",
"clusters",
"=",
"[",
"cluster",
"for",
"cluster",
"in",
"clusters",
"if",
"len",
"(",
"cluster",
")",
"!=",
"1",
"]",
"scores",
"=",
"np",
".",
"zeros",
"(",
"(",
"len",
"(",
"gold_clusters",
")",
",",
"len",
"(",
"clusters",
")",
")",
")",
"for",
"i",
",",
"gold_cluster",
"in",
"enumerate",
"(",
"gold_clusters",
")",
":",
"for",
"j",
",",
"cluster",
"in",
"enumerate",
"(",
"clusters",
")",
":",
"scores",
"[",
"i",
",",
"j",
"]",
"=",
"Scorer",
".",
"phi4",
"(",
"gold_cluster",
",",
"cluster",
")",
"matching",
"=",
"linear_assignment",
"(",
"-",
"scores",
")",
"similarity",
"=",
"sum",
"(",
"scores",
"[",
"matching",
"[",
":",
",",
"0",
"]",
",",
"matching",
"[",
":",
",",
"1",
"]",
"]",
")",
"return",
"similarity",
",",
"len",
"(",
"clusters",
")",
",",
"similarity",
",",
"len",
"(",
"gold_clusters",
")"
] |
Computes the Constrained EntityAlignment F-Measure (CEAF) for evaluating coreference.
Gold and predicted mentions are aligned into clusterings which maximise a metric - in
this case, the F measure between gold and predicted clusters.
<https://www.semanticscholar.org/paper/On-Coreference-Resolution-Performance-Metrics-Luo/de133c1f22d0dfe12539e25dda70f28672459b99>
|
[
"Computes",
"the",
"Constrained",
"EntityAlignment",
"F",
"-",
"Measure",
"(",
"CEAF",
")",
"for",
"evaluating",
"coreference",
".",
"Gold",
"and",
"predicted",
"mentions",
"are",
"aligned",
"into",
"clusterings",
"which",
"maximise",
"a",
"metric",
"-",
"in",
"this",
"case",
"the",
"F",
"measure",
"between",
"gold",
"and",
"predicted",
"clusters",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/training/metrics/conll_coref_scores.py#L217-L232
|
train
|
allenai/allennlp
|
allennlp/state_machines/states/grammar_statelet.py
|
GrammarStatelet.take_action
|
def take_action(self, production_rule: str) -> 'GrammarStatelet':
"""
Takes an action in the current grammar state, returning a new grammar state with whatever
updates are necessary. The production rule is assumed to be formatted as "LHS -> RHS".
This will update the non-terminal stack. Updating the non-terminal stack involves popping
the non-terminal that was expanded off of the stack, then pushing on any non-terminals in
the production rule back on the stack.
For example, if our current ``nonterminal_stack`` is ``["r", "<e,r>", "d"]``, and
``action`` is ``d -> [<e,d>, e]``, the resulting stack will be ``["r", "<e,r>", "e",
"<e,d>"]``.
If ``self._reverse_productions`` is set to ``False`` then we push the non-terminals on in
in their given order, which means that the first non-terminal in the production rule gets
popped off the stack `last`.
"""
left_side, right_side = production_rule.split(' -> ')
assert self._nonterminal_stack[-1] == left_side, (f"Tried to expand {self._nonterminal_stack[-1]}"
f"but got rule {left_side} -> {right_side}")
new_stack = self._nonterminal_stack[:-1]
productions = self._get_productions_from_string(right_side)
if self._reverse_productions:
productions = list(reversed(productions))
for production in productions:
if self._is_nonterminal(production):
new_stack.append(production)
return GrammarStatelet(nonterminal_stack=new_stack,
valid_actions=self._valid_actions,
is_nonterminal=self._is_nonterminal,
reverse_productions=self._reverse_productions)
|
python
|
def take_action(self, production_rule: str) -> 'GrammarStatelet':
"""
Takes an action in the current grammar state, returning a new grammar state with whatever
updates are necessary. The production rule is assumed to be formatted as "LHS -> RHS".
This will update the non-terminal stack. Updating the non-terminal stack involves popping
the non-terminal that was expanded off of the stack, then pushing on any non-terminals in
the production rule back on the stack.
For example, if our current ``nonterminal_stack`` is ``["r", "<e,r>", "d"]``, and
``action`` is ``d -> [<e,d>, e]``, the resulting stack will be ``["r", "<e,r>", "e",
"<e,d>"]``.
If ``self._reverse_productions`` is set to ``False`` then we push the non-terminals on in
in their given order, which means that the first non-terminal in the production rule gets
popped off the stack `last`.
"""
left_side, right_side = production_rule.split(' -> ')
assert self._nonterminal_stack[-1] == left_side, (f"Tried to expand {self._nonterminal_stack[-1]}"
f"but got rule {left_side} -> {right_side}")
new_stack = self._nonterminal_stack[:-1]
productions = self._get_productions_from_string(right_side)
if self._reverse_productions:
productions = list(reversed(productions))
for production in productions:
if self._is_nonterminal(production):
new_stack.append(production)
return GrammarStatelet(nonterminal_stack=new_stack,
valid_actions=self._valid_actions,
is_nonterminal=self._is_nonterminal,
reverse_productions=self._reverse_productions)
|
[
"def",
"take_action",
"(",
"self",
",",
"production_rule",
":",
"str",
")",
"->",
"'GrammarStatelet'",
":",
"left_side",
",",
"right_side",
"=",
"production_rule",
".",
"split",
"(",
"' -> '",
")",
"assert",
"self",
".",
"_nonterminal_stack",
"[",
"-",
"1",
"]",
"==",
"left_side",
",",
"(",
"f\"Tried to expand {self._nonterminal_stack[-1]}\"",
"f\"but got rule {left_side} -> {right_side}\"",
")",
"new_stack",
"=",
"self",
".",
"_nonterminal_stack",
"[",
":",
"-",
"1",
"]",
"productions",
"=",
"self",
".",
"_get_productions_from_string",
"(",
"right_side",
")",
"if",
"self",
".",
"_reverse_productions",
":",
"productions",
"=",
"list",
"(",
"reversed",
"(",
"productions",
")",
")",
"for",
"production",
"in",
"productions",
":",
"if",
"self",
".",
"_is_nonterminal",
"(",
"production",
")",
":",
"new_stack",
".",
"append",
"(",
"production",
")",
"return",
"GrammarStatelet",
"(",
"nonterminal_stack",
"=",
"new_stack",
",",
"valid_actions",
"=",
"self",
".",
"_valid_actions",
",",
"is_nonterminal",
"=",
"self",
".",
"_is_nonterminal",
",",
"reverse_productions",
"=",
"self",
".",
"_reverse_productions",
")"
] |
Takes an action in the current grammar state, returning a new grammar state with whatever
updates are necessary. The production rule is assumed to be formatted as "LHS -> RHS".
This will update the non-terminal stack. Updating the non-terminal stack involves popping
the non-terminal that was expanded off of the stack, then pushing on any non-terminals in
the production rule back on the stack.
For example, if our current ``nonterminal_stack`` is ``["r", "<e,r>", "d"]``, and
``action`` is ``d -> [<e,d>, e]``, the resulting stack will be ``["r", "<e,r>", "e",
"<e,d>"]``.
If ``self._reverse_productions`` is set to ``False`` then we push the non-terminals on in
in their given order, which means that the first non-terminal in the production rule gets
popped off the stack `last`.
|
[
"Takes",
"an",
"action",
"in",
"the",
"current",
"grammar",
"state",
"returning",
"a",
"new",
"grammar",
"state",
"with",
"whatever",
"updates",
"are",
"necessary",
".",
"The",
"production",
"rule",
"is",
"assumed",
"to",
"be",
"formatted",
"as",
"LHS",
"-",
">",
"RHS",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/state_machines/states/grammar_statelet.py#L70-L104
|
train
|
allenai/allennlp
|
allennlp/training/util.py
|
sparse_clip_norm
|
def sparse_clip_norm(parameters, max_norm, norm_type=2) -> float:
"""Clips gradient norm of an iterable of parameters.
The norm is computed over all gradients together, as if they were
concatenated into a single vector. Gradients are modified in-place.
Supports sparse gradients.
Parameters
----------
parameters : ``(Iterable[torch.Tensor])``
An iterable of Tensors that will have gradients normalized.
max_norm : ``float``
The max norm of the gradients.
norm_type : ``float``
The type of the used p-norm. Can be ``'inf'`` for infinity norm.
Returns
-------
Total norm of the parameters (viewed as a single vector).
"""
# pylint: disable=invalid-name,protected-access
parameters = list(filter(lambda p: p.grad is not None, parameters))
max_norm = float(max_norm)
norm_type = float(norm_type)
if norm_type == float('inf'):
total_norm = max(p.grad.data.abs().max() for p in parameters)
else:
total_norm = 0
for p in parameters:
if p.grad.is_sparse:
# need to coalesce the repeated indices before finding norm
grad = p.grad.data.coalesce()
param_norm = grad._values().norm(norm_type)
else:
param_norm = p.grad.data.norm(norm_type)
total_norm += param_norm ** norm_type
total_norm = total_norm ** (1. / norm_type)
clip_coef = max_norm / (total_norm + 1e-6)
if clip_coef < 1:
for p in parameters:
if p.grad.is_sparse:
p.grad.data._values().mul_(clip_coef)
else:
p.grad.data.mul_(clip_coef)
return total_norm
|
python
|
def sparse_clip_norm(parameters, max_norm, norm_type=2) -> float:
"""Clips gradient norm of an iterable of parameters.
The norm is computed over all gradients together, as if they were
concatenated into a single vector. Gradients are modified in-place.
Supports sparse gradients.
Parameters
----------
parameters : ``(Iterable[torch.Tensor])``
An iterable of Tensors that will have gradients normalized.
max_norm : ``float``
The max norm of the gradients.
norm_type : ``float``
The type of the used p-norm. Can be ``'inf'`` for infinity norm.
Returns
-------
Total norm of the parameters (viewed as a single vector).
"""
# pylint: disable=invalid-name,protected-access
parameters = list(filter(lambda p: p.grad is not None, parameters))
max_norm = float(max_norm)
norm_type = float(norm_type)
if norm_type == float('inf'):
total_norm = max(p.grad.data.abs().max() for p in parameters)
else:
total_norm = 0
for p in parameters:
if p.grad.is_sparse:
# need to coalesce the repeated indices before finding norm
grad = p.grad.data.coalesce()
param_norm = grad._values().norm(norm_type)
else:
param_norm = p.grad.data.norm(norm_type)
total_norm += param_norm ** norm_type
total_norm = total_norm ** (1. / norm_type)
clip_coef = max_norm / (total_norm + 1e-6)
if clip_coef < 1:
for p in parameters:
if p.grad.is_sparse:
p.grad.data._values().mul_(clip_coef)
else:
p.grad.data.mul_(clip_coef)
return total_norm
|
[
"def",
"sparse_clip_norm",
"(",
"parameters",
",",
"max_norm",
",",
"norm_type",
"=",
"2",
")",
"->",
"float",
":",
"# pylint: disable=invalid-name,protected-access",
"parameters",
"=",
"list",
"(",
"filter",
"(",
"lambda",
"p",
":",
"p",
".",
"grad",
"is",
"not",
"None",
",",
"parameters",
")",
")",
"max_norm",
"=",
"float",
"(",
"max_norm",
")",
"norm_type",
"=",
"float",
"(",
"norm_type",
")",
"if",
"norm_type",
"==",
"float",
"(",
"'inf'",
")",
":",
"total_norm",
"=",
"max",
"(",
"p",
".",
"grad",
".",
"data",
".",
"abs",
"(",
")",
".",
"max",
"(",
")",
"for",
"p",
"in",
"parameters",
")",
"else",
":",
"total_norm",
"=",
"0",
"for",
"p",
"in",
"parameters",
":",
"if",
"p",
".",
"grad",
".",
"is_sparse",
":",
"# need to coalesce the repeated indices before finding norm",
"grad",
"=",
"p",
".",
"grad",
".",
"data",
".",
"coalesce",
"(",
")",
"param_norm",
"=",
"grad",
".",
"_values",
"(",
")",
".",
"norm",
"(",
"norm_type",
")",
"else",
":",
"param_norm",
"=",
"p",
".",
"grad",
".",
"data",
".",
"norm",
"(",
"norm_type",
")",
"total_norm",
"+=",
"param_norm",
"**",
"norm_type",
"total_norm",
"=",
"total_norm",
"**",
"(",
"1.",
"/",
"norm_type",
")",
"clip_coef",
"=",
"max_norm",
"/",
"(",
"total_norm",
"+",
"1e-6",
")",
"if",
"clip_coef",
"<",
"1",
":",
"for",
"p",
"in",
"parameters",
":",
"if",
"p",
".",
"grad",
".",
"is_sparse",
":",
"p",
".",
"grad",
".",
"data",
".",
"_values",
"(",
")",
".",
"mul_",
"(",
"clip_coef",
")",
"else",
":",
"p",
".",
"grad",
".",
"data",
".",
"mul_",
"(",
"clip_coef",
")",
"return",
"total_norm"
] |
Clips gradient norm of an iterable of parameters.
The norm is computed over all gradients together, as if they were
concatenated into a single vector. Gradients are modified in-place.
Supports sparse gradients.
Parameters
----------
parameters : ``(Iterable[torch.Tensor])``
An iterable of Tensors that will have gradients normalized.
max_norm : ``float``
The max norm of the gradients.
norm_type : ``float``
The type of the used p-norm. Can be ``'inf'`` for infinity norm.
Returns
-------
Total norm of the parameters (viewed as a single vector).
|
[
"Clips",
"gradient",
"norm",
"of",
"an",
"iterable",
"of",
"parameters",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/training/util.py#L34-L78
|
train
|
allenai/allennlp
|
allennlp/training/util.py
|
move_optimizer_to_cuda
|
def move_optimizer_to_cuda(optimizer):
"""
Move the optimizer state to GPU, if necessary.
After calling, any parameter specific state in the optimizer
will be located on the same device as the parameter.
"""
for param_group in optimizer.param_groups:
for param in param_group['params']:
if param.is_cuda:
param_state = optimizer.state[param]
for k in param_state.keys():
if isinstance(param_state[k], torch.Tensor):
param_state[k] = param_state[k].cuda(device=param.get_device())
|
python
|
def move_optimizer_to_cuda(optimizer):
"""
Move the optimizer state to GPU, if necessary.
After calling, any parameter specific state in the optimizer
will be located on the same device as the parameter.
"""
for param_group in optimizer.param_groups:
for param in param_group['params']:
if param.is_cuda:
param_state = optimizer.state[param]
for k in param_state.keys():
if isinstance(param_state[k], torch.Tensor):
param_state[k] = param_state[k].cuda(device=param.get_device())
|
[
"def",
"move_optimizer_to_cuda",
"(",
"optimizer",
")",
":",
"for",
"param_group",
"in",
"optimizer",
".",
"param_groups",
":",
"for",
"param",
"in",
"param_group",
"[",
"'params'",
"]",
":",
"if",
"param",
".",
"is_cuda",
":",
"param_state",
"=",
"optimizer",
".",
"state",
"[",
"param",
"]",
"for",
"k",
"in",
"param_state",
".",
"keys",
"(",
")",
":",
"if",
"isinstance",
"(",
"param_state",
"[",
"k",
"]",
",",
"torch",
".",
"Tensor",
")",
":",
"param_state",
"[",
"k",
"]",
"=",
"param_state",
"[",
"k",
"]",
".",
"cuda",
"(",
"device",
"=",
"param",
".",
"get_device",
"(",
")",
")"
] |
Move the optimizer state to GPU, if necessary.
After calling, any parameter specific state in the optimizer
will be located on the same device as the parameter.
|
[
"Move",
"the",
"optimizer",
"state",
"to",
"GPU",
"if",
"necessary",
".",
"After",
"calling",
"any",
"parameter",
"specific",
"state",
"in",
"the",
"optimizer",
"will",
"be",
"located",
"on",
"the",
"same",
"device",
"as",
"the",
"parameter",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/training/util.py#L81-L93
|
train
|
allenai/allennlp
|
allennlp/training/util.py
|
get_batch_size
|
def get_batch_size(batch: Union[Dict, torch.Tensor]) -> int:
"""
Returns the size of the batch dimension. Assumes a well-formed batch,
returns 0 otherwise.
"""
if isinstance(batch, torch.Tensor):
return batch.size(0) # type: ignore
elif isinstance(batch, Dict):
return get_batch_size(next(iter(batch.values())))
else:
return 0
|
python
|
def get_batch_size(batch: Union[Dict, torch.Tensor]) -> int:
"""
Returns the size of the batch dimension. Assumes a well-formed batch,
returns 0 otherwise.
"""
if isinstance(batch, torch.Tensor):
return batch.size(0) # type: ignore
elif isinstance(batch, Dict):
return get_batch_size(next(iter(batch.values())))
else:
return 0
|
[
"def",
"get_batch_size",
"(",
"batch",
":",
"Union",
"[",
"Dict",
",",
"torch",
".",
"Tensor",
"]",
")",
"->",
"int",
":",
"if",
"isinstance",
"(",
"batch",
",",
"torch",
".",
"Tensor",
")",
":",
"return",
"batch",
".",
"size",
"(",
"0",
")",
"# type: ignore",
"elif",
"isinstance",
"(",
"batch",
",",
"Dict",
")",
":",
"return",
"get_batch_size",
"(",
"next",
"(",
"iter",
"(",
"batch",
".",
"values",
"(",
")",
")",
")",
")",
"else",
":",
"return",
"0"
] |
Returns the size of the batch dimension. Assumes a well-formed batch,
returns 0 otherwise.
|
[
"Returns",
"the",
"size",
"of",
"the",
"batch",
"dimension",
".",
"Assumes",
"a",
"well",
"-",
"formed",
"batch",
"returns",
"0",
"otherwise",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/training/util.py#L96-L106
|
train
|
allenai/allennlp
|
allennlp/training/util.py
|
time_to_str
|
def time_to_str(timestamp: int) -> str:
"""
Convert seconds past Epoch to human readable string.
"""
datetimestamp = datetime.datetime.fromtimestamp(timestamp)
return '{:04d}-{:02d}-{:02d}-{:02d}-{:02d}-{:02d}'.format(
datetimestamp.year, datetimestamp.month, datetimestamp.day,
datetimestamp.hour, datetimestamp.minute, datetimestamp.second
)
|
python
|
def time_to_str(timestamp: int) -> str:
"""
Convert seconds past Epoch to human readable string.
"""
datetimestamp = datetime.datetime.fromtimestamp(timestamp)
return '{:04d}-{:02d}-{:02d}-{:02d}-{:02d}-{:02d}'.format(
datetimestamp.year, datetimestamp.month, datetimestamp.day,
datetimestamp.hour, datetimestamp.minute, datetimestamp.second
)
|
[
"def",
"time_to_str",
"(",
"timestamp",
":",
"int",
")",
"->",
"str",
":",
"datetimestamp",
"=",
"datetime",
".",
"datetime",
".",
"fromtimestamp",
"(",
"timestamp",
")",
"return",
"'{:04d}-{:02d}-{:02d}-{:02d}-{:02d}-{:02d}'",
".",
"format",
"(",
"datetimestamp",
".",
"year",
",",
"datetimestamp",
".",
"month",
",",
"datetimestamp",
".",
"day",
",",
"datetimestamp",
".",
"hour",
",",
"datetimestamp",
".",
"minute",
",",
"datetimestamp",
".",
"second",
")"
] |
Convert seconds past Epoch to human readable string.
|
[
"Convert",
"seconds",
"past",
"Epoch",
"to",
"human",
"readable",
"string",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/training/util.py#L109-L117
|
train
|
allenai/allennlp
|
allennlp/training/util.py
|
str_to_time
|
def str_to_time(time_str: str) -> datetime.datetime:
"""
Convert human readable string to datetime.datetime.
"""
pieces: Any = [int(piece) for piece in time_str.split('-')]
return datetime.datetime(*pieces)
|
python
|
def str_to_time(time_str: str) -> datetime.datetime:
"""
Convert human readable string to datetime.datetime.
"""
pieces: Any = [int(piece) for piece in time_str.split('-')]
return datetime.datetime(*pieces)
|
[
"def",
"str_to_time",
"(",
"time_str",
":",
"str",
")",
"->",
"datetime",
".",
"datetime",
":",
"pieces",
":",
"Any",
"=",
"[",
"int",
"(",
"piece",
")",
"for",
"piece",
"in",
"time_str",
".",
"split",
"(",
"'-'",
")",
"]",
"return",
"datetime",
".",
"datetime",
"(",
"*",
"pieces",
")"
] |
Convert human readable string to datetime.datetime.
|
[
"Convert",
"human",
"readable",
"string",
"to",
"datetime",
".",
"datetime",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/training/util.py#L120-L125
|
train
|
allenai/allennlp
|
allennlp/training/util.py
|
datasets_from_params
|
def datasets_from_params(params: Params,
cache_directory: str = None,
cache_prefix: str = None) -> Dict[str, Iterable[Instance]]:
"""
Load all the datasets specified by the config.
Parameters
----------
params : ``Params``
cache_directory : ``str``, optional
If given, we will instruct the ``DatasetReaders`` that we construct to cache their
instances in this location (or read their instances from caches in this location, if a
suitable cache already exists). This is essentially a `base` directory for the cache, as
we will additionally add the ``cache_prefix`` to this directory, giving an actual cache
location of ``cache_directory + cache_prefix``.
cache_prefix : ``str``, optional
This works in conjunction with the ``cache_directory``. The idea is that the
``cache_directory`` contains caches for all different parameter settings, while the
``cache_prefix`` captures a specific set of parameters that led to a particular cache file.
That is, if you change the tokenization settings inside your ``DatasetReader``, you don't
want to read cached data that used the old settings. In order to avoid this, we compute a
hash of the parameters used to construct each ``DatasetReader`` and use that as a "prefix"
to the cache files inside the base ``cache_directory``. So, a given ``input_file`` would
be cached essentially as ``cache_directory + cache_prefix + input_file``, where you specify
a ``cache_directory``, the ``cache_prefix`` is based on the dataset reader parameters, and
the ``input_file`` is whatever path you provided to ``DatasetReader.read()``. In order to
allow you to give recognizable names to these prefixes if you want them, you can manually
specify the ``cache_prefix``. Note that in some rare cases this can be dangerous, as we'll
use the `same` prefix for both train and validation dataset readers.
"""
dataset_reader_params = params.pop('dataset_reader')
validation_dataset_reader_params = params.pop('validation_dataset_reader', None)
train_cache_dir, validation_cache_dir = _set_up_cache_files(dataset_reader_params,
validation_dataset_reader_params,
cache_directory,
cache_prefix)
dataset_reader = DatasetReader.from_params(dataset_reader_params)
validation_and_test_dataset_reader: DatasetReader = dataset_reader
if validation_dataset_reader_params is not None:
logger.info("Using a separate dataset reader to load validation and test data.")
validation_and_test_dataset_reader = DatasetReader.from_params(validation_dataset_reader_params)
if train_cache_dir:
dataset_reader.cache_data(train_cache_dir)
validation_and_test_dataset_reader.cache_data(validation_cache_dir)
train_data_path = params.pop('train_data_path')
logger.info("Reading training data from %s", train_data_path)
train_data = dataset_reader.read(train_data_path)
datasets: Dict[str, Iterable[Instance]] = {"train": train_data}
validation_data_path = params.pop('validation_data_path', None)
if validation_data_path is not None:
logger.info("Reading validation data from %s", validation_data_path)
validation_data = validation_and_test_dataset_reader.read(validation_data_path)
datasets["validation"] = validation_data
test_data_path = params.pop("test_data_path", None)
if test_data_path is not None:
logger.info("Reading test data from %s", test_data_path)
test_data = validation_and_test_dataset_reader.read(test_data_path)
datasets["test"] = test_data
return datasets
|
python
|
def datasets_from_params(params: Params,
cache_directory: str = None,
cache_prefix: str = None) -> Dict[str, Iterable[Instance]]:
"""
Load all the datasets specified by the config.
Parameters
----------
params : ``Params``
cache_directory : ``str``, optional
If given, we will instruct the ``DatasetReaders`` that we construct to cache their
instances in this location (or read their instances from caches in this location, if a
suitable cache already exists). This is essentially a `base` directory for the cache, as
we will additionally add the ``cache_prefix`` to this directory, giving an actual cache
location of ``cache_directory + cache_prefix``.
cache_prefix : ``str``, optional
This works in conjunction with the ``cache_directory``. The idea is that the
``cache_directory`` contains caches for all different parameter settings, while the
``cache_prefix`` captures a specific set of parameters that led to a particular cache file.
That is, if you change the tokenization settings inside your ``DatasetReader``, you don't
want to read cached data that used the old settings. In order to avoid this, we compute a
hash of the parameters used to construct each ``DatasetReader`` and use that as a "prefix"
to the cache files inside the base ``cache_directory``. So, a given ``input_file`` would
be cached essentially as ``cache_directory + cache_prefix + input_file``, where you specify
a ``cache_directory``, the ``cache_prefix`` is based on the dataset reader parameters, and
the ``input_file`` is whatever path you provided to ``DatasetReader.read()``. In order to
allow you to give recognizable names to these prefixes if you want them, you can manually
specify the ``cache_prefix``. Note that in some rare cases this can be dangerous, as we'll
use the `same` prefix for both train and validation dataset readers.
"""
dataset_reader_params = params.pop('dataset_reader')
validation_dataset_reader_params = params.pop('validation_dataset_reader', None)
train_cache_dir, validation_cache_dir = _set_up_cache_files(dataset_reader_params,
validation_dataset_reader_params,
cache_directory,
cache_prefix)
dataset_reader = DatasetReader.from_params(dataset_reader_params)
validation_and_test_dataset_reader: DatasetReader = dataset_reader
if validation_dataset_reader_params is not None:
logger.info("Using a separate dataset reader to load validation and test data.")
validation_and_test_dataset_reader = DatasetReader.from_params(validation_dataset_reader_params)
if train_cache_dir:
dataset_reader.cache_data(train_cache_dir)
validation_and_test_dataset_reader.cache_data(validation_cache_dir)
train_data_path = params.pop('train_data_path')
logger.info("Reading training data from %s", train_data_path)
train_data = dataset_reader.read(train_data_path)
datasets: Dict[str, Iterable[Instance]] = {"train": train_data}
validation_data_path = params.pop('validation_data_path', None)
if validation_data_path is not None:
logger.info("Reading validation data from %s", validation_data_path)
validation_data = validation_and_test_dataset_reader.read(validation_data_path)
datasets["validation"] = validation_data
test_data_path = params.pop("test_data_path", None)
if test_data_path is not None:
logger.info("Reading test data from %s", test_data_path)
test_data = validation_and_test_dataset_reader.read(test_data_path)
datasets["test"] = test_data
return datasets
|
[
"def",
"datasets_from_params",
"(",
"params",
":",
"Params",
",",
"cache_directory",
":",
"str",
"=",
"None",
",",
"cache_prefix",
":",
"str",
"=",
"None",
")",
"->",
"Dict",
"[",
"str",
",",
"Iterable",
"[",
"Instance",
"]",
"]",
":",
"dataset_reader_params",
"=",
"params",
".",
"pop",
"(",
"'dataset_reader'",
")",
"validation_dataset_reader_params",
"=",
"params",
".",
"pop",
"(",
"'validation_dataset_reader'",
",",
"None",
")",
"train_cache_dir",
",",
"validation_cache_dir",
"=",
"_set_up_cache_files",
"(",
"dataset_reader_params",
",",
"validation_dataset_reader_params",
",",
"cache_directory",
",",
"cache_prefix",
")",
"dataset_reader",
"=",
"DatasetReader",
".",
"from_params",
"(",
"dataset_reader_params",
")",
"validation_and_test_dataset_reader",
":",
"DatasetReader",
"=",
"dataset_reader",
"if",
"validation_dataset_reader_params",
"is",
"not",
"None",
":",
"logger",
".",
"info",
"(",
"\"Using a separate dataset reader to load validation and test data.\"",
")",
"validation_and_test_dataset_reader",
"=",
"DatasetReader",
".",
"from_params",
"(",
"validation_dataset_reader_params",
")",
"if",
"train_cache_dir",
":",
"dataset_reader",
".",
"cache_data",
"(",
"train_cache_dir",
")",
"validation_and_test_dataset_reader",
".",
"cache_data",
"(",
"validation_cache_dir",
")",
"train_data_path",
"=",
"params",
".",
"pop",
"(",
"'train_data_path'",
")",
"logger",
".",
"info",
"(",
"\"Reading training data from %s\"",
",",
"train_data_path",
")",
"train_data",
"=",
"dataset_reader",
".",
"read",
"(",
"train_data_path",
")",
"datasets",
":",
"Dict",
"[",
"str",
",",
"Iterable",
"[",
"Instance",
"]",
"]",
"=",
"{",
"\"train\"",
":",
"train_data",
"}",
"validation_data_path",
"=",
"params",
".",
"pop",
"(",
"'validation_data_path'",
",",
"None",
")",
"if",
"validation_data_path",
"is",
"not",
"None",
":",
"logger",
".",
"info",
"(",
"\"Reading validation data from %s\"",
",",
"validation_data_path",
")",
"validation_data",
"=",
"validation_and_test_dataset_reader",
".",
"read",
"(",
"validation_data_path",
")",
"datasets",
"[",
"\"validation\"",
"]",
"=",
"validation_data",
"test_data_path",
"=",
"params",
".",
"pop",
"(",
"\"test_data_path\"",
",",
"None",
")",
"if",
"test_data_path",
"is",
"not",
"None",
":",
"logger",
".",
"info",
"(",
"\"Reading test data from %s\"",
",",
"test_data_path",
")",
"test_data",
"=",
"validation_and_test_dataset_reader",
".",
"read",
"(",
"test_data_path",
")",
"datasets",
"[",
"\"test\"",
"]",
"=",
"test_data",
"return",
"datasets"
] |
Load all the datasets specified by the config.
Parameters
----------
params : ``Params``
cache_directory : ``str``, optional
If given, we will instruct the ``DatasetReaders`` that we construct to cache their
instances in this location (or read their instances from caches in this location, if a
suitable cache already exists). This is essentially a `base` directory for the cache, as
we will additionally add the ``cache_prefix`` to this directory, giving an actual cache
location of ``cache_directory + cache_prefix``.
cache_prefix : ``str``, optional
This works in conjunction with the ``cache_directory``. The idea is that the
``cache_directory`` contains caches for all different parameter settings, while the
``cache_prefix`` captures a specific set of parameters that led to a particular cache file.
That is, if you change the tokenization settings inside your ``DatasetReader``, you don't
want to read cached data that used the old settings. In order to avoid this, we compute a
hash of the parameters used to construct each ``DatasetReader`` and use that as a "prefix"
to the cache files inside the base ``cache_directory``. So, a given ``input_file`` would
be cached essentially as ``cache_directory + cache_prefix + input_file``, where you specify
a ``cache_directory``, the ``cache_prefix`` is based on the dataset reader parameters, and
the ``input_file`` is whatever path you provided to ``DatasetReader.read()``. In order to
allow you to give recognizable names to these prefixes if you want them, you can manually
specify the ``cache_prefix``. Note that in some rare cases this can be dangerous, as we'll
use the `same` prefix for both train and validation dataset readers.
|
[
"Load",
"all",
"the",
"datasets",
"specified",
"by",
"the",
"config",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/training/util.py#L128-L194
|
train
|
allenai/allennlp
|
allennlp/training/util.py
|
create_serialization_dir
|
def create_serialization_dir(
params: Params,
serialization_dir: str,
recover: bool,
force: bool) -> None:
"""
This function creates the serialization directory if it doesn't exist. If it already exists
and is non-empty, then it verifies that we're recovering from a training with an identical configuration.
Parameters
----------
params: ``Params``
A parameter object specifying an AllenNLP Experiment.
serialization_dir: ``str``
The directory in which to save results and logs.
recover: ``bool``
If ``True``, we will try to recover from an existing serialization directory, and crash if
the directory doesn't exist, or doesn't match the configuration we're given.
force: ``bool``
If ``True``, we will overwrite the serialization directory if it already exists.
"""
if recover and force:
raise ConfigurationError("Illegal arguments: both force and recover are true.")
if os.path.exists(serialization_dir) and force:
shutil.rmtree(serialization_dir)
if os.path.exists(serialization_dir) and os.listdir(serialization_dir):
if not recover:
raise ConfigurationError(f"Serialization directory ({serialization_dir}) already exists and is "
f"not empty. Specify --recover to recover training from existing output.")
logger.info(f"Recovering from prior training at {serialization_dir}.")
recovered_config_file = os.path.join(serialization_dir, CONFIG_NAME)
if not os.path.exists(recovered_config_file):
raise ConfigurationError("The serialization directory already exists but doesn't "
"contain a config.json. You probably gave the wrong directory.")
else:
loaded_params = Params.from_file(recovered_config_file)
# Check whether any of the training configuration differs from the configuration we are
# resuming. If so, warn the user that training may fail.
fail = False
flat_params = params.as_flat_dict()
flat_loaded = loaded_params.as_flat_dict()
for key in flat_params.keys() - flat_loaded.keys():
logger.error(f"Key '{key}' found in training configuration but not in the serialization "
f"directory we're recovering from.")
fail = True
for key in flat_loaded.keys() - flat_params.keys():
logger.error(f"Key '{key}' found in the serialization directory we're recovering from "
f"but not in the training config.")
fail = True
for key in flat_params.keys():
if flat_params.get(key, None) != flat_loaded.get(key, None):
logger.error(f"Value for '{key}' in training configuration does not match that the value in "
f"the serialization directory we're recovering from: "
f"{flat_params[key]} != {flat_loaded[key]}")
fail = True
if fail:
raise ConfigurationError("Training configuration does not match the configuration we're "
"recovering from.")
else:
if recover:
raise ConfigurationError(f"--recover specified but serialization_dir ({serialization_dir}) "
"does not exist. There is nothing to recover from.")
os.makedirs(serialization_dir, exist_ok=True)
|
python
|
def create_serialization_dir(
params: Params,
serialization_dir: str,
recover: bool,
force: bool) -> None:
"""
This function creates the serialization directory if it doesn't exist. If it already exists
and is non-empty, then it verifies that we're recovering from a training with an identical configuration.
Parameters
----------
params: ``Params``
A parameter object specifying an AllenNLP Experiment.
serialization_dir: ``str``
The directory in which to save results and logs.
recover: ``bool``
If ``True``, we will try to recover from an existing serialization directory, and crash if
the directory doesn't exist, or doesn't match the configuration we're given.
force: ``bool``
If ``True``, we will overwrite the serialization directory if it already exists.
"""
if recover and force:
raise ConfigurationError("Illegal arguments: both force and recover are true.")
if os.path.exists(serialization_dir) and force:
shutil.rmtree(serialization_dir)
if os.path.exists(serialization_dir) and os.listdir(serialization_dir):
if not recover:
raise ConfigurationError(f"Serialization directory ({serialization_dir}) already exists and is "
f"not empty. Specify --recover to recover training from existing output.")
logger.info(f"Recovering from prior training at {serialization_dir}.")
recovered_config_file = os.path.join(serialization_dir, CONFIG_NAME)
if not os.path.exists(recovered_config_file):
raise ConfigurationError("The serialization directory already exists but doesn't "
"contain a config.json. You probably gave the wrong directory.")
else:
loaded_params = Params.from_file(recovered_config_file)
# Check whether any of the training configuration differs from the configuration we are
# resuming. If so, warn the user that training may fail.
fail = False
flat_params = params.as_flat_dict()
flat_loaded = loaded_params.as_flat_dict()
for key in flat_params.keys() - flat_loaded.keys():
logger.error(f"Key '{key}' found in training configuration but not in the serialization "
f"directory we're recovering from.")
fail = True
for key in flat_loaded.keys() - flat_params.keys():
logger.error(f"Key '{key}' found in the serialization directory we're recovering from "
f"but not in the training config.")
fail = True
for key in flat_params.keys():
if flat_params.get(key, None) != flat_loaded.get(key, None):
logger.error(f"Value for '{key}' in training configuration does not match that the value in "
f"the serialization directory we're recovering from: "
f"{flat_params[key]} != {flat_loaded[key]}")
fail = True
if fail:
raise ConfigurationError("Training configuration does not match the configuration we're "
"recovering from.")
else:
if recover:
raise ConfigurationError(f"--recover specified but serialization_dir ({serialization_dir}) "
"does not exist. There is nothing to recover from.")
os.makedirs(serialization_dir, exist_ok=True)
|
[
"def",
"create_serialization_dir",
"(",
"params",
":",
"Params",
",",
"serialization_dir",
":",
"str",
",",
"recover",
":",
"bool",
",",
"force",
":",
"bool",
")",
"->",
"None",
":",
"if",
"recover",
"and",
"force",
":",
"raise",
"ConfigurationError",
"(",
"\"Illegal arguments: both force and recover are true.\"",
")",
"if",
"os",
".",
"path",
".",
"exists",
"(",
"serialization_dir",
")",
"and",
"force",
":",
"shutil",
".",
"rmtree",
"(",
"serialization_dir",
")",
"if",
"os",
".",
"path",
".",
"exists",
"(",
"serialization_dir",
")",
"and",
"os",
".",
"listdir",
"(",
"serialization_dir",
")",
":",
"if",
"not",
"recover",
":",
"raise",
"ConfigurationError",
"(",
"f\"Serialization directory ({serialization_dir}) already exists and is \"",
"f\"not empty. Specify --recover to recover training from existing output.\"",
")",
"logger",
".",
"info",
"(",
"f\"Recovering from prior training at {serialization_dir}.\"",
")",
"recovered_config_file",
"=",
"os",
".",
"path",
".",
"join",
"(",
"serialization_dir",
",",
"CONFIG_NAME",
")",
"if",
"not",
"os",
".",
"path",
".",
"exists",
"(",
"recovered_config_file",
")",
":",
"raise",
"ConfigurationError",
"(",
"\"The serialization directory already exists but doesn't \"",
"\"contain a config.json. You probably gave the wrong directory.\"",
")",
"else",
":",
"loaded_params",
"=",
"Params",
".",
"from_file",
"(",
"recovered_config_file",
")",
"# Check whether any of the training configuration differs from the configuration we are",
"# resuming. If so, warn the user that training may fail.",
"fail",
"=",
"False",
"flat_params",
"=",
"params",
".",
"as_flat_dict",
"(",
")",
"flat_loaded",
"=",
"loaded_params",
".",
"as_flat_dict",
"(",
")",
"for",
"key",
"in",
"flat_params",
".",
"keys",
"(",
")",
"-",
"flat_loaded",
".",
"keys",
"(",
")",
":",
"logger",
".",
"error",
"(",
"f\"Key '{key}' found in training configuration but not in the serialization \"",
"f\"directory we're recovering from.\"",
")",
"fail",
"=",
"True",
"for",
"key",
"in",
"flat_loaded",
".",
"keys",
"(",
")",
"-",
"flat_params",
".",
"keys",
"(",
")",
":",
"logger",
".",
"error",
"(",
"f\"Key '{key}' found in the serialization directory we're recovering from \"",
"f\"but not in the training config.\"",
")",
"fail",
"=",
"True",
"for",
"key",
"in",
"flat_params",
".",
"keys",
"(",
")",
":",
"if",
"flat_params",
".",
"get",
"(",
"key",
",",
"None",
")",
"!=",
"flat_loaded",
".",
"get",
"(",
"key",
",",
"None",
")",
":",
"logger",
".",
"error",
"(",
"f\"Value for '{key}' in training configuration does not match that the value in \"",
"f\"the serialization directory we're recovering from: \"",
"f\"{flat_params[key]} != {flat_loaded[key]}\"",
")",
"fail",
"=",
"True",
"if",
"fail",
":",
"raise",
"ConfigurationError",
"(",
"\"Training configuration does not match the configuration we're \"",
"\"recovering from.\"",
")",
"else",
":",
"if",
"recover",
":",
"raise",
"ConfigurationError",
"(",
"f\"--recover specified but serialization_dir ({serialization_dir}) \"",
"\"does not exist. There is nothing to recover from.\"",
")",
"os",
".",
"makedirs",
"(",
"serialization_dir",
",",
"exist_ok",
"=",
"True",
")"
] |
This function creates the serialization directory if it doesn't exist. If it already exists
and is non-empty, then it verifies that we're recovering from a training with an identical configuration.
Parameters
----------
params: ``Params``
A parameter object specifying an AllenNLP Experiment.
serialization_dir: ``str``
The directory in which to save results and logs.
recover: ``bool``
If ``True``, we will try to recover from an existing serialization directory, and crash if
the directory doesn't exist, or doesn't match the configuration we're given.
force: ``bool``
If ``True``, we will overwrite the serialization directory if it already exists.
|
[
"This",
"function",
"creates",
"the",
"serialization",
"directory",
"if",
"it",
"doesn",
"t",
"exist",
".",
"If",
"it",
"already",
"exists",
"and",
"is",
"non",
"-",
"empty",
"then",
"it",
"verifies",
"that",
"we",
"re",
"recovering",
"from",
"a",
"training",
"with",
"an",
"identical",
"configuration",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/training/util.py#L242-L309
|
train
|
allenai/allennlp
|
allennlp/training/util.py
|
data_parallel
|
def data_parallel(batch_group: List[TensorDict],
model: Model,
cuda_devices: List) -> Dict[str, torch.Tensor]:
"""
Performs a forward pass using multiple GPUs. This is a simplification
of torch.nn.parallel.data_parallel to support the allennlp model
interface.
"""
assert len(batch_group) <= len(cuda_devices)
moved = [nn_util.move_to_device(batch, device)
for batch, device in zip(batch_group, cuda_devices)]
used_device_ids = cuda_devices[:len(moved)]
# Counterintuitively, it appears replicate expects the source device id to be the first element
# in the device id list. See torch.cuda.comm.broadcast_coalesced, which is called indirectly.
replicas = replicate(model, used_device_ids)
# We pass all our arguments as kwargs. Create a list of empty tuples of the
# correct shape to serve as (non-existent) positional arguments.
inputs = [()] * len(batch_group)
outputs = parallel_apply(replicas, inputs, moved, used_device_ids)
# Only the 'loss' is needed.
# a (num_gpu, ) tensor with loss on each GPU
losses = gather([output['loss'].unsqueeze(0) for output in outputs], used_device_ids[0], 0)
return {'loss': losses.mean()}
|
python
|
def data_parallel(batch_group: List[TensorDict],
model: Model,
cuda_devices: List) -> Dict[str, torch.Tensor]:
"""
Performs a forward pass using multiple GPUs. This is a simplification
of torch.nn.parallel.data_parallel to support the allennlp model
interface.
"""
assert len(batch_group) <= len(cuda_devices)
moved = [nn_util.move_to_device(batch, device)
for batch, device in zip(batch_group, cuda_devices)]
used_device_ids = cuda_devices[:len(moved)]
# Counterintuitively, it appears replicate expects the source device id to be the first element
# in the device id list. See torch.cuda.comm.broadcast_coalesced, which is called indirectly.
replicas = replicate(model, used_device_ids)
# We pass all our arguments as kwargs. Create a list of empty tuples of the
# correct shape to serve as (non-existent) positional arguments.
inputs = [()] * len(batch_group)
outputs = parallel_apply(replicas, inputs, moved, used_device_ids)
# Only the 'loss' is needed.
# a (num_gpu, ) tensor with loss on each GPU
losses = gather([output['loss'].unsqueeze(0) for output in outputs], used_device_ids[0], 0)
return {'loss': losses.mean()}
|
[
"def",
"data_parallel",
"(",
"batch_group",
":",
"List",
"[",
"TensorDict",
"]",
",",
"model",
":",
"Model",
",",
"cuda_devices",
":",
"List",
")",
"->",
"Dict",
"[",
"str",
",",
"torch",
".",
"Tensor",
"]",
":",
"assert",
"len",
"(",
"batch_group",
")",
"<=",
"len",
"(",
"cuda_devices",
")",
"moved",
"=",
"[",
"nn_util",
".",
"move_to_device",
"(",
"batch",
",",
"device",
")",
"for",
"batch",
",",
"device",
"in",
"zip",
"(",
"batch_group",
",",
"cuda_devices",
")",
"]",
"used_device_ids",
"=",
"cuda_devices",
"[",
":",
"len",
"(",
"moved",
")",
"]",
"# Counterintuitively, it appears replicate expects the source device id to be the first element",
"# in the device id list. See torch.cuda.comm.broadcast_coalesced, which is called indirectly.",
"replicas",
"=",
"replicate",
"(",
"model",
",",
"used_device_ids",
")",
"# We pass all our arguments as kwargs. Create a list of empty tuples of the",
"# correct shape to serve as (non-existent) positional arguments.",
"inputs",
"=",
"[",
"(",
")",
"]",
"*",
"len",
"(",
"batch_group",
")",
"outputs",
"=",
"parallel_apply",
"(",
"replicas",
",",
"inputs",
",",
"moved",
",",
"used_device_ids",
")",
"# Only the 'loss' is needed.",
"# a (num_gpu, ) tensor with loss on each GPU",
"losses",
"=",
"gather",
"(",
"[",
"output",
"[",
"'loss'",
"]",
".",
"unsqueeze",
"(",
"0",
")",
"for",
"output",
"in",
"outputs",
"]",
",",
"used_device_ids",
"[",
"0",
"]",
",",
"0",
")",
"return",
"{",
"'loss'",
":",
"losses",
".",
"mean",
"(",
")",
"}"
] |
Performs a forward pass using multiple GPUs. This is a simplification
of torch.nn.parallel.data_parallel to support the allennlp model
interface.
|
[
"Performs",
"a",
"forward",
"pass",
"using",
"multiple",
"GPUs",
".",
"This",
"is",
"a",
"simplification",
"of",
"torch",
".",
"nn",
".",
"parallel",
".",
"data_parallel",
"to",
"support",
"the",
"allennlp",
"model",
"interface",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/training/util.py#L311-L337
|
train
|
allenai/allennlp
|
allennlp/training/util.py
|
rescale_gradients
|
def rescale_gradients(model: Model, grad_norm: Optional[float] = None) -> Optional[float]:
"""
Performs gradient rescaling. Is a no-op if gradient rescaling is not enabled.
"""
if grad_norm:
parameters_to_clip = [p for p in model.parameters()
if p.grad is not None]
return sparse_clip_norm(parameters_to_clip, grad_norm)
return None
|
python
|
def rescale_gradients(model: Model, grad_norm: Optional[float] = None) -> Optional[float]:
"""
Performs gradient rescaling. Is a no-op if gradient rescaling is not enabled.
"""
if grad_norm:
parameters_to_clip = [p for p in model.parameters()
if p.grad is not None]
return sparse_clip_norm(parameters_to_clip, grad_norm)
return None
|
[
"def",
"rescale_gradients",
"(",
"model",
":",
"Model",
",",
"grad_norm",
":",
"Optional",
"[",
"float",
"]",
"=",
"None",
")",
"->",
"Optional",
"[",
"float",
"]",
":",
"if",
"grad_norm",
":",
"parameters_to_clip",
"=",
"[",
"p",
"for",
"p",
"in",
"model",
".",
"parameters",
"(",
")",
"if",
"p",
".",
"grad",
"is",
"not",
"None",
"]",
"return",
"sparse_clip_norm",
"(",
"parameters_to_clip",
",",
"grad_norm",
")",
"return",
"None"
] |
Performs gradient rescaling. Is a no-op if gradient rescaling is not enabled.
|
[
"Performs",
"gradient",
"rescaling",
".",
"Is",
"a",
"no",
"-",
"op",
"if",
"gradient",
"rescaling",
"is",
"not",
"enabled",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/training/util.py#L347-L355
|
train
|
allenai/allennlp
|
allennlp/training/util.py
|
get_metrics
|
def get_metrics(model: Model, total_loss: float, num_batches: int, reset: bool = False) -> Dict[str, float]:
"""
Gets the metrics but sets ``"loss"`` to
the total loss divided by the ``num_batches`` so that
the ``"loss"`` metric is "average loss per batch".
"""
metrics = model.get_metrics(reset=reset)
metrics["loss"] = float(total_loss / num_batches) if num_batches > 0 else 0.0
return metrics
|
python
|
def get_metrics(model: Model, total_loss: float, num_batches: int, reset: bool = False) -> Dict[str, float]:
"""
Gets the metrics but sets ``"loss"`` to
the total loss divided by the ``num_batches`` so that
the ``"loss"`` metric is "average loss per batch".
"""
metrics = model.get_metrics(reset=reset)
metrics["loss"] = float(total_loss / num_batches) if num_batches > 0 else 0.0
return metrics
|
[
"def",
"get_metrics",
"(",
"model",
":",
"Model",
",",
"total_loss",
":",
"float",
",",
"num_batches",
":",
"int",
",",
"reset",
":",
"bool",
"=",
"False",
")",
"->",
"Dict",
"[",
"str",
",",
"float",
"]",
":",
"metrics",
"=",
"model",
".",
"get_metrics",
"(",
"reset",
"=",
"reset",
")",
"metrics",
"[",
"\"loss\"",
"]",
"=",
"float",
"(",
"total_loss",
"/",
"num_batches",
")",
"if",
"num_batches",
">",
"0",
"else",
"0.0",
"return",
"metrics"
] |
Gets the metrics but sets ``"loss"`` to
the total loss divided by the ``num_batches`` so that
the ``"loss"`` metric is "average loss per batch".
|
[
"Gets",
"the",
"metrics",
"but",
"sets",
"loss",
"to",
"the",
"total",
"loss",
"divided",
"by",
"the",
"num_batches",
"so",
"that",
"the",
"loss",
"metric",
"is",
"average",
"loss",
"per",
"batch",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/training/util.py#L357-L365
|
train
|
allenai/allennlp
|
scripts/check_requirements_and_setup.py
|
parse_requirements
|
def parse_requirements() -> Tuple[PackagesType, PackagesType, Set[str]]:
"""Parse all dependencies out of the requirements.txt file."""
essential_packages: PackagesType = {}
other_packages: PackagesType = {}
duplicates: Set[str] = set()
with open("requirements.txt", "r") as req_file:
section: str = ""
for line in req_file:
line = line.strip()
if line.startswith("####"):
# Line is a section name.
section = parse_section_name(line)
continue
if not line or line.startswith("#"):
# Line is empty or just regular comment.
continue
module, version = parse_package(line)
if module in essential_packages or module in other_packages:
duplicates.add(module)
if section.startswith("ESSENTIAL"):
essential_packages[module] = version
else:
other_packages[module] = version
return essential_packages, other_packages, duplicates
|
python
|
def parse_requirements() -> Tuple[PackagesType, PackagesType, Set[str]]:
"""Parse all dependencies out of the requirements.txt file."""
essential_packages: PackagesType = {}
other_packages: PackagesType = {}
duplicates: Set[str] = set()
with open("requirements.txt", "r") as req_file:
section: str = ""
for line in req_file:
line = line.strip()
if line.startswith("####"):
# Line is a section name.
section = parse_section_name(line)
continue
if not line or line.startswith("#"):
# Line is empty or just regular comment.
continue
module, version = parse_package(line)
if module in essential_packages or module in other_packages:
duplicates.add(module)
if section.startswith("ESSENTIAL"):
essential_packages[module] = version
else:
other_packages[module] = version
return essential_packages, other_packages, duplicates
|
[
"def",
"parse_requirements",
"(",
")",
"->",
"Tuple",
"[",
"PackagesType",
",",
"PackagesType",
",",
"Set",
"[",
"str",
"]",
"]",
":",
"essential_packages",
":",
"PackagesType",
"=",
"{",
"}",
"other_packages",
":",
"PackagesType",
"=",
"{",
"}",
"duplicates",
":",
"Set",
"[",
"str",
"]",
"=",
"set",
"(",
")",
"with",
"open",
"(",
"\"requirements.txt\"",
",",
"\"r\"",
")",
"as",
"req_file",
":",
"section",
":",
"str",
"=",
"\"\"",
"for",
"line",
"in",
"req_file",
":",
"line",
"=",
"line",
".",
"strip",
"(",
")",
"if",
"line",
".",
"startswith",
"(",
"\"####\"",
")",
":",
"# Line is a section name.",
"section",
"=",
"parse_section_name",
"(",
"line",
")",
"continue",
"if",
"not",
"line",
"or",
"line",
".",
"startswith",
"(",
"\"#\"",
")",
":",
"# Line is empty or just regular comment.",
"continue",
"module",
",",
"version",
"=",
"parse_package",
"(",
"line",
")",
"if",
"module",
"in",
"essential_packages",
"or",
"module",
"in",
"other_packages",
":",
"duplicates",
".",
"add",
"(",
"module",
")",
"if",
"section",
".",
"startswith",
"(",
"\"ESSENTIAL\"",
")",
":",
"essential_packages",
"[",
"module",
"]",
"=",
"version",
"else",
":",
"other_packages",
"[",
"module",
"]",
"=",
"version",
"return",
"essential_packages",
",",
"other_packages",
",",
"duplicates"
] |
Parse all dependencies out of the requirements.txt file.
|
[
"Parse",
"all",
"dependencies",
"out",
"of",
"the",
"requirements",
".",
"txt",
"file",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/scripts/check_requirements_and_setup.py#L32-L60
|
train
|
allenai/allennlp
|
scripts/check_requirements_and_setup.py
|
parse_setup
|
def parse_setup() -> Tuple[PackagesType, PackagesType, Set[str], Set[str]]:
"""Parse all dependencies out of the setup.py script."""
essential_packages: PackagesType = {}
test_packages: PackagesType = {}
essential_duplicates: Set[str] = set()
test_duplicates: Set[str] = set()
with open('setup.py') as setup_file:
contents = setup_file.read()
# Parse out essential packages.
package_string = re.search(r"""install_requires=\[[\s\n]*['"](.*?)['"],?[\s\n]*\]""",
contents, re.DOTALL).groups()[0].strip()
for package in re.split(r"""['"],[\s\n]+['"]""", package_string):
module, version = parse_package(package)
if module in essential_packages:
essential_duplicates.add(module)
else:
essential_packages[module] = version
# Parse packages only needed for testing.
package_string = re.search(r"""tests_require=\[[\s\n]*['"](.*?)['"],?[\s\n]*\]""",
contents, re.DOTALL).groups()[0].strip()
for package in re.split(r"""['"],[\s\n]+['"]""", package_string):
module, version = parse_package(package)
if module in test_packages:
test_duplicates.add(module)
else:
test_packages[module] = version
return essential_packages, test_packages, essential_duplicates, test_duplicates
|
python
|
def parse_setup() -> Tuple[PackagesType, PackagesType, Set[str], Set[str]]:
"""Parse all dependencies out of the setup.py script."""
essential_packages: PackagesType = {}
test_packages: PackagesType = {}
essential_duplicates: Set[str] = set()
test_duplicates: Set[str] = set()
with open('setup.py') as setup_file:
contents = setup_file.read()
# Parse out essential packages.
package_string = re.search(r"""install_requires=\[[\s\n]*['"](.*?)['"],?[\s\n]*\]""",
contents, re.DOTALL).groups()[0].strip()
for package in re.split(r"""['"],[\s\n]+['"]""", package_string):
module, version = parse_package(package)
if module in essential_packages:
essential_duplicates.add(module)
else:
essential_packages[module] = version
# Parse packages only needed for testing.
package_string = re.search(r"""tests_require=\[[\s\n]*['"](.*?)['"],?[\s\n]*\]""",
contents, re.DOTALL).groups()[0].strip()
for package in re.split(r"""['"],[\s\n]+['"]""", package_string):
module, version = parse_package(package)
if module in test_packages:
test_duplicates.add(module)
else:
test_packages[module] = version
return essential_packages, test_packages, essential_duplicates, test_duplicates
|
[
"def",
"parse_setup",
"(",
")",
"->",
"Tuple",
"[",
"PackagesType",
",",
"PackagesType",
",",
"Set",
"[",
"str",
"]",
",",
"Set",
"[",
"str",
"]",
"]",
":",
"essential_packages",
":",
"PackagesType",
"=",
"{",
"}",
"test_packages",
":",
"PackagesType",
"=",
"{",
"}",
"essential_duplicates",
":",
"Set",
"[",
"str",
"]",
"=",
"set",
"(",
")",
"test_duplicates",
":",
"Set",
"[",
"str",
"]",
"=",
"set",
"(",
")",
"with",
"open",
"(",
"'setup.py'",
")",
"as",
"setup_file",
":",
"contents",
"=",
"setup_file",
".",
"read",
"(",
")",
"# Parse out essential packages.",
"package_string",
"=",
"re",
".",
"search",
"(",
"r\"\"\"install_requires=\\[[\\s\\n]*['\"](.*?)['\"],?[\\s\\n]*\\]\"\"\"",
",",
"contents",
",",
"re",
".",
"DOTALL",
")",
".",
"groups",
"(",
")",
"[",
"0",
"]",
".",
"strip",
"(",
")",
"for",
"package",
"in",
"re",
".",
"split",
"(",
"r\"\"\"['\"],[\\s\\n]+['\"]\"\"\"",
",",
"package_string",
")",
":",
"module",
",",
"version",
"=",
"parse_package",
"(",
"package",
")",
"if",
"module",
"in",
"essential_packages",
":",
"essential_duplicates",
".",
"add",
"(",
"module",
")",
"else",
":",
"essential_packages",
"[",
"module",
"]",
"=",
"version",
"# Parse packages only needed for testing.",
"package_string",
"=",
"re",
".",
"search",
"(",
"r\"\"\"tests_require=\\[[\\s\\n]*['\"](.*?)['\"],?[\\s\\n]*\\]\"\"\"",
",",
"contents",
",",
"re",
".",
"DOTALL",
")",
".",
"groups",
"(",
")",
"[",
"0",
"]",
".",
"strip",
"(",
")",
"for",
"package",
"in",
"re",
".",
"split",
"(",
"r\"\"\"['\"],[\\s\\n]+['\"]\"\"\"",
",",
"package_string",
")",
":",
"module",
",",
"version",
"=",
"parse_package",
"(",
"package",
")",
"if",
"module",
"in",
"test_packages",
":",
"test_duplicates",
".",
"add",
"(",
"module",
")",
"else",
":",
"test_packages",
"[",
"module",
"]",
"=",
"version",
"return",
"essential_packages",
",",
"test_packages",
",",
"essential_duplicates",
",",
"test_duplicates"
] |
Parse all dependencies out of the setup.py script.
|
[
"Parse",
"all",
"dependencies",
"out",
"of",
"the",
"setup",
".",
"py",
"script",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/scripts/check_requirements_and_setup.py#L63-L93
|
train
|
allenai/allennlp
|
allennlp/data/dataset_readers/dataset_utils/span_utils.py
|
enumerate_spans
|
def enumerate_spans(sentence: List[T],
offset: int = 0,
max_span_width: int = None,
min_span_width: int = 1,
filter_function: Callable[[List[T]], bool] = None) -> List[Tuple[int, int]]:
"""
Given a sentence, return all token spans within the sentence. Spans are `inclusive`.
Additionally, you can provide a maximum and minimum span width, which will be used
to exclude spans outside of this range.
Finally, you can provide a function mapping ``List[T] -> bool``, which will
be applied to every span to decide whether that span should be included. This
allows filtering by length, regex matches, pos tags or any Spacy ``Token``
attributes, for example.
Parameters
----------
sentence : ``List[T]``, required.
The sentence to generate spans for. The type is generic, as this function
can be used with strings, or Spacy ``Tokens`` or other sequences.
offset : ``int``, optional (default = 0)
A numeric offset to add to all span start and end indices. This is helpful
if the sentence is part of a larger structure, such as a document, which
the indices need to respect.
max_span_width : ``int``, optional (default = None)
The maximum length of spans which should be included. Defaults to len(sentence).
min_span_width : ``int``, optional (default = 1)
The minimum length of spans which should be included. Defaults to 1.
filter_function : ``Callable[[List[T]], bool]``, optional (default = None)
A function mapping sequences of the passed type T to a boolean value.
If ``True``, the span is included in the returned spans from the
sentence, otherwise it is excluded..
"""
max_span_width = max_span_width or len(sentence)
filter_function = filter_function or (lambda x: True)
spans: List[Tuple[int, int]] = []
for start_index in range(len(sentence)):
last_end_index = min(start_index + max_span_width, len(sentence))
first_end_index = min(start_index + min_span_width - 1, len(sentence))
for end_index in range(first_end_index, last_end_index):
start = offset + start_index
end = offset + end_index
# add 1 to end index because span indices are inclusive.
if filter_function(sentence[slice(start_index, end_index + 1)]):
spans.append((start, end))
return spans
|
python
|
def enumerate_spans(sentence: List[T],
offset: int = 0,
max_span_width: int = None,
min_span_width: int = 1,
filter_function: Callable[[List[T]], bool] = None) -> List[Tuple[int, int]]:
"""
Given a sentence, return all token spans within the sentence. Spans are `inclusive`.
Additionally, you can provide a maximum and minimum span width, which will be used
to exclude spans outside of this range.
Finally, you can provide a function mapping ``List[T] -> bool``, which will
be applied to every span to decide whether that span should be included. This
allows filtering by length, regex matches, pos tags or any Spacy ``Token``
attributes, for example.
Parameters
----------
sentence : ``List[T]``, required.
The sentence to generate spans for. The type is generic, as this function
can be used with strings, or Spacy ``Tokens`` or other sequences.
offset : ``int``, optional (default = 0)
A numeric offset to add to all span start and end indices. This is helpful
if the sentence is part of a larger structure, such as a document, which
the indices need to respect.
max_span_width : ``int``, optional (default = None)
The maximum length of spans which should be included. Defaults to len(sentence).
min_span_width : ``int``, optional (default = 1)
The minimum length of spans which should be included. Defaults to 1.
filter_function : ``Callable[[List[T]], bool]``, optional (default = None)
A function mapping sequences of the passed type T to a boolean value.
If ``True``, the span is included in the returned spans from the
sentence, otherwise it is excluded..
"""
max_span_width = max_span_width or len(sentence)
filter_function = filter_function or (lambda x: True)
spans: List[Tuple[int, int]] = []
for start_index in range(len(sentence)):
last_end_index = min(start_index + max_span_width, len(sentence))
first_end_index = min(start_index + min_span_width - 1, len(sentence))
for end_index in range(first_end_index, last_end_index):
start = offset + start_index
end = offset + end_index
# add 1 to end index because span indices are inclusive.
if filter_function(sentence[slice(start_index, end_index + 1)]):
spans.append((start, end))
return spans
|
[
"def",
"enumerate_spans",
"(",
"sentence",
":",
"List",
"[",
"T",
"]",
",",
"offset",
":",
"int",
"=",
"0",
",",
"max_span_width",
":",
"int",
"=",
"None",
",",
"min_span_width",
":",
"int",
"=",
"1",
",",
"filter_function",
":",
"Callable",
"[",
"[",
"List",
"[",
"T",
"]",
"]",
",",
"bool",
"]",
"=",
"None",
")",
"->",
"List",
"[",
"Tuple",
"[",
"int",
",",
"int",
"]",
"]",
":",
"max_span_width",
"=",
"max_span_width",
"or",
"len",
"(",
"sentence",
")",
"filter_function",
"=",
"filter_function",
"or",
"(",
"lambda",
"x",
":",
"True",
")",
"spans",
":",
"List",
"[",
"Tuple",
"[",
"int",
",",
"int",
"]",
"]",
"=",
"[",
"]",
"for",
"start_index",
"in",
"range",
"(",
"len",
"(",
"sentence",
")",
")",
":",
"last_end_index",
"=",
"min",
"(",
"start_index",
"+",
"max_span_width",
",",
"len",
"(",
"sentence",
")",
")",
"first_end_index",
"=",
"min",
"(",
"start_index",
"+",
"min_span_width",
"-",
"1",
",",
"len",
"(",
"sentence",
")",
")",
"for",
"end_index",
"in",
"range",
"(",
"first_end_index",
",",
"last_end_index",
")",
":",
"start",
"=",
"offset",
"+",
"start_index",
"end",
"=",
"offset",
"+",
"end_index",
"# add 1 to end index because span indices are inclusive.",
"if",
"filter_function",
"(",
"sentence",
"[",
"slice",
"(",
"start_index",
",",
"end_index",
"+",
"1",
")",
"]",
")",
":",
"spans",
".",
"append",
"(",
"(",
"start",
",",
"end",
")",
")",
"return",
"spans"
] |
Given a sentence, return all token spans within the sentence. Spans are `inclusive`.
Additionally, you can provide a maximum and minimum span width, which will be used
to exclude spans outside of this range.
Finally, you can provide a function mapping ``List[T] -> bool``, which will
be applied to every span to decide whether that span should be included. This
allows filtering by length, regex matches, pos tags or any Spacy ``Token``
attributes, for example.
Parameters
----------
sentence : ``List[T]``, required.
The sentence to generate spans for. The type is generic, as this function
can be used with strings, or Spacy ``Tokens`` or other sequences.
offset : ``int``, optional (default = 0)
A numeric offset to add to all span start and end indices. This is helpful
if the sentence is part of a larger structure, such as a document, which
the indices need to respect.
max_span_width : ``int``, optional (default = None)
The maximum length of spans which should be included. Defaults to len(sentence).
min_span_width : ``int``, optional (default = 1)
The minimum length of spans which should be included. Defaults to 1.
filter_function : ``Callable[[List[T]], bool]``, optional (default = None)
A function mapping sequences of the passed type T to a boolean value.
If ``True``, the span is included in the returned spans from the
sentence, otherwise it is excluded..
|
[
"Given",
"a",
"sentence",
"return",
"all",
"token",
"spans",
"within",
"the",
"sentence",
".",
"Spans",
"are",
"inclusive",
".",
"Additionally",
"you",
"can",
"provide",
"a",
"maximum",
"and",
"minimum",
"span",
"width",
"which",
"will",
"be",
"used",
"to",
"exclude",
"spans",
"outside",
"of",
"this",
"range",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/data/dataset_readers/dataset_utils/span_utils.py#L20-L66
|
train
|
allenai/allennlp
|
allennlp/data/dataset_readers/dataset_utils/span_utils.py
|
bio_tags_to_spans
|
def bio_tags_to_spans(tag_sequence: List[str],
classes_to_ignore: List[str] = None) -> List[TypedStringSpan]:
"""
Given a sequence corresponding to BIO tags, extracts spans.
Spans are inclusive and can be of zero length, representing a single word span.
Ill-formed spans are also included (i.e those which do not start with a "B-LABEL"),
as otherwise it is possible to get a perfect precision score whilst still predicting
ill-formed spans in addition to the correct spans. This function works properly when
the spans are unlabeled (i.e., your labels are simply "B", "I", and "O").
Parameters
----------
tag_sequence : List[str], required.
The integer class labels for a sequence.
classes_to_ignore : List[str], optional (default = None).
A list of string class labels `excluding` the bio tag
which should be ignored when extracting spans.
Returns
-------
spans : List[TypedStringSpan]
The typed, extracted spans from the sequence, in the format (label, (span_start, span_end)).
Note that the label `does not` contain any BIO tag prefixes.
"""
classes_to_ignore = classes_to_ignore or []
spans: Set[Tuple[str, Tuple[int, int]]] = set()
span_start = 0
span_end = 0
active_conll_tag = None
for index, string_tag in enumerate(tag_sequence):
# Actual BIO tag.
bio_tag = string_tag[0]
if bio_tag not in ["B", "I", "O"]:
raise InvalidTagSequence(tag_sequence)
conll_tag = string_tag[2:]
if bio_tag == "O" or conll_tag in classes_to_ignore:
# The span has ended.
if active_conll_tag is not None:
spans.add((active_conll_tag, (span_start, span_end)))
active_conll_tag = None
# We don't care about tags we are
# told to ignore, so we do nothing.
continue
elif bio_tag == "B":
# We are entering a new span; reset indices
# and active tag to new span.
if active_conll_tag is not None:
spans.add((active_conll_tag, (span_start, span_end)))
active_conll_tag = conll_tag
span_start = index
span_end = index
elif bio_tag == "I" and conll_tag == active_conll_tag:
# We're inside a span.
span_end += 1
else:
# This is the case the bio label is an "I", but either:
# 1) the span hasn't started - i.e. an ill formed span.
# 2) The span is an I tag for a different conll annotation.
# We'll process the previous span if it exists, but also
# include this span. This is important, because otherwise,
# a model may get a perfect F1 score whilst still including
# false positive ill-formed spans.
if active_conll_tag is not None:
spans.add((active_conll_tag, (span_start, span_end)))
active_conll_tag = conll_tag
span_start = index
span_end = index
# Last token might have been a part of a valid span.
if active_conll_tag is not None:
spans.add((active_conll_tag, (span_start, span_end)))
return list(spans)
|
python
|
def bio_tags_to_spans(tag_sequence: List[str],
classes_to_ignore: List[str] = None) -> List[TypedStringSpan]:
"""
Given a sequence corresponding to BIO tags, extracts spans.
Spans are inclusive and can be of zero length, representing a single word span.
Ill-formed spans are also included (i.e those which do not start with a "B-LABEL"),
as otherwise it is possible to get a perfect precision score whilst still predicting
ill-formed spans in addition to the correct spans. This function works properly when
the spans are unlabeled (i.e., your labels are simply "B", "I", and "O").
Parameters
----------
tag_sequence : List[str], required.
The integer class labels for a sequence.
classes_to_ignore : List[str], optional (default = None).
A list of string class labels `excluding` the bio tag
which should be ignored when extracting spans.
Returns
-------
spans : List[TypedStringSpan]
The typed, extracted spans from the sequence, in the format (label, (span_start, span_end)).
Note that the label `does not` contain any BIO tag prefixes.
"""
classes_to_ignore = classes_to_ignore or []
spans: Set[Tuple[str, Tuple[int, int]]] = set()
span_start = 0
span_end = 0
active_conll_tag = None
for index, string_tag in enumerate(tag_sequence):
# Actual BIO tag.
bio_tag = string_tag[0]
if bio_tag not in ["B", "I", "O"]:
raise InvalidTagSequence(tag_sequence)
conll_tag = string_tag[2:]
if bio_tag == "O" or conll_tag in classes_to_ignore:
# The span has ended.
if active_conll_tag is not None:
spans.add((active_conll_tag, (span_start, span_end)))
active_conll_tag = None
# We don't care about tags we are
# told to ignore, so we do nothing.
continue
elif bio_tag == "B":
# We are entering a new span; reset indices
# and active tag to new span.
if active_conll_tag is not None:
spans.add((active_conll_tag, (span_start, span_end)))
active_conll_tag = conll_tag
span_start = index
span_end = index
elif bio_tag == "I" and conll_tag == active_conll_tag:
# We're inside a span.
span_end += 1
else:
# This is the case the bio label is an "I", but either:
# 1) the span hasn't started - i.e. an ill formed span.
# 2) The span is an I tag for a different conll annotation.
# We'll process the previous span if it exists, but also
# include this span. This is important, because otherwise,
# a model may get a perfect F1 score whilst still including
# false positive ill-formed spans.
if active_conll_tag is not None:
spans.add((active_conll_tag, (span_start, span_end)))
active_conll_tag = conll_tag
span_start = index
span_end = index
# Last token might have been a part of a valid span.
if active_conll_tag is not None:
spans.add((active_conll_tag, (span_start, span_end)))
return list(spans)
|
[
"def",
"bio_tags_to_spans",
"(",
"tag_sequence",
":",
"List",
"[",
"str",
"]",
",",
"classes_to_ignore",
":",
"List",
"[",
"str",
"]",
"=",
"None",
")",
"->",
"List",
"[",
"TypedStringSpan",
"]",
":",
"classes_to_ignore",
"=",
"classes_to_ignore",
"or",
"[",
"]",
"spans",
":",
"Set",
"[",
"Tuple",
"[",
"str",
",",
"Tuple",
"[",
"int",
",",
"int",
"]",
"]",
"]",
"=",
"set",
"(",
")",
"span_start",
"=",
"0",
"span_end",
"=",
"0",
"active_conll_tag",
"=",
"None",
"for",
"index",
",",
"string_tag",
"in",
"enumerate",
"(",
"tag_sequence",
")",
":",
"# Actual BIO tag.",
"bio_tag",
"=",
"string_tag",
"[",
"0",
"]",
"if",
"bio_tag",
"not",
"in",
"[",
"\"B\"",
",",
"\"I\"",
",",
"\"O\"",
"]",
":",
"raise",
"InvalidTagSequence",
"(",
"tag_sequence",
")",
"conll_tag",
"=",
"string_tag",
"[",
"2",
":",
"]",
"if",
"bio_tag",
"==",
"\"O\"",
"or",
"conll_tag",
"in",
"classes_to_ignore",
":",
"# The span has ended.",
"if",
"active_conll_tag",
"is",
"not",
"None",
":",
"spans",
".",
"add",
"(",
"(",
"active_conll_tag",
",",
"(",
"span_start",
",",
"span_end",
")",
")",
")",
"active_conll_tag",
"=",
"None",
"# We don't care about tags we are",
"# told to ignore, so we do nothing.",
"continue",
"elif",
"bio_tag",
"==",
"\"B\"",
":",
"# We are entering a new span; reset indices",
"# and active tag to new span.",
"if",
"active_conll_tag",
"is",
"not",
"None",
":",
"spans",
".",
"add",
"(",
"(",
"active_conll_tag",
",",
"(",
"span_start",
",",
"span_end",
")",
")",
")",
"active_conll_tag",
"=",
"conll_tag",
"span_start",
"=",
"index",
"span_end",
"=",
"index",
"elif",
"bio_tag",
"==",
"\"I\"",
"and",
"conll_tag",
"==",
"active_conll_tag",
":",
"# We're inside a span.",
"span_end",
"+=",
"1",
"else",
":",
"# This is the case the bio label is an \"I\", but either:",
"# 1) the span hasn't started - i.e. an ill formed span.",
"# 2) The span is an I tag for a different conll annotation.",
"# We'll process the previous span if it exists, but also",
"# include this span. This is important, because otherwise,",
"# a model may get a perfect F1 score whilst still including",
"# false positive ill-formed spans.",
"if",
"active_conll_tag",
"is",
"not",
"None",
":",
"spans",
".",
"add",
"(",
"(",
"active_conll_tag",
",",
"(",
"span_start",
",",
"span_end",
")",
")",
")",
"active_conll_tag",
"=",
"conll_tag",
"span_start",
"=",
"index",
"span_end",
"=",
"index",
"# Last token might have been a part of a valid span.",
"if",
"active_conll_tag",
"is",
"not",
"None",
":",
"spans",
".",
"add",
"(",
"(",
"active_conll_tag",
",",
"(",
"span_start",
",",
"span_end",
")",
")",
")",
"return",
"list",
"(",
"spans",
")"
] |
Given a sequence corresponding to BIO tags, extracts spans.
Spans are inclusive and can be of zero length, representing a single word span.
Ill-formed spans are also included (i.e those which do not start with a "B-LABEL"),
as otherwise it is possible to get a perfect precision score whilst still predicting
ill-formed spans in addition to the correct spans. This function works properly when
the spans are unlabeled (i.e., your labels are simply "B", "I", and "O").
Parameters
----------
tag_sequence : List[str], required.
The integer class labels for a sequence.
classes_to_ignore : List[str], optional (default = None).
A list of string class labels `excluding` the bio tag
which should be ignored when extracting spans.
Returns
-------
spans : List[TypedStringSpan]
The typed, extracted spans from the sequence, in the format (label, (span_start, span_end)).
Note that the label `does not` contain any BIO tag prefixes.
|
[
"Given",
"a",
"sequence",
"corresponding",
"to",
"BIO",
"tags",
"extracts",
"spans",
".",
"Spans",
"are",
"inclusive",
"and",
"can",
"be",
"of",
"zero",
"length",
"representing",
"a",
"single",
"word",
"span",
".",
"Ill",
"-",
"formed",
"spans",
"are",
"also",
"included",
"(",
"i",
".",
"e",
"those",
"which",
"do",
"not",
"start",
"with",
"a",
"B",
"-",
"LABEL",
")",
"as",
"otherwise",
"it",
"is",
"possible",
"to",
"get",
"a",
"perfect",
"precision",
"score",
"whilst",
"still",
"predicting",
"ill",
"-",
"formed",
"spans",
"in",
"addition",
"to",
"the",
"correct",
"spans",
".",
"This",
"function",
"works",
"properly",
"when",
"the",
"spans",
"are",
"unlabeled",
"(",
"i",
".",
"e",
".",
"your",
"labels",
"are",
"simply",
"B",
"I",
"and",
"O",
")",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/data/dataset_readers/dataset_utils/span_utils.py#L69-L139
|
train
|
allenai/allennlp
|
allennlp/data/dataset_readers/dataset_utils/span_utils.py
|
iob1_tags_to_spans
|
def iob1_tags_to_spans(tag_sequence: List[str],
classes_to_ignore: List[str] = None) -> List[TypedStringSpan]:
"""
Given a sequence corresponding to IOB1 tags, extracts spans.
Spans are inclusive and can be of zero length, representing a single word span.
Ill-formed spans are also included (i.e., those where "B-LABEL" is not preceded
by "I-LABEL" or "B-LABEL").
Parameters
----------
tag_sequence : List[str], required.
The integer class labels for a sequence.
classes_to_ignore : List[str], optional (default = None).
A list of string class labels `excluding` the bio tag
which should be ignored when extracting spans.
Returns
-------
spans : List[TypedStringSpan]
The typed, extracted spans from the sequence, in the format (label, (span_start, span_end)).
Note that the label `does not` contain any BIO tag prefixes.
"""
classes_to_ignore = classes_to_ignore or []
spans: Set[Tuple[str, Tuple[int, int]]] = set()
span_start = 0
span_end = 0
active_conll_tag = None
prev_bio_tag = None
prev_conll_tag = None
for index, string_tag in enumerate(tag_sequence):
curr_bio_tag = string_tag[0]
curr_conll_tag = string_tag[2:]
if curr_bio_tag not in ["B", "I", "O"]:
raise InvalidTagSequence(tag_sequence)
if curr_bio_tag == "O" or curr_conll_tag in classes_to_ignore:
# The span has ended.
if active_conll_tag is not None:
spans.add((active_conll_tag, (span_start, span_end)))
active_conll_tag = None
elif _iob1_start_of_chunk(prev_bio_tag, prev_conll_tag,
curr_bio_tag, curr_conll_tag):
# We are entering a new span; reset indices
# and active tag to new span.
if active_conll_tag is not None:
spans.add((active_conll_tag, (span_start, span_end)))
active_conll_tag = curr_conll_tag
span_start = index
span_end = index
else:
# bio_tag == "I" and curr_conll_tag == active_conll_tag
# We're continuing a span.
span_end += 1
prev_bio_tag = string_tag[0]
prev_conll_tag = string_tag[2:]
# Last token might have been a part of a valid span.
if active_conll_tag is not None:
spans.add((active_conll_tag, (span_start, span_end)))
return list(spans)
|
python
|
def iob1_tags_to_spans(tag_sequence: List[str],
classes_to_ignore: List[str] = None) -> List[TypedStringSpan]:
"""
Given a sequence corresponding to IOB1 tags, extracts spans.
Spans are inclusive and can be of zero length, representing a single word span.
Ill-formed spans are also included (i.e., those where "B-LABEL" is not preceded
by "I-LABEL" or "B-LABEL").
Parameters
----------
tag_sequence : List[str], required.
The integer class labels for a sequence.
classes_to_ignore : List[str], optional (default = None).
A list of string class labels `excluding` the bio tag
which should be ignored when extracting spans.
Returns
-------
spans : List[TypedStringSpan]
The typed, extracted spans from the sequence, in the format (label, (span_start, span_end)).
Note that the label `does not` contain any BIO tag prefixes.
"""
classes_to_ignore = classes_to_ignore or []
spans: Set[Tuple[str, Tuple[int, int]]] = set()
span_start = 0
span_end = 0
active_conll_tag = None
prev_bio_tag = None
prev_conll_tag = None
for index, string_tag in enumerate(tag_sequence):
curr_bio_tag = string_tag[0]
curr_conll_tag = string_tag[2:]
if curr_bio_tag not in ["B", "I", "O"]:
raise InvalidTagSequence(tag_sequence)
if curr_bio_tag == "O" or curr_conll_tag in classes_to_ignore:
# The span has ended.
if active_conll_tag is not None:
spans.add((active_conll_tag, (span_start, span_end)))
active_conll_tag = None
elif _iob1_start_of_chunk(prev_bio_tag, prev_conll_tag,
curr_bio_tag, curr_conll_tag):
# We are entering a new span; reset indices
# and active tag to new span.
if active_conll_tag is not None:
spans.add((active_conll_tag, (span_start, span_end)))
active_conll_tag = curr_conll_tag
span_start = index
span_end = index
else:
# bio_tag == "I" and curr_conll_tag == active_conll_tag
# We're continuing a span.
span_end += 1
prev_bio_tag = string_tag[0]
prev_conll_tag = string_tag[2:]
# Last token might have been a part of a valid span.
if active_conll_tag is not None:
spans.add((active_conll_tag, (span_start, span_end)))
return list(spans)
|
[
"def",
"iob1_tags_to_spans",
"(",
"tag_sequence",
":",
"List",
"[",
"str",
"]",
",",
"classes_to_ignore",
":",
"List",
"[",
"str",
"]",
"=",
"None",
")",
"->",
"List",
"[",
"TypedStringSpan",
"]",
":",
"classes_to_ignore",
"=",
"classes_to_ignore",
"or",
"[",
"]",
"spans",
":",
"Set",
"[",
"Tuple",
"[",
"str",
",",
"Tuple",
"[",
"int",
",",
"int",
"]",
"]",
"]",
"=",
"set",
"(",
")",
"span_start",
"=",
"0",
"span_end",
"=",
"0",
"active_conll_tag",
"=",
"None",
"prev_bio_tag",
"=",
"None",
"prev_conll_tag",
"=",
"None",
"for",
"index",
",",
"string_tag",
"in",
"enumerate",
"(",
"tag_sequence",
")",
":",
"curr_bio_tag",
"=",
"string_tag",
"[",
"0",
"]",
"curr_conll_tag",
"=",
"string_tag",
"[",
"2",
":",
"]",
"if",
"curr_bio_tag",
"not",
"in",
"[",
"\"B\"",
",",
"\"I\"",
",",
"\"O\"",
"]",
":",
"raise",
"InvalidTagSequence",
"(",
"tag_sequence",
")",
"if",
"curr_bio_tag",
"==",
"\"O\"",
"or",
"curr_conll_tag",
"in",
"classes_to_ignore",
":",
"# The span has ended.",
"if",
"active_conll_tag",
"is",
"not",
"None",
":",
"spans",
".",
"add",
"(",
"(",
"active_conll_tag",
",",
"(",
"span_start",
",",
"span_end",
")",
")",
")",
"active_conll_tag",
"=",
"None",
"elif",
"_iob1_start_of_chunk",
"(",
"prev_bio_tag",
",",
"prev_conll_tag",
",",
"curr_bio_tag",
",",
"curr_conll_tag",
")",
":",
"# We are entering a new span; reset indices",
"# and active tag to new span.",
"if",
"active_conll_tag",
"is",
"not",
"None",
":",
"spans",
".",
"add",
"(",
"(",
"active_conll_tag",
",",
"(",
"span_start",
",",
"span_end",
")",
")",
")",
"active_conll_tag",
"=",
"curr_conll_tag",
"span_start",
"=",
"index",
"span_end",
"=",
"index",
"else",
":",
"# bio_tag == \"I\" and curr_conll_tag == active_conll_tag",
"# We're continuing a span.",
"span_end",
"+=",
"1",
"prev_bio_tag",
"=",
"string_tag",
"[",
"0",
"]",
"prev_conll_tag",
"=",
"string_tag",
"[",
"2",
":",
"]",
"# Last token might have been a part of a valid span.",
"if",
"active_conll_tag",
"is",
"not",
"None",
":",
"spans",
".",
"add",
"(",
"(",
"active_conll_tag",
",",
"(",
"span_start",
",",
"span_end",
")",
")",
")",
"return",
"list",
"(",
"spans",
")"
] |
Given a sequence corresponding to IOB1 tags, extracts spans.
Spans are inclusive and can be of zero length, representing a single word span.
Ill-formed spans are also included (i.e., those where "B-LABEL" is not preceded
by "I-LABEL" or "B-LABEL").
Parameters
----------
tag_sequence : List[str], required.
The integer class labels for a sequence.
classes_to_ignore : List[str], optional (default = None).
A list of string class labels `excluding` the bio tag
which should be ignored when extracting spans.
Returns
-------
spans : List[TypedStringSpan]
The typed, extracted spans from the sequence, in the format (label, (span_start, span_end)).
Note that the label `does not` contain any BIO tag prefixes.
|
[
"Given",
"a",
"sequence",
"corresponding",
"to",
"IOB1",
"tags",
"extracts",
"spans",
".",
"Spans",
"are",
"inclusive",
"and",
"can",
"be",
"of",
"zero",
"length",
"representing",
"a",
"single",
"word",
"span",
".",
"Ill",
"-",
"formed",
"spans",
"are",
"also",
"included",
"(",
"i",
".",
"e",
".",
"those",
"where",
"B",
"-",
"LABEL",
"is",
"not",
"preceded",
"by",
"I",
"-",
"LABEL",
"or",
"B",
"-",
"LABEL",
")",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/data/dataset_readers/dataset_utils/span_utils.py#L142-L201
|
train
|
allenai/allennlp
|
allennlp/data/dataset_readers/dataset_utils/span_utils.py
|
bioul_tags_to_spans
|
def bioul_tags_to_spans(tag_sequence: List[str],
classes_to_ignore: List[str] = None) -> List[TypedStringSpan]:
"""
Given a sequence corresponding to BIOUL tags, extracts spans.
Spans are inclusive and can be of zero length, representing a single word span.
Ill-formed spans are not allowed and will raise ``InvalidTagSequence``.
This function works properly when the spans are unlabeled (i.e., your labels are
simply "B", "I", "O", "U", and "L").
Parameters
----------
tag_sequence : ``List[str]``, required.
The tag sequence encoded in BIOUL, e.g. ["B-PER", "L-PER", "O"].
classes_to_ignore : ``List[str]``, optional (default = None).
A list of string class labels `excluding` the bio tag
which should be ignored when extracting spans.
Returns
-------
spans : ``List[TypedStringSpan]``
The typed, extracted spans from the sequence, in the format (label, (span_start, span_end)).
"""
spans = []
classes_to_ignore = classes_to_ignore or []
index = 0
while index < len(tag_sequence):
label = tag_sequence[index]
if label[0] == 'U':
spans.append((label.partition('-')[2], (index, index)))
elif label[0] == 'B':
start = index
while label[0] != 'L':
index += 1
if index >= len(tag_sequence):
raise InvalidTagSequence(tag_sequence)
label = tag_sequence[index]
if not (label[0] == 'I' or label[0] == 'L'):
raise InvalidTagSequence(tag_sequence)
spans.append((label.partition('-')[2], (start, index)))
else:
if label != 'O':
raise InvalidTagSequence(tag_sequence)
index += 1
return [span for span in spans if span[0] not in classes_to_ignore]
|
python
|
def bioul_tags_to_spans(tag_sequence: List[str],
classes_to_ignore: List[str] = None) -> List[TypedStringSpan]:
"""
Given a sequence corresponding to BIOUL tags, extracts spans.
Spans are inclusive and can be of zero length, representing a single word span.
Ill-formed spans are not allowed and will raise ``InvalidTagSequence``.
This function works properly when the spans are unlabeled (i.e., your labels are
simply "B", "I", "O", "U", and "L").
Parameters
----------
tag_sequence : ``List[str]``, required.
The tag sequence encoded in BIOUL, e.g. ["B-PER", "L-PER", "O"].
classes_to_ignore : ``List[str]``, optional (default = None).
A list of string class labels `excluding` the bio tag
which should be ignored when extracting spans.
Returns
-------
spans : ``List[TypedStringSpan]``
The typed, extracted spans from the sequence, in the format (label, (span_start, span_end)).
"""
spans = []
classes_to_ignore = classes_to_ignore or []
index = 0
while index < len(tag_sequence):
label = tag_sequence[index]
if label[0] == 'U':
spans.append((label.partition('-')[2], (index, index)))
elif label[0] == 'B':
start = index
while label[0] != 'L':
index += 1
if index >= len(tag_sequence):
raise InvalidTagSequence(tag_sequence)
label = tag_sequence[index]
if not (label[0] == 'I' or label[0] == 'L'):
raise InvalidTagSequence(tag_sequence)
spans.append((label.partition('-')[2], (start, index)))
else:
if label != 'O':
raise InvalidTagSequence(tag_sequence)
index += 1
return [span for span in spans if span[0] not in classes_to_ignore]
|
[
"def",
"bioul_tags_to_spans",
"(",
"tag_sequence",
":",
"List",
"[",
"str",
"]",
",",
"classes_to_ignore",
":",
"List",
"[",
"str",
"]",
"=",
"None",
")",
"->",
"List",
"[",
"TypedStringSpan",
"]",
":",
"spans",
"=",
"[",
"]",
"classes_to_ignore",
"=",
"classes_to_ignore",
"or",
"[",
"]",
"index",
"=",
"0",
"while",
"index",
"<",
"len",
"(",
"tag_sequence",
")",
":",
"label",
"=",
"tag_sequence",
"[",
"index",
"]",
"if",
"label",
"[",
"0",
"]",
"==",
"'U'",
":",
"spans",
".",
"append",
"(",
"(",
"label",
".",
"partition",
"(",
"'-'",
")",
"[",
"2",
"]",
",",
"(",
"index",
",",
"index",
")",
")",
")",
"elif",
"label",
"[",
"0",
"]",
"==",
"'B'",
":",
"start",
"=",
"index",
"while",
"label",
"[",
"0",
"]",
"!=",
"'L'",
":",
"index",
"+=",
"1",
"if",
"index",
">=",
"len",
"(",
"tag_sequence",
")",
":",
"raise",
"InvalidTagSequence",
"(",
"tag_sequence",
")",
"label",
"=",
"tag_sequence",
"[",
"index",
"]",
"if",
"not",
"(",
"label",
"[",
"0",
"]",
"==",
"'I'",
"or",
"label",
"[",
"0",
"]",
"==",
"'L'",
")",
":",
"raise",
"InvalidTagSequence",
"(",
"tag_sequence",
")",
"spans",
".",
"append",
"(",
"(",
"label",
".",
"partition",
"(",
"'-'",
")",
"[",
"2",
"]",
",",
"(",
"start",
",",
"index",
")",
")",
")",
"else",
":",
"if",
"label",
"!=",
"'O'",
":",
"raise",
"InvalidTagSequence",
"(",
"tag_sequence",
")",
"index",
"+=",
"1",
"return",
"[",
"span",
"for",
"span",
"in",
"spans",
"if",
"span",
"[",
"0",
"]",
"not",
"in",
"classes_to_ignore",
"]"
] |
Given a sequence corresponding to BIOUL tags, extracts spans.
Spans are inclusive and can be of zero length, representing a single word span.
Ill-formed spans are not allowed and will raise ``InvalidTagSequence``.
This function works properly when the spans are unlabeled (i.e., your labels are
simply "B", "I", "O", "U", and "L").
Parameters
----------
tag_sequence : ``List[str]``, required.
The tag sequence encoded in BIOUL, e.g. ["B-PER", "L-PER", "O"].
classes_to_ignore : ``List[str]``, optional (default = None).
A list of string class labels `excluding` the bio tag
which should be ignored when extracting spans.
Returns
-------
spans : ``List[TypedStringSpan]``
The typed, extracted spans from the sequence, in the format (label, (span_start, span_end)).
|
[
"Given",
"a",
"sequence",
"corresponding",
"to",
"BIOUL",
"tags",
"extracts",
"spans",
".",
"Spans",
"are",
"inclusive",
"and",
"can",
"be",
"of",
"zero",
"length",
"representing",
"a",
"single",
"word",
"span",
".",
"Ill",
"-",
"formed",
"spans",
"are",
"not",
"allowed",
"and",
"will",
"raise",
"InvalidTagSequence",
".",
"This",
"function",
"works",
"properly",
"when",
"the",
"spans",
"are",
"unlabeled",
"(",
"i",
".",
"e",
".",
"your",
"labels",
"are",
"simply",
"B",
"I",
"O",
"U",
"and",
"L",
")",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/data/dataset_readers/dataset_utils/span_utils.py#L217-L260
|
train
|
allenai/allennlp
|
allennlp/data/dataset_readers/dataset_utils/span_utils.py
|
to_bioul
|
def to_bioul(tag_sequence: List[str], encoding: str = "IOB1") -> List[str]:
"""
Given a tag sequence encoded with IOB1 labels, recode to BIOUL.
In the IOB1 scheme, I is a token inside a span, O is a token outside
a span and B is the beginning of span immediately following another
span of the same type.
In the BIO scheme, I is a token inside a span, O is a token outside
a span and B is the beginning of a span.
Parameters
----------
tag_sequence : ``List[str]``, required.
The tag sequence encoded in IOB1, e.g. ["I-PER", "I-PER", "O"].
encoding : `str`, optional, (default = ``IOB1``).
The encoding type to convert from. Must be either "IOB1" or "BIO".
Returns
-------
bioul_sequence: ``List[str]``
The tag sequence encoded in IOB1, e.g. ["B-PER", "L-PER", "O"].
"""
if not encoding in {"IOB1", "BIO"}:
raise ConfigurationError(f"Invalid encoding {encoding} passed to 'to_bioul'.")
# pylint: disable=len-as-condition
def replace_label(full_label, new_label):
# example: full_label = 'I-PER', new_label = 'U', returns 'U-PER'
parts = list(full_label.partition('-'))
parts[0] = new_label
return ''.join(parts)
def pop_replace_append(in_stack, out_stack, new_label):
# pop the last element from in_stack, replace the label, append
# to out_stack
tag = in_stack.pop()
new_tag = replace_label(tag, new_label)
out_stack.append(new_tag)
def process_stack(stack, out_stack):
# process a stack of labels, add them to out_stack
if len(stack) == 1:
# just a U token
pop_replace_append(stack, out_stack, 'U')
else:
# need to code as BIL
recoded_stack = []
pop_replace_append(stack, recoded_stack, 'L')
while len(stack) >= 2:
pop_replace_append(stack, recoded_stack, 'I')
pop_replace_append(stack, recoded_stack, 'B')
recoded_stack.reverse()
out_stack.extend(recoded_stack)
# Process the tag_sequence one tag at a time, adding spans to a stack,
# then recode them.
bioul_sequence = []
stack: List[str] = []
for label in tag_sequence:
# need to make a dict like
# token = {'token': 'Matt', "labels": {'conll2003': "B-PER"}
# 'gold': 'I-PER'}
# where 'gold' is the raw value from the CoNLL data set
if label == 'O' and len(stack) == 0:
bioul_sequence.append(label)
elif label == 'O' and len(stack) > 0:
# need to process the entries on the stack plus this one
process_stack(stack, bioul_sequence)
bioul_sequence.append(label)
elif label[0] == 'I':
# check if the previous type is the same as this one
# if it is then append to stack
# otherwise this start a new entity if the type
# is different
if len(stack) == 0:
if encoding == "BIO":
raise InvalidTagSequence(tag_sequence)
stack.append(label)
else:
# check if the previous type is the same as this one
this_type = label.partition('-')[2]
prev_type = stack[-1].partition('-')[2]
if this_type == prev_type:
stack.append(label)
else:
if encoding == "BIO":
raise InvalidTagSequence(tag_sequence)
# a new entity
process_stack(stack, bioul_sequence)
stack.append(label)
elif label[0] == 'B':
if len(stack) > 0:
process_stack(stack, bioul_sequence)
stack.append(label)
else:
raise InvalidTagSequence(tag_sequence)
# process the stack
if len(stack) > 0:
process_stack(stack, bioul_sequence)
return bioul_sequence
|
python
|
def to_bioul(tag_sequence: List[str], encoding: str = "IOB1") -> List[str]:
"""
Given a tag sequence encoded with IOB1 labels, recode to BIOUL.
In the IOB1 scheme, I is a token inside a span, O is a token outside
a span and B is the beginning of span immediately following another
span of the same type.
In the BIO scheme, I is a token inside a span, O is a token outside
a span and B is the beginning of a span.
Parameters
----------
tag_sequence : ``List[str]``, required.
The tag sequence encoded in IOB1, e.g. ["I-PER", "I-PER", "O"].
encoding : `str`, optional, (default = ``IOB1``).
The encoding type to convert from. Must be either "IOB1" or "BIO".
Returns
-------
bioul_sequence: ``List[str]``
The tag sequence encoded in IOB1, e.g. ["B-PER", "L-PER", "O"].
"""
if not encoding in {"IOB1", "BIO"}:
raise ConfigurationError(f"Invalid encoding {encoding} passed to 'to_bioul'.")
# pylint: disable=len-as-condition
def replace_label(full_label, new_label):
# example: full_label = 'I-PER', new_label = 'U', returns 'U-PER'
parts = list(full_label.partition('-'))
parts[0] = new_label
return ''.join(parts)
def pop_replace_append(in_stack, out_stack, new_label):
# pop the last element from in_stack, replace the label, append
# to out_stack
tag = in_stack.pop()
new_tag = replace_label(tag, new_label)
out_stack.append(new_tag)
def process_stack(stack, out_stack):
# process a stack of labels, add them to out_stack
if len(stack) == 1:
# just a U token
pop_replace_append(stack, out_stack, 'U')
else:
# need to code as BIL
recoded_stack = []
pop_replace_append(stack, recoded_stack, 'L')
while len(stack) >= 2:
pop_replace_append(stack, recoded_stack, 'I')
pop_replace_append(stack, recoded_stack, 'B')
recoded_stack.reverse()
out_stack.extend(recoded_stack)
# Process the tag_sequence one tag at a time, adding spans to a stack,
# then recode them.
bioul_sequence = []
stack: List[str] = []
for label in tag_sequence:
# need to make a dict like
# token = {'token': 'Matt', "labels": {'conll2003': "B-PER"}
# 'gold': 'I-PER'}
# where 'gold' is the raw value from the CoNLL data set
if label == 'O' and len(stack) == 0:
bioul_sequence.append(label)
elif label == 'O' and len(stack) > 0:
# need to process the entries on the stack plus this one
process_stack(stack, bioul_sequence)
bioul_sequence.append(label)
elif label[0] == 'I':
# check if the previous type is the same as this one
# if it is then append to stack
# otherwise this start a new entity if the type
# is different
if len(stack) == 0:
if encoding == "BIO":
raise InvalidTagSequence(tag_sequence)
stack.append(label)
else:
# check if the previous type is the same as this one
this_type = label.partition('-')[2]
prev_type = stack[-1].partition('-')[2]
if this_type == prev_type:
stack.append(label)
else:
if encoding == "BIO":
raise InvalidTagSequence(tag_sequence)
# a new entity
process_stack(stack, bioul_sequence)
stack.append(label)
elif label[0] == 'B':
if len(stack) > 0:
process_stack(stack, bioul_sequence)
stack.append(label)
else:
raise InvalidTagSequence(tag_sequence)
# process the stack
if len(stack) > 0:
process_stack(stack, bioul_sequence)
return bioul_sequence
|
[
"def",
"to_bioul",
"(",
"tag_sequence",
":",
"List",
"[",
"str",
"]",
",",
"encoding",
":",
"str",
"=",
"\"IOB1\"",
")",
"->",
"List",
"[",
"str",
"]",
":",
"if",
"not",
"encoding",
"in",
"{",
"\"IOB1\"",
",",
"\"BIO\"",
"}",
":",
"raise",
"ConfigurationError",
"(",
"f\"Invalid encoding {encoding} passed to 'to_bioul'.\"",
")",
"# pylint: disable=len-as-condition",
"def",
"replace_label",
"(",
"full_label",
",",
"new_label",
")",
":",
"# example: full_label = 'I-PER', new_label = 'U', returns 'U-PER'",
"parts",
"=",
"list",
"(",
"full_label",
".",
"partition",
"(",
"'-'",
")",
")",
"parts",
"[",
"0",
"]",
"=",
"new_label",
"return",
"''",
".",
"join",
"(",
"parts",
")",
"def",
"pop_replace_append",
"(",
"in_stack",
",",
"out_stack",
",",
"new_label",
")",
":",
"# pop the last element from in_stack, replace the label, append",
"# to out_stack",
"tag",
"=",
"in_stack",
".",
"pop",
"(",
")",
"new_tag",
"=",
"replace_label",
"(",
"tag",
",",
"new_label",
")",
"out_stack",
".",
"append",
"(",
"new_tag",
")",
"def",
"process_stack",
"(",
"stack",
",",
"out_stack",
")",
":",
"# process a stack of labels, add them to out_stack",
"if",
"len",
"(",
"stack",
")",
"==",
"1",
":",
"# just a U token",
"pop_replace_append",
"(",
"stack",
",",
"out_stack",
",",
"'U'",
")",
"else",
":",
"# need to code as BIL",
"recoded_stack",
"=",
"[",
"]",
"pop_replace_append",
"(",
"stack",
",",
"recoded_stack",
",",
"'L'",
")",
"while",
"len",
"(",
"stack",
")",
">=",
"2",
":",
"pop_replace_append",
"(",
"stack",
",",
"recoded_stack",
",",
"'I'",
")",
"pop_replace_append",
"(",
"stack",
",",
"recoded_stack",
",",
"'B'",
")",
"recoded_stack",
".",
"reverse",
"(",
")",
"out_stack",
".",
"extend",
"(",
"recoded_stack",
")",
"# Process the tag_sequence one tag at a time, adding spans to a stack,",
"# then recode them.",
"bioul_sequence",
"=",
"[",
"]",
"stack",
":",
"List",
"[",
"str",
"]",
"=",
"[",
"]",
"for",
"label",
"in",
"tag_sequence",
":",
"# need to make a dict like",
"# token = {'token': 'Matt', \"labels\": {'conll2003': \"B-PER\"}",
"# 'gold': 'I-PER'}",
"# where 'gold' is the raw value from the CoNLL data set",
"if",
"label",
"==",
"'O'",
"and",
"len",
"(",
"stack",
")",
"==",
"0",
":",
"bioul_sequence",
".",
"append",
"(",
"label",
")",
"elif",
"label",
"==",
"'O'",
"and",
"len",
"(",
"stack",
")",
">",
"0",
":",
"# need to process the entries on the stack plus this one",
"process_stack",
"(",
"stack",
",",
"bioul_sequence",
")",
"bioul_sequence",
".",
"append",
"(",
"label",
")",
"elif",
"label",
"[",
"0",
"]",
"==",
"'I'",
":",
"# check if the previous type is the same as this one",
"# if it is then append to stack",
"# otherwise this start a new entity if the type",
"# is different",
"if",
"len",
"(",
"stack",
")",
"==",
"0",
":",
"if",
"encoding",
"==",
"\"BIO\"",
":",
"raise",
"InvalidTagSequence",
"(",
"tag_sequence",
")",
"stack",
".",
"append",
"(",
"label",
")",
"else",
":",
"# check if the previous type is the same as this one",
"this_type",
"=",
"label",
".",
"partition",
"(",
"'-'",
")",
"[",
"2",
"]",
"prev_type",
"=",
"stack",
"[",
"-",
"1",
"]",
".",
"partition",
"(",
"'-'",
")",
"[",
"2",
"]",
"if",
"this_type",
"==",
"prev_type",
":",
"stack",
".",
"append",
"(",
"label",
")",
"else",
":",
"if",
"encoding",
"==",
"\"BIO\"",
":",
"raise",
"InvalidTagSequence",
"(",
"tag_sequence",
")",
"# a new entity",
"process_stack",
"(",
"stack",
",",
"bioul_sequence",
")",
"stack",
".",
"append",
"(",
"label",
")",
"elif",
"label",
"[",
"0",
"]",
"==",
"'B'",
":",
"if",
"len",
"(",
"stack",
")",
">",
"0",
":",
"process_stack",
"(",
"stack",
",",
"bioul_sequence",
")",
"stack",
".",
"append",
"(",
"label",
")",
"else",
":",
"raise",
"InvalidTagSequence",
"(",
"tag_sequence",
")",
"# process the stack",
"if",
"len",
"(",
"stack",
")",
">",
"0",
":",
"process_stack",
"(",
"stack",
",",
"bioul_sequence",
")",
"return",
"bioul_sequence"
] |
Given a tag sequence encoded with IOB1 labels, recode to BIOUL.
In the IOB1 scheme, I is a token inside a span, O is a token outside
a span and B is the beginning of span immediately following another
span of the same type.
In the BIO scheme, I is a token inside a span, O is a token outside
a span and B is the beginning of a span.
Parameters
----------
tag_sequence : ``List[str]``, required.
The tag sequence encoded in IOB1, e.g. ["I-PER", "I-PER", "O"].
encoding : `str`, optional, (default = ``IOB1``).
The encoding type to convert from. Must be either "IOB1" or "BIO".
Returns
-------
bioul_sequence: ``List[str]``
The tag sequence encoded in IOB1, e.g. ["B-PER", "L-PER", "O"].
|
[
"Given",
"a",
"tag",
"sequence",
"encoded",
"with",
"IOB1",
"labels",
"recode",
"to",
"BIOUL",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/data/dataset_readers/dataset_utils/span_utils.py#L267-L373
|
train
|
allenai/allennlp
|
allennlp/data/dataset_readers/dataset_utils/span_utils.py
|
bmes_tags_to_spans
|
def bmes_tags_to_spans(tag_sequence: List[str],
classes_to_ignore: List[str] = None) -> List[TypedStringSpan]:
"""
Given a sequence corresponding to BMES tags, extracts spans.
Spans are inclusive and can be of zero length, representing a single word span.
Ill-formed spans are also included (i.e those which do not start with a "B-LABEL"),
as otherwise it is possible to get a perfect precision score whilst still predicting
ill-formed spans in addition to the correct spans.
This function works properly when the spans are unlabeled (i.e., your labels are
simply "B", "M", "E" and "S").
Parameters
----------
tag_sequence : List[str], required.
The integer class labels for a sequence.
classes_to_ignore : List[str], optional (default = None).
A list of string class labels `excluding` the bio tag
which should be ignored when extracting spans.
Returns
-------
spans : List[TypedStringSpan]
The typed, extracted spans from the sequence, in the format (label, (span_start, span_end)).
Note that the label `does not` contain any BIO tag prefixes.
"""
def extract_bmes_tag_label(text):
bmes_tag = text[0]
label = text[2:]
return bmes_tag, label
spans: List[Tuple[str, List[int]]] = []
prev_bmes_tag: Optional[str] = None
for index, tag in enumerate(tag_sequence):
bmes_tag, label = extract_bmes_tag_label(tag)
if bmes_tag in ('B', 'S'):
# Regardless of tag, we start a new span when reaching B & S.
spans.append(
(label, [index, index])
)
elif bmes_tag in ('M', 'E') and prev_bmes_tag in ('B', 'M') and spans[-1][0] == label:
# Only expand the span if
# 1. Valid transition: B/M -> M/E.
# 2. Matched label.
spans[-1][1][1] = index
else:
# Best effort split for invalid span.
spans.append(
(label, [index, index])
)
# update previous BMES tag.
prev_bmes_tag = bmes_tag
classes_to_ignore = classes_to_ignore or []
return [
# to tuple.
(span[0], (span[1][0], span[1][1]))
for span in spans
if span[0] not in classes_to_ignore
]
|
python
|
def bmes_tags_to_spans(tag_sequence: List[str],
classes_to_ignore: List[str] = None) -> List[TypedStringSpan]:
"""
Given a sequence corresponding to BMES tags, extracts spans.
Spans are inclusive and can be of zero length, representing a single word span.
Ill-formed spans are also included (i.e those which do not start with a "B-LABEL"),
as otherwise it is possible to get a perfect precision score whilst still predicting
ill-formed spans in addition to the correct spans.
This function works properly when the spans are unlabeled (i.e., your labels are
simply "B", "M", "E" and "S").
Parameters
----------
tag_sequence : List[str], required.
The integer class labels for a sequence.
classes_to_ignore : List[str], optional (default = None).
A list of string class labels `excluding` the bio tag
which should be ignored when extracting spans.
Returns
-------
spans : List[TypedStringSpan]
The typed, extracted spans from the sequence, in the format (label, (span_start, span_end)).
Note that the label `does not` contain any BIO tag prefixes.
"""
def extract_bmes_tag_label(text):
bmes_tag = text[0]
label = text[2:]
return bmes_tag, label
spans: List[Tuple[str, List[int]]] = []
prev_bmes_tag: Optional[str] = None
for index, tag in enumerate(tag_sequence):
bmes_tag, label = extract_bmes_tag_label(tag)
if bmes_tag in ('B', 'S'):
# Regardless of tag, we start a new span when reaching B & S.
spans.append(
(label, [index, index])
)
elif bmes_tag in ('M', 'E') and prev_bmes_tag in ('B', 'M') and spans[-1][0] == label:
# Only expand the span if
# 1. Valid transition: B/M -> M/E.
# 2. Matched label.
spans[-1][1][1] = index
else:
# Best effort split for invalid span.
spans.append(
(label, [index, index])
)
# update previous BMES tag.
prev_bmes_tag = bmes_tag
classes_to_ignore = classes_to_ignore or []
return [
# to tuple.
(span[0], (span[1][0], span[1][1]))
for span in spans
if span[0] not in classes_to_ignore
]
|
[
"def",
"bmes_tags_to_spans",
"(",
"tag_sequence",
":",
"List",
"[",
"str",
"]",
",",
"classes_to_ignore",
":",
"List",
"[",
"str",
"]",
"=",
"None",
")",
"->",
"List",
"[",
"TypedStringSpan",
"]",
":",
"def",
"extract_bmes_tag_label",
"(",
"text",
")",
":",
"bmes_tag",
"=",
"text",
"[",
"0",
"]",
"label",
"=",
"text",
"[",
"2",
":",
"]",
"return",
"bmes_tag",
",",
"label",
"spans",
":",
"List",
"[",
"Tuple",
"[",
"str",
",",
"List",
"[",
"int",
"]",
"]",
"]",
"=",
"[",
"]",
"prev_bmes_tag",
":",
"Optional",
"[",
"str",
"]",
"=",
"None",
"for",
"index",
",",
"tag",
"in",
"enumerate",
"(",
"tag_sequence",
")",
":",
"bmes_tag",
",",
"label",
"=",
"extract_bmes_tag_label",
"(",
"tag",
")",
"if",
"bmes_tag",
"in",
"(",
"'B'",
",",
"'S'",
")",
":",
"# Regardless of tag, we start a new span when reaching B & S.",
"spans",
".",
"append",
"(",
"(",
"label",
",",
"[",
"index",
",",
"index",
"]",
")",
")",
"elif",
"bmes_tag",
"in",
"(",
"'M'",
",",
"'E'",
")",
"and",
"prev_bmes_tag",
"in",
"(",
"'B'",
",",
"'M'",
")",
"and",
"spans",
"[",
"-",
"1",
"]",
"[",
"0",
"]",
"==",
"label",
":",
"# Only expand the span if",
"# 1. Valid transition: B/M -> M/E.",
"# 2. Matched label.",
"spans",
"[",
"-",
"1",
"]",
"[",
"1",
"]",
"[",
"1",
"]",
"=",
"index",
"else",
":",
"# Best effort split for invalid span.",
"spans",
".",
"append",
"(",
"(",
"label",
",",
"[",
"index",
",",
"index",
"]",
")",
")",
"# update previous BMES tag.",
"prev_bmes_tag",
"=",
"bmes_tag",
"classes_to_ignore",
"=",
"classes_to_ignore",
"or",
"[",
"]",
"return",
"[",
"# to tuple.",
"(",
"span",
"[",
"0",
"]",
",",
"(",
"span",
"[",
"1",
"]",
"[",
"0",
"]",
",",
"span",
"[",
"1",
"]",
"[",
"1",
"]",
")",
")",
"for",
"span",
"in",
"spans",
"if",
"span",
"[",
"0",
"]",
"not",
"in",
"classes_to_ignore",
"]"
] |
Given a sequence corresponding to BMES tags, extracts spans.
Spans are inclusive and can be of zero length, representing a single word span.
Ill-formed spans are also included (i.e those which do not start with a "B-LABEL"),
as otherwise it is possible to get a perfect precision score whilst still predicting
ill-formed spans in addition to the correct spans.
This function works properly when the spans are unlabeled (i.e., your labels are
simply "B", "M", "E" and "S").
Parameters
----------
tag_sequence : List[str], required.
The integer class labels for a sequence.
classes_to_ignore : List[str], optional (default = None).
A list of string class labels `excluding` the bio tag
which should be ignored when extracting spans.
Returns
-------
spans : List[TypedStringSpan]
The typed, extracted spans from the sequence, in the format (label, (span_start, span_end)).
Note that the label `does not` contain any BIO tag prefixes.
|
[
"Given",
"a",
"sequence",
"corresponding",
"to",
"BMES",
"tags",
"extracts",
"spans",
".",
"Spans",
"are",
"inclusive",
"and",
"can",
"be",
"of",
"zero",
"length",
"representing",
"a",
"single",
"word",
"span",
".",
"Ill",
"-",
"formed",
"spans",
"are",
"also",
"included",
"(",
"i",
".",
"e",
"those",
"which",
"do",
"not",
"start",
"with",
"a",
"B",
"-",
"LABEL",
")",
"as",
"otherwise",
"it",
"is",
"possible",
"to",
"get",
"a",
"perfect",
"precision",
"score",
"whilst",
"still",
"predicting",
"ill",
"-",
"formed",
"spans",
"in",
"addition",
"to",
"the",
"correct",
"spans",
".",
"This",
"function",
"works",
"properly",
"when",
"the",
"spans",
"are",
"unlabeled",
"(",
"i",
".",
"e",
".",
"your",
"labels",
"are",
"simply",
"B",
"M",
"E",
"and",
"S",
")",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/data/dataset_readers/dataset_utils/span_utils.py#L376-L435
|
train
|
allenai/allennlp
|
allennlp/commands/dry_run.py
|
dry_run_from_args
|
def dry_run_from_args(args: argparse.Namespace):
"""
Just converts from an ``argparse.Namespace`` object to params.
"""
parameter_path = args.param_path
serialization_dir = args.serialization_dir
overrides = args.overrides
params = Params.from_file(parameter_path, overrides)
dry_run_from_params(params, serialization_dir)
|
python
|
def dry_run_from_args(args: argparse.Namespace):
"""
Just converts from an ``argparse.Namespace`` object to params.
"""
parameter_path = args.param_path
serialization_dir = args.serialization_dir
overrides = args.overrides
params = Params.from_file(parameter_path, overrides)
dry_run_from_params(params, serialization_dir)
|
[
"def",
"dry_run_from_args",
"(",
"args",
":",
"argparse",
".",
"Namespace",
")",
":",
"parameter_path",
"=",
"args",
".",
"param_path",
"serialization_dir",
"=",
"args",
".",
"serialization_dir",
"overrides",
"=",
"args",
".",
"overrides",
"params",
"=",
"Params",
".",
"from_file",
"(",
"parameter_path",
",",
"overrides",
")",
"dry_run_from_params",
"(",
"params",
",",
"serialization_dir",
")"
] |
Just converts from an ``argparse.Namespace`` object to params.
|
[
"Just",
"converts",
"from",
"an",
"argparse",
".",
"Namespace",
"object",
"to",
"params",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/commands/dry_run.py#L72-L82
|
train
|
allenai/allennlp
|
allennlp/state_machines/constrained_beam_search.py
|
ConstrainedBeamSearch.search
|
def search(self,
initial_state: State,
transition_function: TransitionFunction) -> Dict[int, List[State]]:
"""
Parameters
----------
initial_state : ``State``
The starting state of our search. This is assumed to be `batched`, and our beam search
is batch-aware - we'll keep ``beam_size`` states around for each instance in the batch.
transition_function : ``TransitionFunction``
The ``TransitionFunction`` object that defines and scores transitions from one state to the
next.
Returns
-------
best_states : ``Dict[int, List[State]]``
This is a mapping from batch index to the top states for that instance.
"""
finished_states: Dict[int, List[State]] = defaultdict(list)
states = [initial_state]
step_num = 0
while states:
step_num += 1
next_states: Dict[int, List[State]] = defaultdict(list)
grouped_state = states[0].combine_states(states)
allowed_actions = []
for batch_index, action_history in zip(grouped_state.batch_indices,
grouped_state.action_history):
allowed_actions.append(self._allowed_transitions[batch_index][tuple(action_history)])
for next_state in transition_function.take_step(grouped_state,
max_actions=self._per_node_beam_size,
allowed_actions=allowed_actions):
# NOTE: we're doing state.batch_indices[0] here (and similar things below),
# hard-coding a group size of 1. But, our use of `next_state.is_finished()`
# already checks for that, as it crashes if the group size is not 1.
batch_index = next_state.batch_indices[0]
if next_state.is_finished():
finished_states[batch_index].append(next_state)
else:
next_states[batch_index].append(next_state)
states = []
for batch_index, batch_states in next_states.items():
# The states from the generator are already sorted, so we can just take the first
# ones here, without an additional sort.
if self._beam_size:
batch_states = batch_states[:self._beam_size]
states.extend(batch_states)
best_states: Dict[int, List[State]] = {}
for batch_index, batch_states in finished_states.items():
# The time this sort takes is pretty negligible, no particular need to optimize this
# yet. Maybe with a larger beam size...
finished_to_sort = [(-state.score[0].item(), state) for state in batch_states]
finished_to_sort.sort(key=lambda x: x[0])
best_states[batch_index] = [state[1] for state in finished_to_sort[:self._beam_size]]
return best_states
|
python
|
def search(self,
initial_state: State,
transition_function: TransitionFunction) -> Dict[int, List[State]]:
"""
Parameters
----------
initial_state : ``State``
The starting state of our search. This is assumed to be `batched`, and our beam search
is batch-aware - we'll keep ``beam_size`` states around for each instance in the batch.
transition_function : ``TransitionFunction``
The ``TransitionFunction`` object that defines and scores transitions from one state to the
next.
Returns
-------
best_states : ``Dict[int, List[State]]``
This is a mapping from batch index to the top states for that instance.
"""
finished_states: Dict[int, List[State]] = defaultdict(list)
states = [initial_state]
step_num = 0
while states:
step_num += 1
next_states: Dict[int, List[State]] = defaultdict(list)
grouped_state = states[0].combine_states(states)
allowed_actions = []
for batch_index, action_history in zip(grouped_state.batch_indices,
grouped_state.action_history):
allowed_actions.append(self._allowed_transitions[batch_index][tuple(action_history)])
for next_state in transition_function.take_step(grouped_state,
max_actions=self._per_node_beam_size,
allowed_actions=allowed_actions):
# NOTE: we're doing state.batch_indices[0] here (and similar things below),
# hard-coding a group size of 1. But, our use of `next_state.is_finished()`
# already checks for that, as it crashes if the group size is not 1.
batch_index = next_state.batch_indices[0]
if next_state.is_finished():
finished_states[batch_index].append(next_state)
else:
next_states[batch_index].append(next_state)
states = []
for batch_index, batch_states in next_states.items():
# The states from the generator are already sorted, so we can just take the first
# ones here, without an additional sort.
if self._beam_size:
batch_states = batch_states[:self._beam_size]
states.extend(batch_states)
best_states: Dict[int, List[State]] = {}
for batch_index, batch_states in finished_states.items():
# The time this sort takes is pretty negligible, no particular need to optimize this
# yet. Maybe with a larger beam size...
finished_to_sort = [(-state.score[0].item(), state) for state in batch_states]
finished_to_sort.sort(key=lambda x: x[0])
best_states[batch_index] = [state[1] for state in finished_to_sort[:self._beam_size]]
return best_states
|
[
"def",
"search",
"(",
"self",
",",
"initial_state",
":",
"State",
",",
"transition_function",
":",
"TransitionFunction",
")",
"->",
"Dict",
"[",
"int",
",",
"List",
"[",
"State",
"]",
"]",
":",
"finished_states",
":",
"Dict",
"[",
"int",
",",
"List",
"[",
"State",
"]",
"]",
"=",
"defaultdict",
"(",
"list",
")",
"states",
"=",
"[",
"initial_state",
"]",
"step_num",
"=",
"0",
"while",
"states",
":",
"step_num",
"+=",
"1",
"next_states",
":",
"Dict",
"[",
"int",
",",
"List",
"[",
"State",
"]",
"]",
"=",
"defaultdict",
"(",
"list",
")",
"grouped_state",
"=",
"states",
"[",
"0",
"]",
".",
"combine_states",
"(",
"states",
")",
"allowed_actions",
"=",
"[",
"]",
"for",
"batch_index",
",",
"action_history",
"in",
"zip",
"(",
"grouped_state",
".",
"batch_indices",
",",
"grouped_state",
".",
"action_history",
")",
":",
"allowed_actions",
".",
"append",
"(",
"self",
".",
"_allowed_transitions",
"[",
"batch_index",
"]",
"[",
"tuple",
"(",
"action_history",
")",
"]",
")",
"for",
"next_state",
"in",
"transition_function",
".",
"take_step",
"(",
"grouped_state",
",",
"max_actions",
"=",
"self",
".",
"_per_node_beam_size",
",",
"allowed_actions",
"=",
"allowed_actions",
")",
":",
"# NOTE: we're doing state.batch_indices[0] here (and similar things below),",
"# hard-coding a group size of 1. But, our use of `next_state.is_finished()`",
"# already checks for that, as it crashes if the group size is not 1.",
"batch_index",
"=",
"next_state",
".",
"batch_indices",
"[",
"0",
"]",
"if",
"next_state",
".",
"is_finished",
"(",
")",
":",
"finished_states",
"[",
"batch_index",
"]",
".",
"append",
"(",
"next_state",
")",
"else",
":",
"next_states",
"[",
"batch_index",
"]",
".",
"append",
"(",
"next_state",
")",
"states",
"=",
"[",
"]",
"for",
"batch_index",
",",
"batch_states",
"in",
"next_states",
".",
"items",
"(",
")",
":",
"# The states from the generator are already sorted, so we can just take the first",
"# ones here, without an additional sort.",
"if",
"self",
".",
"_beam_size",
":",
"batch_states",
"=",
"batch_states",
"[",
":",
"self",
".",
"_beam_size",
"]",
"states",
".",
"extend",
"(",
"batch_states",
")",
"best_states",
":",
"Dict",
"[",
"int",
",",
"List",
"[",
"State",
"]",
"]",
"=",
"{",
"}",
"for",
"batch_index",
",",
"batch_states",
"in",
"finished_states",
".",
"items",
"(",
")",
":",
"# The time this sort takes is pretty negligible, no particular need to optimize this",
"# yet. Maybe with a larger beam size...",
"finished_to_sort",
"=",
"[",
"(",
"-",
"state",
".",
"score",
"[",
"0",
"]",
".",
"item",
"(",
")",
",",
"state",
")",
"for",
"state",
"in",
"batch_states",
"]",
"finished_to_sort",
".",
"sort",
"(",
"key",
"=",
"lambda",
"x",
":",
"x",
"[",
"0",
"]",
")",
"best_states",
"[",
"batch_index",
"]",
"=",
"[",
"state",
"[",
"1",
"]",
"for",
"state",
"in",
"finished_to_sort",
"[",
":",
"self",
".",
"_beam_size",
"]",
"]",
"return",
"best_states"
] |
Parameters
----------
initial_state : ``State``
The starting state of our search. This is assumed to be `batched`, and our beam search
is batch-aware - we'll keep ``beam_size`` states around for each instance in the batch.
transition_function : ``TransitionFunction``
The ``TransitionFunction`` object that defines and scores transitions from one state to the
next.
Returns
-------
best_states : ``Dict[int, List[State]]``
This is a mapping from batch index to the top states for that instance.
|
[
"Parameters",
"----------",
"initial_state",
":",
"State",
"The",
"starting",
"state",
"of",
"our",
"search",
".",
"This",
"is",
"assumed",
"to",
"be",
"batched",
"and",
"our",
"beam",
"search",
"is",
"batch",
"-",
"aware",
"-",
"we",
"ll",
"keep",
"beam_size",
"states",
"around",
"for",
"each",
"instance",
"in",
"the",
"batch",
".",
"transition_function",
":",
"TransitionFunction",
"The",
"TransitionFunction",
"object",
"that",
"defines",
"and",
"scores",
"transitions",
"from",
"one",
"state",
"to",
"the",
"next",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/state_machines/constrained_beam_search.py#L60-L114
|
train
|
allenai/allennlp
|
scripts/check_links.py
|
url_ok
|
def url_ok(match_tuple: MatchTuple) -> bool:
"""Check if a URL is reachable."""
try:
result = requests.get(match_tuple.link, timeout=5)
return result.ok
except (requests.ConnectionError, requests.Timeout):
return False
|
python
|
def url_ok(match_tuple: MatchTuple) -> bool:
"""Check if a URL is reachable."""
try:
result = requests.get(match_tuple.link, timeout=5)
return result.ok
except (requests.ConnectionError, requests.Timeout):
return False
|
[
"def",
"url_ok",
"(",
"match_tuple",
":",
"MatchTuple",
")",
"->",
"bool",
":",
"try",
":",
"result",
"=",
"requests",
".",
"get",
"(",
"match_tuple",
".",
"link",
",",
"timeout",
"=",
"5",
")",
"return",
"result",
".",
"ok",
"except",
"(",
"requests",
".",
"ConnectionError",
",",
"requests",
".",
"Timeout",
")",
":",
"return",
"False"
] |
Check if a URL is reachable.
|
[
"Check",
"if",
"a",
"URL",
"is",
"reachable",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/scripts/check_links.py#L24-L30
|
train
|
allenai/allennlp
|
scripts/check_links.py
|
path_ok
|
def path_ok(match_tuple: MatchTuple) -> bool:
"""Check if a file in this repository exists."""
relative_path = match_tuple.link.split("#")[0]
full_path = os.path.join(os.path.dirname(str(match_tuple.source)), relative_path)
return os.path.exists(full_path)
|
python
|
def path_ok(match_tuple: MatchTuple) -> bool:
"""Check if a file in this repository exists."""
relative_path = match_tuple.link.split("#")[0]
full_path = os.path.join(os.path.dirname(str(match_tuple.source)), relative_path)
return os.path.exists(full_path)
|
[
"def",
"path_ok",
"(",
"match_tuple",
":",
"MatchTuple",
")",
"->",
"bool",
":",
"relative_path",
"=",
"match_tuple",
".",
"link",
".",
"split",
"(",
"\"#\"",
")",
"[",
"0",
"]",
"full_path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"os",
".",
"path",
".",
"dirname",
"(",
"str",
"(",
"match_tuple",
".",
"source",
")",
")",
",",
"relative_path",
")",
"return",
"os",
".",
"path",
".",
"exists",
"(",
"full_path",
")"
] |
Check if a file in this repository exists.
|
[
"Check",
"if",
"a",
"file",
"in",
"this",
"repository",
"exists",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/scripts/check_links.py#L33-L37
|
train
|
allenai/allennlp
|
allennlp/common/params.py
|
infer_and_cast
|
def infer_and_cast(value: Any):
"""
In some cases we'll be feeding params dicts to functions we don't own;
for example, PyTorch optimizers. In that case we can't use ``pop_int``
or similar to force casts (which means you can't specify ``int`` parameters
using environment variables). This function takes something that looks JSON-like
and recursively casts things that look like (bool, int, float) to (bool, int, float).
"""
# pylint: disable=too-many-return-statements
if isinstance(value, (int, float, bool)):
# Already one of our desired types, so leave as is.
return value
elif isinstance(value, list):
# Recursively call on each list element.
return [infer_and_cast(item) for item in value]
elif isinstance(value, dict):
# Recursively call on each dict value.
return {key: infer_and_cast(item) for key, item in value.items()}
elif isinstance(value, str):
# If it looks like a bool, make it a bool.
if value.lower() == "true":
return True
elif value.lower() == "false":
return False
else:
# See if it could be an int.
try:
return int(value)
except ValueError:
pass
# See if it could be a float.
try:
return float(value)
except ValueError:
# Just return it as a string.
return value
else:
raise ValueError(f"cannot infer type of {value}")
|
python
|
def infer_and_cast(value: Any):
"""
In some cases we'll be feeding params dicts to functions we don't own;
for example, PyTorch optimizers. In that case we can't use ``pop_int``
or similar to force casts (which means you can't specify ``int`` parameters
using environment variables). This function takes something that looks JSON-like
and recursively casts things that look like (bool, int, float) to (bool, int, float).
"""
# pylint: disable=too-many-return-statements
if isinstance(value, (int, float, bool)):
# Already one of our desired types, so leave as is.
return value
elif isinstance(value, list):
# Recursively call on each list element.
return [infer_and_cast(item) for item in value]
elif isinstance(value, dict):
# Recursively call on each dict value.
return {key: infer_and_cast(item) for key, item in value.items()}
elif isinstance(value, str):
# If it looks like a bool, make it a bool.
if value.lower() == "true":
return True
elif value.lower() == "false":
return False
else:
# See if it could be an int.
try:
return int(value)
except ValueError:
pass
# See if it could be a float.
try:
return float(value)
except ValueError:
# Just return it as a string.
return value
else:
raise ValueError(f"cannot infer type of {value}")
|
[
"def",
"infer_and_cast",
"(",
"value",
":",
"Any",
")",
":",
"# pylint: disable=too-many-return-statements",
"if",
"isinstance",
"(",
"value",
",",
"(",
"int",
",",
"float",
",",
"bool",
")",
")",
":",
"# Already one of our desired types, so leave as is.",
"return",
"value",
"elif",
"isinstance",
"(",
"value",
",",
"list",
")",
":",
"# Recursively call on each list element.",
"return",
"[",
"infer_and_cast",
"(",
"item",
")",
"for",
"item",
"in",
"value",
"]",
"elif",
"isinstance",
"(",
"value",
",",
"dict",
")",
":",
"# Recursively call on each dict value.",
"return",
"{",
"key",
":",
"infer_and_cast",
"(",
"item",
")",
"for",
"key",
",",
"item",
"in",
"value",
".",
"items",
"(",
")",
"}",
"elif",
"isinstance",
"(",
"value",
",",
"str",
")",
":",
"# If it looks like a bool, make it a bool.",
"if",
"value",
".",
"lower",
"(",
")",
"==",
"\"true\"",
":",
"return",
"True",
"elif",
"value",
".",
"lower",
"(",
")",
"==",
"\"false\"",
":",
"return",
"False",
"else",
":",
"# See if it could be an int.",
"try",
":",
"return",
"int",
"(",
"value",
")",
"except",
"ValueError",
":",
"pass",
"# See if it could be a float.",
"try",
":",
"return",
"float",
"(",
"value",
")",
"except",
"ValueError",
":",
"# Just return it as a string.",
"return",
"value",
"else",
":",
"raise",
"ValueError",
"(",
"f\"cannot infer type of {value}\"",
")"
] |
In some cases we'll be feeding params dicts to functions we don't own;
for example, PyTorch optimizers. In that case we can't use ``pop_int``
or similar to force casts (which means you can't specify ``int`` parameters
using environment variables). This function takes something that looks JSON-like
and recursively casts things that look like (bool, int, float) to (bool, int, float).
|
[
"In",
"some",
"cases",
"we",
"ll",
"be",
"feeding",
"params",
"dicts",
"to",
"functions",
"we",
"don",
"t",
"own",
";",
"for",
"example",
"PyTorch",
"optimizers",
".",
"In",
"that",
"case",
"we",
"can",
"t",
"use",
"pop_int",
"or",
"similar",
"to",
"force",
"casts",
"(",
"which",
"means",
"you",
"can",
"t",
"specify",
"int",
"parameters",
"using",
"environment",
"variables",
")",
".",
"This",
"function",
"takes",
"something",
"that",
"looks",
"JSON",
"-",
"like",
"and",
"recursively",
"casts",
"things",
"that",
"look",
"like",
"(",
"bool",
"int",
"float",
")",
"to",
"(",
"bool",
"int",
"float",
")",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/common/params.py#L35-L72
|
train
|
allenai/allennlp
|
allennlp/common/params.py
|
_environment_variables
|
def _environment_variables() -> Dict[str, str]:
"""
Wraps `os.environ` to filter out non-encodable values.
"""
return {key: value
for key, value in os.environ.items()
if _is_encodable(value)}
|
python
|
def _environment_variables() -> Dict[str, str]:
"""
Wraps `os.environ` to filter out non-encodable values.
"""
return {key: value
for key, value in os.environ.items()
if _is_encodable(value)}
|
[
"def",
"_environment_variables",
"(",
")",
"->",
"Dict",
"[",
"str",
",",
"str",
"]",
":",
"return",
"{",
"key",
":",
"value",
"for",
"key",
",",
"value",
"in",
"os",
".",
"environ",
".",
"items",
"(",
")",
"if",
"_is_encodable",
"(",
"value",
")",
"}"
] |
Wraps `os.environ` to filter out non-encodable values.
|
[
"Wraps",
"os",
".",
"environ",
"to",
"filter",
"out",
"non",
"-",
"encodable",
"values",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/common/params.py#L85-L91
|
train
|
allenai/allennlp
|
allennlp/common/params.py
|
unflatten
|
def unflatten(flat_dict: Dict[str, Any]) -> Dict[str, Any]:
"""
Given a "flattened" dict with compound keys, e.g.
{"a.b": 0}
unflatten it:
{"a": {"b": 0}}
"""
unflat: Dict[str, Any] = {}
for compound_key, value in flat_dict.items():
curr_dict = unflat
parts = compound_key.split(".")
for key in parts[:-1]:
curr_value = curr_dict.get(key)
if key not in curr_dict:
curr_dict[key] = {}
curr_dict = curr_dict[key]
elif isinstance(curr_value, dict):
curr_dict = curr_value
else:
raise ConfigurationError("flattened dictionary is invalid")
if not isinstance(curr_dict, dict) or parts[-1] in curr_dict:
raise ConfigurationError("flattened dictionary is invalid")
else:
curr_dict[parts[-1]] = value
return unflat
|
python
|
def unflatten(flat_dict: Dict[str, Any]) -> Dict[str, Any]:
"""
Given a "flattened" dict with compound keys, e.g.
{"a.b": 0}
unflatten it:
{"a": {"b": 0}}
"""
unflat: Dict[str, Any] = {}
for compound_key, value in flat_dict.items():
curr_dict = unflat
parts = compound_key.split(".")
for key in parts[:-1]:
curr_value = curr_dict.get(key)
if key not in curr_dict:
curr_dict[key] = {}
curr_dict = curr_dict[key]
elif isinstance(curr_value, dict):
curr_dict = curr_value
else:
raise ConfigurationError("flattened dictionary is invalid")
if not isinstance(curr_dict, dict) or parts[-1] in curr_dict:
raise ConfigurationError("flattened dictionary is invalid")
else:
curr_dict[parts[-1]] = value
return unflat
|
[
"def",
"unflatten",
"(",
"flat_dict",
":",
"Dict",
"[",
"str",
",",
"Any",
"]",
")",
"->",
"Dict",
"[",
"str",
",",
"Any",
"]",
":",
"unflat",
":",
"Dict",
"[",
"str",
",",
"Any",
"]",
"=",
"{",
"}",
"for",
"compound_key",
",",
"value",
"in",
"flat_dict",
".",
"items",
"(",
")",
":",
"curr_dict",
"=",
"unflat",
"parts",
"=",
"compound_key",
".",
"split",
"(",
"\".\"",
")",
"for",
"key",
"in",
"parts",
"[",
":",
"-",
"1",
"]",
":",
"curr_value",
"=",
"curr_dict",
".",
"get",
"(",
"key",
")",
"if",
"key",
"not",
"in",
"curr_dict",
":",
"curr_dict",
"[",
"key",
"]",
"=",
"{",
"}",
"curr_dict",
"=",
"curr_dict",
"[",
"key",
"]",
"elif",
"isinstance",
"(",
"curr_value",
",",
"dict",
")",
":",
"curr_dict",
"=",
"curr_value",
"else",
":",
"raise",
"ConfigurationError",
"(",
"\"flattened dictionary is invalid\"",
")",
"if",
"not",
"isinstance",
"(",
"curr_dict",
",",
"dict",
")",
"or",
"parts",
"[",
"-",
"1",
"]",
"in",
"curr_dict",
":",
"raise",
"ConfigurationError",
"(",
"\"flattened dictionary is invalid\"",
")",
"else",
":",
"curr_dict",
"[",
"parts",
"[",
"-",
"1",
"]",
"]",
"=",
"value",
"return",
"unflat"
] |
Given a "flattened" dict with compound keys, e.g.
{"a.b": 0}
unflatten it:
{"a": {"b": 0}}
|
[
"Given",
"a",
"flattened",
"dict",
"with",
"compound",
"keys",
"e",
".",
"g",
".",
"{",
"a",
".",
"b",
":",
"0",
"}",
"unflatten",
"it",
":",
"{",
"a",
":",
"{",
"b",
":",
"0",
"}}"
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/common/params.py#L93-L119
|
train
|
allenai/allennlp
|
allennlp/common/params.py
|
with_fallback
|
def with_fallback(preferred: Dict[str, Any], fallback: Dict[str, Any]) -> Dict[str, Any]:
"""
Deep merge two dicts, preferring values from `preferred`.
"""
def merge(preferred_value: Any, fallback_value: Any) -> Any:
if isinstance(preferred_value, dict) and isinstance(fallback_value, dict):
return with_fallback(preferred_value, fallback_value)
elif isinstance(preferred_value, dict) and isinstance(fallback_value, list):
# treat preferred_value as a sparse list, where each key is an index to be overridden
merged_list = fallback_value
for elem_key, preferred_element in preferred_value.items():
try:
index = int(elem_key)
merged_list[index] = merge(preferred_element, fallback_value[index])
except ValueError:
raise ConfigurationError("could not merge dicts - the preferred dict contains "
f"invalid keys (key {elem_key} is not a valid list index)")
except IndexError:
raise ConfigurationError("could not merge dicts - the preferred dict contains "
f"invalid keys (key {index} is out of bounds)")
return merged_list
else:
return copy.deepcopy(preferred_value)
preferred_keys = set(preferred.keys())
fallback_keys = set(fallback.keys())
common_keys = preferred_keys & fallback_keys
merged: Dict[str, Any] = {}
for key in preferred_keys - fallback_keys:
merged[key] = copy.deepcopy(preferred[key])
for key in fallback_keys - preferred_keys:
merged[key] = copy.deepcopy(fallback[key])
for key in common_keys:
preferred_value = preferred[key]
fallback_value = fallback[key]
merged[key] = merge(preferred_value, fallback_value)
return merged
|
python
|
def with_fallback(preferred: Dict[str, Any], fallback: Dict[str, Any]) -> Dict[str, Any]:
"""
Deep merge two dicts, preferring values from `preferred`.
"""
def merge(preferred_value: Any, fallback_value: Any) -> Any:
if isinstance(preferred_value, dict) and isinstance(fallback_value, dict):
return with_fallback(preferred_value, fallback_value)
elif isinstance(preferred_value, dict) and isinstance(fallback_value, list):
# treat preferred_value as a sparse list, where each key is an index to be overridden
merged_list = fallback_value
for elem_key, preferred_element in preferred_value.items():
try:
index = int(elem_key)
merged_list[index] = merge(preferred_element, fallback_value[index])
except ValueError:
raise ConfigurationError("could not merge dicts - the preferred dict contains "
f"invalid keys (key {elem_key} is not a valid list index)")
except IndexError:
raise ConfigurationError("could not merge dicts - the preferred dict contains "
f"invalid keys (key {index} is out of bounds)")
return merged_list
else:
return copy.deepcopy(preferred_value)
preferred_keys = set(preferred.keys())
fallback_keys = set(fallback.keys())
common_keys = preferred_keys & fallback_keys
merged: Dict[str, Any] = {}
for key in preferred_keys - fallback_keys:
merged[key] = copy.deepcopy(preferred[key])
for key in fallback_keys - preferred_keys:
merged[key] = copy.deepcopy(fallback[key])
for key in common_keys:
preferred_value = preferred[key]
fallback_value = fallback[key]
merged[key] = merge(preferred_value, fallback_value)
return merged
|
[
"def",
"with_fallback",
"(",
"preferred",
":",
"Dict",
"[",
"str",
",",
"Any",
"]",
",",
"fallback",
":",
"Dict",
"[",
"str",
",",
"Any",
"]",
")",
"->",
"Dict",
"[",
"str",
",",
"Any",
"]",
":",
"def",
"merge",
"(",
"preferred_value",
":",
"Any",
",",
"fallback_value",
":",
"Any",
")",
"->",
"Any",
":",
"if",
"isinstance",
"(",
"preferred_value",
",",
"dict",
")",
"and",
"isinstance",
"(",
"fallback_value",
",",
"dict",
")",
":",
"return",
"with_fallback",
"(",
"preferred_value",
",",
"fallback_value",
")",
"elif",
"isinstance",
"(",
"preferred_value",
",",
"dict",
")",
"and",
"isinstance",
"(",
"fallback_value",
",",
"list",
")",
":",
"# treat preferred_value as a sparse list, where each key is an index to be overridden",
"merged_list",
"=",
"fallback_value",
"for",
"elem_key",
",",
"preferred_element",
"in",
"preferred_value",
".",
"items",
"(",
")",
":",
"try",
":",
"index",
"=",
"int",
"(",
"elem_key",
")",
"merged_list",
"[",
"index",
"]",
"=",
"merge",
"(",
"preferred_element",
",",
"fallback_value",
"[",
"index",
"]",
")",
"except",
"ValueError",
":",
"raise",
"ConfigurationError",
"(",
"\"could not merge dicts - the preferred dict contains \"",
"f\"invalid keys (key {elem_key} is not a valid list index)\"",
")",
"except",
"IndexError",
":",
"raise",
"ConfigurationError",
"(",
"\"could not merge dicts - the preferred dict contains \"",
"f\"invalid keys (key {index} is out of bounds)\"",
")",
"return",
"merged_list",
"else",
":",
"return",
"copy",
".",
"deepcopy",
"(",
"preferred_value",
")",
"preferred_keys",
"=",
"set",
"(",
"preferred",
".",
"keys",
"(",
")",
")",
"fallback_keys",
"=",
"set",
"(",
"fallback",
".",
"keys",
"(",
")",
")",
"common_keys",
"=",
"preferred_keys",
"&",
"fallback_keys",
"merged",
":",
"Dict",
"[",
"str",
",",
"Any",
"]",
"=",
"{",
"}",
"for",
"key",
"in",
"preferred_keys",
"-",
"fallback_keys",
":",
"merged",
"[",
"key",
"]",
"=",
"copy",
".",
"deepcopy",
"(",
"preferred",
"[",
"key",
"]",
")",
"for",
"key",
"in",
"fallback_keys",
"-",
"preferred_keys",
":",
"merged",
"[",
"key",
"]",
"=",
"copy",
".",
"deepcopy",
"(",
"fallback",
"[",
"key",
"]",
")",
"for",
"key",
"in",
"common_keys",
":",
"preferred_value",
"=",
"preferred",
"[",
"key",
"]",
"fallback_value",
"=",
"fallback",
"[",
"key",
"]",
"merged",
"[",
"key",
"]",
"=",
"merge",
"(",
"preferred_value",
",",
"fallback_value",
")",
"return",
"merged"
] |
Deep merge two dicts, preferring values from `preferred`.
|
[
"Deep",
"merge",
"two",
"dicts",
"preferring",
"values",
"from",
"preferred",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/common/params.py#L121-L161
|
train
|
allenai/allennlp
|
allennlp/common/params.py
|
pop_choice
|
def pop_choice(params: Dict[str, Any],
key: str,
choices: List[Any],
default_to_first_choice: bool = False,
history: str = "?.") -> Any:
"""
Performs the same function as :func:`Params.pop_choice`, but is required in order to deal with
places that the Params object is not welcome, such as inside Keras layers. See the docstring
of that method for more detail on how this function works.
This method adds a ``history`` parameter, in the off-chance that you know it, so that we can
reproduce :func:`Params.pop_choice` exactly. We default to using "?." if you don't know the
history, so you'll have to fix that in the log if you want to actually recover the logged
parameters.
"""
value = Params(params, history).pop_choice(key, choices, default_to_first_choice)
return value
|
python
|
def pop_choice(params: Dict[str, Any],
key: str,
choices: List[Any],
default_to_first_choice: bool = False,
history: str = "?.") -> Any:
"""
Performs the same function as :func:`Params.pop_choice`, but is required in order to deal with
places that the Params object is not welcome, such as inside Keras layers. See the docstring
of that method for more detail on how this function works.
This method adds a ``history`` parameter, in the off-chance that you know it, so that we can
reproduce :func:`Params.pop_choice` exactly. We default to using "?." if you don't know the
history, so you'll have to fix that in the log if you want to actually recover the logged
parameters.
"""
value = Params(params, history).pop_choice(key, choices, default_to_first_choice)
return value
|
[
"def",
"pop_choice",
"(",
"params",
":",
"Dict",
"[",
"str",
",",
"Any",
"]",
",",
"key",
":",
"str",
",",
"choices",
":",
"List",
"[",
"Any",
"]",
",",
"default_to_first_choice",
":",
"bool",
"=",
"False",
",",
"history",
":",
"str",
"=",
"\"?.\"",
")",
"->",
"Any",
":",
"value",
"=",
"Params",
"(",
"params",
",",
"history",
")",
".",
"pop_choice",
"(",
"key",
",",
"choices",
",",
"default_to_first_choice",
")",
"return",
"value"
] |
Performs the same function as :func:`Params.pop_choice`, but is required in order to deal with
places that the Params object is not welcome, such as inside Keras layers. See the docstring
of that method for more detail on how this function works.
This method adds a ``history`` parameter, in the off-chance that you know it, so that we can
reproduce :func:`Params.pop_choice` exactly. We default to using "?." if you don't know the
history, so you'll have to fix that in the log if you want to actually recover the logged
parameters.
|
[
"Performs",
"the",
"same",
"function",
"as",
":",
"func",
":",
"Params",
".",
"pop_choice",
"but",
"is",
"required",
"in",
"order",
"to",
"deal",
"with",
"places",
"that",
"the",
"Params",
"object",
"is",
"not",
"welcome",
"such",
"as",
"inside",
"Keras",
"layers",
".",
"See",
"the",
"docstring",
"of",
"that",
"method",
"for",
"more",
"detail",
"on",
"how",
"this",
"function",
"works",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/common/params.py#L518-L534
|
train
|
allenai/allennlp
|
allennlp/common/params.py
|
Params.add_file_to_archive
|
def add_file_to_archive(self, name: str) -> None:
"""
Any class in its ``from_params`` method can request that some of its
input files be added to the archive by calling this method.
For example, if some class ``A`` had an ``input_file`` parameter, it could call
```
params.add_file_to_archive("input_file")
```
which would store the supplied value for ``input_file`` at the key
``previous.history.and.then.input_file``. The ``files_to_archive`` dict
is shared with child instances via the ``_check_is_dict`` method, so that
the final mapping can be retrieved from the top-level ``Params`` object.
NOTE: You must call ``add_file_to_archive`` before you ``pop()``
the parameter, because the ``Params`` instance looks up the value
of the filename inside itself.
If the ``loading_from_archive`` flag is True, this will be a no-op.
"""
if not self.loading_from_archive:
self.files_to_archive[f"{self.history}{name}"] = cached_path(self.get(name))
|
python
|
def add_file_to_archive(self, name: str) -> None:
"""
Any class in its ``from_params`` method can request that some of its
input files be added to the archive by calling this method.
For example, if some class ``A`` had an ``input_file`` parameter, it could call
```
params.add_file_to_archive("input_file")
```
which would store the supplied value for ``input_file`` at the key
``previous.history.and.then.input_file``. The ``files_to_archive`` dict
is shared with child instances via the ``_check_is_dict`` method, so that
the final mapping can be retrieved from the top-level ``Params`` object.
NOTE: You must call ``add_file_to_archive`` before you ``pop()``
the parameter, because the ``Params`` instance looks up the value
of the filename inside itself.
If the ``loading_from_archive`` flag is True, this will be a no-op.
"""
if not self.loading_from_archive:
self.files_to_archive[f"{self.history}{name}"] = cached_path(self.get(name))
|
[
"def",
"add_file_to_archive",
"(",
"self",
",",
"name",
":",
"str",
")",
"->",
"None",
":",
"if",
"not",
"self",
".",
"loading_from_archive",
":",
"self",
".",
"files_to_archive",
"[",
"f\"{self.history}{name}\"",
"]",
"=",
"cached_path",
"(",
"self",
".",
"get",
"(",
"name",
")",
")"
] |
Any class in its ``from_params`` method can request that some of its
input files be added to the archive by calling this method.
For example, if some class ``A`` had an ``input_file`` parameter, it could call
```
params.add_file_to_archive("input_file")
```
which would store the supplied value for ``input_file`` at the key
``previous.history.and.then.input_file``. The ``files_to_archive`` dict
is shared with child instances via the ``_check_is_dict`` method, so that
the final mapping can be retrieved from the top-level ``Params`` object.
NOTE: You must call ``add_file_to_archive`` before you ``pop()``
the parameter, because the ``Params`` instance looks up the value
of the filename inside itself.
If the ``loading_from_archive`` flag is True, this will be a no-op.
|
[
"Any",
"class",
"in",
"its",
"from_params",
"method",
"can",
"request",
"that",
"some",
"of",
"its",
"input",
"files",
"be",
"added",
"to",
"the",
"archive",
"by",
"calling",
"this",
"method",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/common/params.py#L209-L232
|
train
|
allenai/allennlp
|
allennlp/common/params.py
|
Params.pop
|
def pop(self, key: str, default: Any = DEFAULT) -> Any:
"""
Performs the functionality associated with dict.pop(key), along with checking for
returned dictionaries, replacing them with Param objects with an updated history.
If ``key`` is not present in the dictionary, and no default was specified, we raise a
``ConfigurationError``, instead of the typical ``KeyError``.
"""
if default is self.DEFAULT:
try:
value = self.params.pop(key)
except KeyError:
raise ConfigurationError("key \"{}\" is required at location \"{}\"".format(key, self.history))
else:
value = self.params.pop(key, default)
if not isinstance(value, dict):
logger.info(self.history + key + " = " + str(value)) # type: ignore
return self._check_is_dict(key, value)
|
python
|
def pop(self, key: str, default: Any = DEFAULT) -> Any:
"""
Performs the functionality associated with dict.pop(key), along with checking for
returned dictionaries, replacing them with Param objects with an updated history.
If ``key`` is not present in the dictionary, and no default was specified, we raise a
``ConfigurationError``, instead of the typical ``KeyError``.
"""
if default is self.DEFAULT:
try:
value = self.params.pop(key)
except KeyError:
raise ConfigurationError("key \"{}\" is required at location \"{}\"".format(key, self.history))
else:
value = self.params.pop(key, default)
if not isinstance(value, dict):
logger.info(self.history + key + " = " + str(value)) # type: ignore
return self._check_is_dict(key, value)
|
[
"def",
"pop",
"(",
"self",
",",
"key",
":",
"str",
",",
"default",
":",
"Any",
"=",
"DEFAULT",
")",
"->",
"Any",
":",
"if",
"default",
"is",
"self",
".",
"DEFAULT",
":",
"try",
":",
"value",
"=",
"self",
".",
"params",
".",
"pop",
"(",
"key",
")",
"except",
"KeyError",
":",
"raise",
"ConfigurationError",
"(",
"\"key \\\"{}\\\" is required at location \\\"{}\\\"\"",
".",
"format",
"(",
"key",
",",
"self",
".",
"history",
")",
")",
"else",
":",
"value",
"=",
"self",
".",
"params",
".",
"pop",
"(",
"key",
",",
"default",
")",
"if",
"not",
"isinstance",
"(",
"value",
",",
"dict",
")",
":",
"logger",
".",
"info",
"(",
"self",
".",
"history",
"+",
"key",
"+",
"\" = \"",
"+",
"str",
"(",
"value",
")",
")",
"# type: ignore",
"return",
"self",
".",
"_check_is_dict",
"(",
"key",
",",
"value",
")"
] |
Performs the functionality associated with dict.pop(key), along with checking for
returned dictionaries, replacing them with Param objects with an updated history.
If ``key`` is not present in the dictionary, and no default was specified, we raise a
``ConfigurationError``, instead of the typical ``KeyError``.
|
[
"Performs",
"the",
"functionality",
"associated",
"with",
"dict",
".",
"pop",
"(",
"key",
")",
"along",
"with",
"checking",
"for",
"returned",
"dictionaries",
"replacing",
"them",
"with",
"Param",
"objects",
"with",
"an",
"updated",
"history",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/common/params.py#L235-L252
|
train
|
allenai/allennlp
|
allennlp/common/params.py
|
Params.pop_int
|
def pop_int(self, key: str, default: Any = DEFAULT) -> int:
"""
Performs a pop and coerces to an int.
"""
value = self.pop(key, default)
if value is None:
return None
else:
return int(value)
|
python
|
def pop_int(self, key: str, default: Any = DEFAULT) -> int:
"""
Performs a pop and coerces to an int.
"""
value = self.pop(key, default)
if value is None:
return None
else:
return int(value)
|
[
"def",
"pop_int",
"(",
"self",
",",
"key",
":",
"str",
",",
"default",
":",
"Any",
"=",
"DEFAULT",
")",
"->",
"int",
":",
"value",
"=",
"self",
".",
"pop",
"(",
"key",
",",
"default",
")",
"if",
"value",
"is",
"None",
":",
"return",
"None",
"else",
":",
"return",
"int",
"(",
"value",
")"
] |
Performs a pop and coerces to an int.
|
[
"Performs",
"a",
"pop",
"and",
"coerces",
"to",
"an",
"int",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/common/params.py#L254-L262
|
train
|
allenai/allennlp
|
allennlp/common/params.py
|
Params.pop_float
|
def pop_float(self, key: str, default: Any = DEFAULT) -> float:
"""
Performs a pop and coerces to a float.
"""
value = self.pop(key, default)
if value is None:
return None
else:
return float(value)
|
python
|
def pop_float(self, key: str, default: Any = DEFAULT) -> float:
"""
Performs a pop and coerces to a float.
"""
value = self.pop(key, default)
if value is None:
return None
else:
return float(value)
|
[
"def",
"pop_float",
"(",
"self",
",",
"key",
":",
"str",
",",
"default",
":",
"Any",
"=",
"DEFAULT",
")",
"->",
"float",
":",
"value",
"=",
"self",
".",
"pop",
"(",
"key",
",",
"default",
")",
"if",
"value",
"is",
"None",
":",
"return",
"None",
"else",
":",
"return",
"float",
"(",
"value",
")"
] |
Performs a pop and coerces to a float.
|
[
"Performs",
"a",
"pop",
"and",
"coerces",
"to",
"a",
"float",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/common/params.py#L264-L272
|
train
|
allenai/allennlp
|
allennlp/common/params.py
|
Params.pop_bool
|
def pop_bool(self, key: str, default: Any = DEFAULT) -> bool:
"""
Performs a pop and coerces to a bool.
"""
value = self.pop(key, default)
if value is None:
return None
elif isinstance(value, bool):
return value
elif value == "true":
return True
elif value == "false":
return False
else:
raise ValueError("Cannot convert variable to bool: " + value)
|
python
|
def pop_bool(self, key: str, default: Any = DEFAULT) -> bool:
"""
Performs a pop and coerces to a bool.
"""
value = self.pop(key, default)
if value is None:
return None
elif isinstance(value, bool):
return value
elif value == "true":
return True
elif value == "false":
return False
else:
raise ValueError("Cannot convert variable to bool: " + value)
|
[
"def",
"pop_bool",
"(",
"self",
",",
"key",
":",
"str",
",",
"default",
":",
"Any",
"=",
"DEFAULT",
")",
"->",
"bool",
":",
"value",
"=",
"self",
".",
"pop",
"(",
"key",
",",
"default",
")",
"if",
"value",
"is",
"None",
":",
"return",
"None",
"elif",
"isinstance",
"(",
"value",
",",
"bool",
")",
":",
"return",
"value",
"elif",
"value",
"==",
"\"true\"",
":",
"return",
"True",
"elif",
"value",
"==",
"\"false\"",
":",
"return",
"False",
"else",
":",
"raise",
"ValueError",
"(",
"\"Cannot convert variable to bool: \"",
"+",
"value",
")"
] |
Performs a pop and coerces to a bool.
|
[
"Performs",
"a",
"pop",
"and",
"coerces",
"to",
"a",
"bool",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/common/params.py#L274-L288
|
train
|
allenai/allennlp
|
allennlp/common/params.py
|
Params.get
|
def get(self, key: str, default: Any = DEFAULT):
"""
Performs the functionality associated with dict.get(key) but also checks for returned
dicts and returns a Params object in their place with an updated history.
"""
if default is self.DEFAULT:
try:
value = self.params.get(key)
except KeyError:
raise ConfigurationError("key \"{}\" is required at location \"{}\"".format(key, self.history))
else:
value = self.params.get(key, default)
return self._check_is_dict(key, value)
|
python
|
def get(self, key: str, default: Any = DEFAULT):
"""
Performs the functionality associated with dict.get(key) but also checks for returned
dicts and returns a Params object in their place with an updated history.
"""
if default is self.DEFAULT:
try:
value = self.params.get(key)
except KeyError:
raise ConfigurationError("key \"{}\" is required at location \"{}\"".format(key, self.history))
else:
value = self.params.get(key, default)
return self._check_is_dict(key, value)
|
[
"def",
"get",
"(",
"self",
",",
"key",
":",
"str",
",",
"default",
":",
"Any",
"=",
"DEFAULT",
")",
":",
"if",
"default",
"is",
"self",
".",
"DEFAULT",
":",
"try",
":",
"value",
"=",
"self",
".",
"params",
".",
"get",
"(",
"key",
")",
"except",
"KeyError",
":",
"raise",
"ConfigurationError",
"(",
"\"key \\\"{}\\\" is required at location \\\"{}\\\"\"",
".",
"format",
"(",
"key",
",",
"self",
".",
"history",
")",
")",
"else",
":",
"value",
"=",
"self",
".",
"params",
".",
"get",
"(",
"key",
",",
"default",
")",
"return",
"self",
".",
"_check_is_dict",
"(",
"key",
",",
"value",
")"
] |
Performs the functionality associated with dict.get(key) but also checks for returned
dicts and returns a Params object in their place with an updated history.
|
[
"Performs",
"the",
"functionality",
"associated",
"with",
"dict",
".",
"get",
"(",
"key",
")",
"but",
"also",
"checks",
"for",
"returned",
"dicts",
"and",
"returns",
"a",
"Params",
"object",
"in",
"their",
"place",
"with",
"an",
"updated",
"history",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/common/params.py#L291-L303
|
train
|
allenai/allennlp
|
allennlp/common/params.py
|
Params.pop_choice
|
def pop_choice(self, key: str, choices: List[Any], default_to_first_choice: bool = False) -> Any:
"""
Gets the value of ``key`` in the ``params`` dictionary, ensuring that the value is one of
the given choices. Note that this `pops` the key from params, modifying the dictionary,
consistent with how parameters are processed in this codebase.
Parameters
----------
key: str
Key to get the value from in the param dictionary
choices: List[Any]
A list of valid options for values corresponding to ``key``. For example, if you're
specifying the type of encoder to use for some part of your model, the choices might be
the list of encoder classes we know about and can instantiate. If the value we find in
the param dictionary is not in ``choices``, we raise a ``ConfigurationError``, because
the user specified an invalid value in their parameter file.
default_to_first_choice: bool, optional (default=False)
If this is ``True``, we allow the ``key`` to not be present in the parameter
dictionary. If the key is not present, we will use the return as the value the first
choice in the ``choices`` list. If this is ``False``, we raise a
``ConfigurationError``, because specifying the ``key`` is required (e.g., you `have` to
specify your model class when running an experiment, but you can feel free to use
default settings for encoders if you want).
"""
default = choices[0] if default_to_first_choice else self.DEFAULT
value = self.pop(key, default)
if value not in choices:
key_str = self.history + key
message = '%s not in acceptable choices for %s: %s' % (value, key_str, str(choices))
raise ConfigurationError(message)
return value
|
python
|
def pop_choice(self, key: str, choices: List[Any], default_to_first_choice: bool = False) -> Any:
"""
Gets the value of ``key`` in the ``params`` dictionary, ensuring that the value is one of
the given choices. Note that this `pops` the key from params, modifying the dictionary,
consistent with how parameters are processed in this codebase.
Parameters
----------
key: str
Key to get the value from in the param dictionary
choices: List[Any]
A list of valid options for values corresponding to ``key``. For example, if you're
specifying the type of encoder to use for some part of your model, the choices might be
the list of encoder classes we know about and can instantiate. If the value we find in
the param dictionary is not in ``choices``, we raise a ``ConfigurationError``, because
the user specified an invalid value in their parameter file.
default_to_first_choice: bool, optional (default=False)
If this is ``True``, we allow the ``key`` to not be present in the parameter
dictionary. If the key is not present, we will use the return as the value the first
choice in the ``choices`` list. If this is ``False``, we raise a
``ConfigurationError``, because specifying the ``key`` is required (e.g., you `have` to
specify your model class when running an experiment, but you can feel free to use
default settings for encoders if you want).
"""
default = choices[0] if default_to_first_choice else self.DEFAULT
value = self.pop(key, default)
if value not in choices:
key_str = self.history + key
message = '%s not in acceptable choices for %s: %s' % (value, key_str, str(choices))
raise ConfigurationError(message)
return value
|
[
"def",
"pop_choice",
"(",
"self",
",",
"key",
":",
"str",
",",
"choices",
":",
"List",
"[",
"Any",
"]",
",",
"default_to_first_choice",
":",
"bool",
"=",
"False",
")",
"->",
"Any",
":",
"default",
"=",
"choices",
"[",
"0",
"]",
"if",
"default_to_first_choice",
"else",
"self",
".",
"DEFAULT",
"value",
"=",
"self",
".",
"pop",
"(",
"key",
",",
"default",
")",
"if",
"value",
"not",
"in",
"choices",
":",
"key_str",
"=",
"self",
".",
"history",
"+",
"key",
"message",
"=",
"'%s not in acceptable choices for %s: %s'",
"%",
"(",
"value",
",",
"key_str",
",",
"str",
"(",
"choices",
")",
")",
"raise",
"ConfigurationError",
"(",
"message",
")",
"return",
"value"
] |
Gets the value of ``key`` in the ``params`` dictionary, ensuring that the value is one of
the given choices. Note that this `pops` the key from params, modifying the dictionary,
consistent with how parameters are processed in this codebase.
Parameters
----------
key: str
Key to get the value from in the param dictionary
choices: List[Any]
A list of valid options for values corresponding to ``key``. For example, if you're
specifying the type of encoder to use for some part of your model, the choices might be
the list of encoder classes we know about and can instantiate. If the value we find in
the param dictionary is not in ``choices``, we raise a ``ConfigurationError``, because
the user specified an invalid value in their parameter file.
default_to_first_choice: bool, optional (default=False)
If this is ``True``, we allow the ``key`` to not be present in the parameter
dictionary. If the key is not present, we will use the return as the value the first
choice in the ``choices`` list. If this is ``False``, we raise a
``ConfigurationError``, because specifying the ``key`` is required (e.g., you `have` to
specify your model class when running an experiment, but you can feel free to use
default settings for encoders if you want).
|
[
"Gets",
"the",
"value",
"of",
"key",
"in",
"the",
"params",
"dictionary",
"ensuring",
"that",
"the",
"value",
"is",
"one",
"of",
"the",
"given",
"choices",
".",
"Note",
"that",
"this",
"pops",
"the",
"key",
"from",
"params",
"modifying",
"the",
"dictionary",
"consistent",
"with",
"how",
"parameters",
"are",
"processed",
"in",
"this",
"codebase",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/common/params.py#L305-L335
|
train
|
allenai/allennlp
|
allennlp/common/params.py
|
Params.as_dict
|
def as_dict(self, quiet: bool = False, infer_type_and_cast: bool = False):
"""
Sometimes we need to just represent the parameters as a dict, for instance when we pass
them to PyTorch code.
Parameters
----------
quiet: bool, optional (default = False)
Whether to log the parameters before returning them as a dict.
infer_type_and_cast : bool, optional (default = False)
If True, we infer types and cast (e.g. things that look like floats to floats).
"""
if infer_type_and_cast:
params_as_dict = infer_and_cast(self.params)
else:
params_as_dict = self.params
if quiet:
return params_as_dict
def log_recursively(parameters, history):
for key, value in parameters.items():
if isinstance(value, dict):
new_local_history = history + key + "."
log_recursively(value, new_local_history)
else:
logger.info(history + key + " = " + str(value))
logger.info("Converting Params object to dict; logging of default "
"values will not occur when dictionary parameters are "
"used subsequently.")
logger.info("CURRENTLY DEFINED PARAMETERS: ")
log_recursively(self.params, self.history)
return params_as_dict
|
python
|
def as_dict(self, quiet: bool = False, infer_type_and_cast: bool = False):
"""
Sometimes we need to just represent the parameters as a dict, for instance when we pass
them to PyTorch code.
Parameters
----------
quiet: bool, optional (default = False)
Whether to log the parameters before returning them as a dict.
infer_type_and_cast : bool, optional (default = False)
If True, we infer types and cast (e.g. things that look like floats to floats).
"""
if infer_type_and_cast:
params_as_dict = infer_and_cast(self.params)
else:
params_as_dict = self.params
if quiet:
return params_as_dict
def log_recursively(parameters, history):
for key, value in parameters.items():
if isinstance(value, dict):
new_local_history = history + key + "."
log_recursively(value, new_local_history)
else:
logger.info(history + key + " = " + str(value))
logger.info("Converting Params object to dict; logging of default "
"values will not occur when dictionary parameters are "
"used subsequently.")
logger.info("CURRENTLY DEFINED PARAMETERS: ")
log_recursively(self.params, self.history)
return params_as_dict
|
[
"def",
"as_dict",
"(",
"self",
",",
"quiet",
":",
"bool",
"=",
"False",
",",
"infer_type_and_cast",
":",
"bool",
"=",
"False",
")",
":",
"if",
"infer_type_and_cast",
":",
"params_as_dict",
"=",
"infer_and_cast",
"(",
"self",
".",
"params",
")",
"else",
":",
"params_as_dict",
"=",
"self",
".",
"params",
"if",
"quiet",
":",
"return",
"params_as_dict",
"def",
"log_recursively",
"(",
"parameters",
",",
"history",
")",
":",
"for",
"key",
",",
"value",
"in",
"parameters",
".",
"items",
"(",
")",
":",
"if",
"isinstance",
"(",
"value",
",",
"dict",
")",
":",
"new_local_history",
"=",
"history",
"+",
"key",
"+",
"\".\"",
"log_recursively",
"(",
"value",
",",
"new_local_history",
")",
"else",
":",
"logger",
".",
"info",
"(",
"history",
"+",
"key",
"+",
"\" = \"",
"+",
"str",
"(",
"value",
")",
")",
"logger",
".",
"info",
"(",
"\"Converting Params object to dict; logging of default \"",
"\"values will not occur when dictionary parameters are \"",
"\"used subsequently.\"",
")",
"logger",
".",
"info",
"(",
"\"CURRENTLY DEFINED PARAMETERS: \"",
")",
"log_recursively",
"(",
"self",
".",
"params",
",",
"self",
".",
"history",
")",
"return",
"params_as_dict"
] |
Sometimes we need to just represent the parameters as a dict, for instance when we pass
them to PyTorch code.
Parameters
----------
quiet: bool, optional (default = False)
Whether to log the parameters before returning them as a dict.
infer_type_and_cast : bool, optional (default = False)
If True, we infer types and cast (e.g. things that look like floats to floats).
|
[
"Sometimes",
"we",
"need",
"to",
"just",
"represent",
"the",
"parameters",
"as",
"a",
"dict",
"for",
"instance",
"when",
"we",
"pass",
"them",
"to",
"PyTorch",
"code",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/common/params.py#L337-L370
|
train
|
allenai/allennlp
|
allennlp/common/params.py
|
Params.as_flat_dict
|
def as_flat_dict(self):
"""
Returns the parameters of a flat dictionary from keys to values.
Nested structure is collapsed with periods.
"""
flat_params = {}
def recurse(parameters, path):
for key, value in parameters.items():
newpath = path + [key]
if isinstance(value, dict):
recurse(value, newpath)
else:
flat_params['.'.join(newpath)] = value
recurse(self.params, [])
return flat_params
|
python
|
def as_flat_dict(self):
"""
Returns the parameters of a flat dictionary from keys to values.
Nested structure is collapsed with periods.
"""
flat_params = {}
def recurse(parameters, path):
for key, value in parameters.items():
newpath = path + [key]
if isinstance(value, dict):
recurse(value, newpath)
else:
flat_params['.'.join(newpath)] = value
recurse(self.params, [])
return flat_params
|
[
"def",
"as_flat_dict",
"(",
"self",
")",
":",
"flat_params",
"=",
"{",
"}",
"def",
"recurse",
"(",
"parameters",
",",
"path",
")",
":",
"for",
"key",
",",
"value",
"in",
"parameters",
".",
"items",
"(",
")",
":",
"newpath",
"=",
"path",
"+",
"[",
"key",
"]",
"if",
"isinstance",
"(",
"value",
",",
"dict",
")",
":",
"recurse",
"(",
"value",
",",
"newpath",
")",
"else",
":",
"flat_params",
"[",
"'.'",
".",
"join",
"(",
"newpath",
")",
"]",
"=",
"value",
"recurse",
"(",
"self",
".",
"params",
",",
"[",
"]",
")",
"return",
"flat_params"
] |
Returns the parameters of a flat dictionary from keys to values.
Nested structure is collapsed with periods.
|
[
"Returns",
"the",
"parameters",
"of",
"a",
"flat",
"dictionary",
"from",
"keys",
"to",
"values",
".",
"Nested",
"structure",
"is",
"collapsed",
"with",
"periods",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/common/params.py#L372-L387
|
train
|
allenai/allennlp
|
allennlp/common/params.py
|
Params.assert_empty
|
def assert_empty(self, class_name: str):
"""
Raises a ``ConfigurationError`` if ``self.params`` is not empty. We take ``class_name`` as
an argument so that the error message gives some idea of where an error happened, if there
was one. ``class_name`` should be the name of the `calling` class, the one that got extra
parameters (if there are any).
"""
if self.params:
raise ConfigurationError("Extra parameters passed to {}: {}".format(class_name, self.params))
|
python
|
def assert_empty(self, class_name: str):
"""
Raises a ``ConfigurationError`` if ``self.params`` is not empty. We take ``class_name`` as
an argument so that the error message gives some idea of where an error happened, if there
was one. ``class_name`` should be the name of the `calling` class, the one that got extra
parameters (if there are any).
"""
if self.params:
raise ConfigurationError("Extra parameters passed to {}: {}".format(class_name, self.params))
|
[
"def",
"assert_empty",
"(",
"self",
",",
"class_name",
":",
"str",
")",
":",
"if",
"self",
".",
"params",
":",
"raise",
"ConfigurationError",
"(",
"\"Extra parameters passed to {}: {}\"",
".",
"format",
"(",
"class_name",
",",
"self",
".",
"params",
")",
")"
] |
Raises a ``ConfigurationError`` if ``self.params`` is not empty. We take ``class_name`` as
an argument so that the error message gives some idea of where an error happened, if there
was one. ``class_name`` should be the name of the `calling` class, the one that got extra
parameters (if there are any).
|
[
"Raises",
"a",
"ConfigurationError",
"if",
"self",
".",
"params",
"is",
"not",
"empty",
".",
"We",
"take",
"class_name",
"as",
"an",
"argument",
"so",
"that",
"the",
"error",
"message",
"gives",
"some",
"idea",
"of",
"where",
"an",
"error",
"happened",
"if",
"there",
"was",
"one",
".",
"class_name",
"should",
"be",
"the",
"name",
"of",
"the",
"calling",
"class",
"the",
"one",
"that",
"got",
"extra",
"parameters",
"(",
"if",
"there",
"are",
"any",
")",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/common/params.py#L396-L404
|
train
|
allenai/allennlp
|
allennlp/common/params.py
|
Params.from_file
|
def from_file(params_file: str, params_overrides: str = "", ext_vars: dict = None) -> 'Params':
"""
Load a `Params` object from a configuration file.
Parameters
----------
params_file : ``str``
The path to the configuration file to load.
params_overrides : ``str``, optional
A dict of overrides that can be applied to final object.
e.g. {"model.embedding_dim": 10}
ext_vars : ``dict``, optional
Our config files are Jsonnet, which allows specifying external variables
for later substitution. Typically we substitute these using environment
variables; however, you can also specify them here, in which case they
take priority over environment variables.
e.g. {"HOME_DIR": "/Users/allennlp/home"}
"""
if ext_vars is None:
ext_vars = {}
# redirect to cache, if necessary
params_file = cached_path(params_file)
ext_vars = {**_environment_variables(), **ext_vars}
file_dict = json.loads(evaluate_file(params_file, ext_vars=ext_vars))
overrides_dict = parse_overrides(params_overrides)
param_dict = with_fallback(preferred=overrides_dict, fallback=file_dict)
return Params(param_dict)
|
python
|
def from_file(params_file: str, params_overrides: str = "", ext_vars: dict = None) -> 'Params':
"""
Load a `Params` object from a configuration file.
Parameters
----------
params_file : ``str``
The path to the configuration file to load.
params_overrides : ``str``, optional
A dict of overrides that can be applied to final object.
e.g. {"model.embedding_dim": 10}
ext_vars : ``dict``, optional
Our config files are Jsonnet, which allows specifying external variables
for later substitution. Typically we substitute these using environment
variables; however, you can also specify them here, in which case they
take priority over environment variables.
e.g. {"HOME_DIR": "/Users/allennlp/home"}
"""
if ext_vars is None:
ext_vars = {}
# redirect to cache, if necessary
params_file = cached_path(params_file)
ext_vars = {**_environment_variables(), **ext_vars}
file_dict = json.loads(evaluate_file(params_file, ext_vars=ext_vars))
overrides_dict = parse_overrides(params_overrides)
param_dict = with_fallback(preferred=overrides_dict, fallback=file_dict)
return Params(param_dict)
|
[
"def",
"from_file",
"(",
"params_file",
":",
"str",
",",
"params_overrides",
":",
"str",
"=",
"\"\"",
",",
"ext_vars",
":",
"dict",
"=",
"None",
")",
"->",
"'Params'",
":",
"if",
"ext_vars",
"is",
"None",
":",
"ext_vars",
"=",
"{",
"}",
"# redirect to cache, if necessary",
"params_file",
"=",
"cached_path",
"(",
"params_file",
")",
"ext_vars",
"=",
"{",
"*",
"*",
"_environment_variables",
"(",
")",
",",
"*",
"*",
"ext_vars",
"}",
"file_dict",
"=",
"json",
".",
"loads",
"(",
"evaluate_file",
"(",
"params_file",
",",
"ext_vars",
"=",
"ext_vars",
")",
")",
"overrides_dict",
"=",
"parse_overrides",
"(",
"params_overrides",
")",
"param_dict",
"=",
"with_fallback",
"(",
"preferred",
"=",
"overrides_dict",
",",
"fallback",
"=",
"file_dict",
")",
"return",
"Params",
"(",
"param_dict",
")"
] |
Load a `Params` object from a configuration file.
Parameters
----------
params_file : ``str``
The path to the configuration file to load.
params_overrides : ``str``, optional
A dict of overrides that can be applied to final object.
e.g. {"model.embedding_dim": 10}
ext_vars : ``dict``, optional
Our config files are Jsonnet, which allows specifying external variables
for later substitution. Typically we substitute these using environment
variables; however, you can also specify them here, in which case they
take priority over environment variables.
e.g. {"HOME_DIR": "/Users/allennlp/home"}
|
[
"Load",
"a",
"Params",
"object",
"from",
"a",
"configuration",
"file",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/common/params.py#L436-L466
|
train
|
allenai/allennlp
|
allennlp/common/params.py
|
Params.as_ordered_dict
|
def as_ordered_dict(self, preference_orders: List[List[str]] = None) -> OrderedDict:
"""
Returns Ordered Dict of Params from list of partial order preferences.
Parameters
----------
preference_orders: List[List[str]], optional
``preference_orders`` is list of partial preference orders. ["A", "B", "C"] means
"A" > "B" > "C". For multiple preference_orders first will be considered first.
Keys not found, will have last but alphabetical preference. Default Preferences:
``[["dataset_reader", "iterator", "model", "train_data_path", "validation_data_path",
"test_data_path", "trainer", "vocabulary"], ["type"]]``
"""
params_dict = self.as_dict(quiet=True)
if not preference_orders:
preference_orders = []
preference_orders.append(["dataset_reader", "iterator", "model",
"train_data_path", "validation_data_path", "test_data_path",
"trainer", "vocabulary"])
preference_orders.append(["type"])
def order_func(key):
# Makes a tuple to use for ordering. The tuple is an index into each of the `preference_orders`,
# followed by the key itself. This gives us integer sorting if you have a key in one of the
# `preference_orders`, followed by alphabetical ordering if not.
order_tuple = [order.index(key) if key in order else len(order) for order in preference_orders]
return order_tuple + [key]
def order_dict(dictionary, order_func):
# Recursively orders dictionary according to scoring order_func
result = OrderedDict()
for key, val in sorted(dictionary.items(), key=lambda item: order_func(item[0])):
result[key] = order_dict(val, order_func) if isinstance(val, dict) else val
return result
return order_dict(params_dict, order_func)
|
python
|
def as_ordered_dict(self, preference_orders: List[List[str]] = None) -> OrderedDict:
"""
Returns Ordered Dict of Params from list of partial order preferences.
Parameters
----------
preference_orders: List[List[str]], optional
``preference_orders`` is list of partial preference orders. ["A", "B", "C"] means
"A" > "B" > "C". For multiple preference_orders first will be considered first.
Keys not found, will have last but alphabetical preference. Default Preferences:
``[["dataset_reader", "iterator", "model", "train_data_path", "validation_data_path",
"test_data_path", "trainer", "vocabulary"], ["type"]]``
"""
params_dict = self.as_dict(quiet=True)
if not preference_orders:
preference_orders = []
preference_orders.append(["dataset_reader", "iterator", "model",
"train_data_path", "validation_data_path", "test_data_path",
"trainer", "vocabulary"])
preference_orders.append(["type"])
def order_func(key):
# Makes a tuple to use for ordering. The tuple is an index into each of the `preference_orders`,
# followed by the key itself. This gives us integer sorting if you have a key in one of the
# `preference_orders`, followed by alphabetical ordering if not.
order_tuple = [order.index(key) if key in order else len(order) for order in preference_orders]
return order_tuple + [key]
def order_dict(dictionary, order_func):
# Recursively orders dictionary according to scoring order_func
result = OrderedDict()
for key, val in sorted(dictionary.items(), key=lambda item: order_func(item[0])):
result[key] = order_dict(val, order_func) if isinstance(val, dict) else val
return result
return order_dict(params_dict, order_func)
|
[
"def",
"as_ordered_dict",
"(",
"self",
",",
"preference_orders",
":",
"List",
"[",
"List",
"[",
"str",
"]",
"]",
"=",
"None",
")",
"->",
"OrderedDict",
":",
"params_dict",
"=",
"self",
".",
"as_dict",
"(",
"quiet",
"=",
"True",
")",
"if",
"not",
"preference_orders",
":",
"preference_orders",
"=",
"[",
"]",
"preference_orders",
".",
"append",
"(",
"[",
"\"dataset_reader\"",
",",
"\"iterator\"",
",",
"\"model\"",
",",
"\"train_data_path\"",
",",
"\"validation_data_path\"",
",",
"\"test_data_path\"",
",",
"\"trainer\"",
",",
"\"vocabulary\"",
"]",
")",
"preference_orders",
".",
"append",
"(",
"[",
"\"type\"",
"]",
")",
"def",
"order_func",
"(",
"key",
")",
":",
"# Makes a tuple to use for ordering. The tuple is an index into each of the `preference_orders`,",
"# followed by the key itself. This gives us integer sorting if you have a key in one of the",
"# `preference_orders`, followed by alphabetical ordering if not.",
"order_tuple",
"=",
"[",
"order",
".",
"index",
"(",
"key",
")",
"if",
"key",
"in",
"order",
"else",
"len",
"(",
"order",
")",
"for",
"order",
"in",
"preference_orders",
"]",
"return",
"order_tuple",
"+",
"[",
"key",
"]",
"def",
"order_dict",
"(",
"dictionary",
",",
"order_func",
")",
":",
"# Recursively orders dictionary according to scoring order_func",
"result",
"=",
"OrderedDict",
"(",
")",
"for",
"key",
",",
"val",
"in",
"sorted",
"(",
"dictionary",
".",
"items",
"(",
")",
",",
"key",
"=",
"lambda",
"item",
":",
"order_func",
"(",
"item",
"[",
"0",
"]",
")",
")",
":",
"result",
"[",
"key",
"]",
"=",
"order_dict",
"(",
"val",
",",
"order_func",
")",
"if",
"isinstance",
"(",
"val",
",",
"dict",
")",
"else",
"val",
"return",
"result",
"return",
"order_dict",
"(",
"params_dict",
",",
"order_func",
")"
] |
Returns Ordered Dict of Params from list of partial order preferences.
Parameters
----------
preference_orders: List[List[str]], optional
``preference_orders`` is list of partial preference orders. ["A", "B", "C"] means
"A" > "B" > "C". For multiple preference_orders first will be considered first.
Keys not found, will have last but alphabetical preference. Default Preferences:
``[["dataset_reader", "iterator", "model", "train_data_path", "validation_data_path",
"test_data_path", "trainer", "vocabulary"], ["type"]]``
|
[
"Returns",
"Ordered",
"Dict",
"of",
"Params",
"from",
"list",
"of",
"partial",
"order",
"preferences",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/common/params.py#L472-L507
|
train
|
allenai/allennlp
|
allennlp/common/params.py
|
Params.get_hash
|
def get_hash(self) -> str:
"""
Returns a hash code representing the current state of this ``Params`` object. We don't
want to implement ``__hash__`` because that has deeper python implications (and this is a
mutable object), but this will give you a representation of the current state.
"""
return str(hash(json.dumps(self.params, sort_keys=True)))
|
python
|
def get_hash(self) -> str:
"""
Returns a hash code representing the current state of this ``Params`` object. We don't
want to implement ``__hash__`` because that has deeper python implications (and this is a
mutable object), but this will give you a representation of the current state.
"""
return str(hash(json.dumps(self.params, sort_keys=True)))
|
[
"def",
"get_hash",
"(",
"self",
")",
"->",
"str",
":",
"return",
"str",
"(",
"hash",
"(",
"json",
".",
"dumps",
"(",
"self",
".",
"params",
",",
"sort_keys",
"=",
"True",
")",
")",
")"
] |
Returns a hash code representing the current state of this ``Params`` object. We don't
want to implement ``__hash__`` because that has deeper python implications (and this is a
mutable object), but this will give you a representation of the current state.
|
[
"Returns",
"a",
"hash",
"code",
"representing",
"the",
"current",
"state",
"of",
"this",
"Params",
"object",
".",
"We",
"don",
"t",
"want",
"to",
"implement",
"__hash__",
"because",
"that",
"has",
"deeper",
"python",
"implications",
"(",
"and",
"this",
"is",
"a",
"mutable",
"object",
")",
"but",
"this",
"will",
"give",
"you",
"a",
"representation",
"of",
"the",
"current",
"state",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/common/params.py#L509-L515
|
train
|
allenai/allennlp
|
allennlp/training/metric_tracker.py
|
MetricTracker.clear
|
def clear(self) -> None:
"""
Clears out the tracked metrics, but keeps the patience and should_decrease settings.
"""
self._best_so_far = None
self._epochs_with_no_improvement = 0
self._is_best_so_far = True
self._epoch_number = 0
self.best_epoch = None
|
python
|
def clear(self) -> None:
"""
Clears out the tracked metrics, but keeps the patience and should_decrease settings.
"""
self._best_so_far = None
self._epochs_with_no_improvement = 0
self._is_best_so_far = True
self._epoch_number = 0
self.best_epoch = None
|
[
"def",
"clear",
"(",
"self",
")",
"->",
"None",
":",
"self",
".",
"_best_so_far",
"=",
"None",
"self",
".",
"_epochs_with_no_improvement",
"=",
"0",
"self",
".",
"_is_best_so_far",
"=",
"True",
"self",
".",
"_epoch_number",
"=",
"0",
"self",
".",
"best_epoch",
"=",
"None"
] |
Clears out the tracked metrics, but keeps the patience and should_decrease settings.
|
[
"Clears",
"out",
"the",
"tracked",
"metrics",
"but",
"keeps",
"the",
"patience",
"and",
"should_decrease",
"settings",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/training/metric_tracker.py#L59-L67
|
train
|
allenai/allennlp
|
allennlp/training/metric_tracker.py
|
MetricTracker.state_dict
|
def state_dict(self) -> Dict[str, Any]:
"""
A ``Trainer`` can use this to serialize the state of the metric tracker.
"""
return {
"best_so_far": self._best_so_far,
"patience": self._patience,
"epochs_with_no_improvement": self._epochs_with_no_improvement,
"is_best_so_far": self._is_best_so_far,
"should_decrease": self._should_decrease,
"best_epoch_metrics": self.best_epoch_metrics,
"epoch_number": self._epoch_number,
"best_epoch": self.best_epoch
}
|
python
|
def state_dict(self) -> Dict[str, Any]:
"""
A ``Trainer`` can use this to serialize the state of the metric tracker.
"""
return {
"best_so_far": self._best_so_far,
"patience": self._patience,
"epochs_with_no_improvement": self._epochs_with_no_improvement,
"is_best_so_far": self._is_best_so_far,
"should_decrease": self._should_decrease,
"best_epoch_metrics": self.best_epoch_metrics,
"epoch_number": self._epoch_number,
"best_epoch": self.best_epoch
}
|
[
"def",
"state_dict",
"(",
"self",
")",
"->",
"Dict",
"[",
"str",
",",
"Any",
"]",
":",
"return",
"{",
"\"best_so_far\"",
":",
"self",
".",
"_best_so_far",
",",
"\"patience\"",
":",
"self",
".",
"_patience",
",",
"\"epochs_with_no_improvement\"",
":",
"self",
".",
"_epochs_with_no_improvement",
",",
"\"is_best_so_far\"",
":",
"self",
".",
"_is_best_so_far",
",",
"\"should_decrease\"",
":",
"self",
".",
"_should_decrease",
",",
"\"best_epoch_metrics\"",
":",
"self",
".",
"best_epoch_metrics",
",",
"\"epoch_number\"",
":",
"self",
".",
"_epoch_number",
",",
"\"best_epoch\"",
":",
"self",
".",
"best_epoch",
"}"
] |
A ``Trainer`` can use this to serialize the state of the metric tracker.
|
[
"A",
"Trainer",
"can",
"use",
"this",
"to",
"serialize",
"the",
"state",
"of",
"the",
"metric",
"tracker",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/training/metric_tracker.py#L69-L82
|
train
|
allenai/allennlp
|
allennlp/training/metric_tracker.py
|
MetricTracker.add_metric
|
def add_metric(self, metric: float) -> None:
"""
Record a new value of the metric and update the various things that depend on it.
"""
new_best = ((self._best_so_far is None) or
(self._should_decrease and metric < self._best_so_far) or
(not self._should_decrease and metric > self._best_so_far))
if new_best:
self.best_epoch = self._epoch_number
self._is_best_so_far = True
self._best_so_far = metric
self._epochs_with_no_improvement = 0
else:
self._is_best_so_far = False
self._epochs_with_no_improvement += 1
self._epoch_number += 1
|
python
|
def add_metric(self, metric: float) -> None:
"""
Record a new value of the metric and update the various things that depend on it.
"""
new_best = ((self._best_so_far is None) or
(self._should_decrease and metric < self._best_so_far) or
(not self._should_decrease and metric > self._best_so_far))
if new_best:
self.best_epoch = self._epoch_number
self._is_best_so_far = True
self._best_so_far = metric
self._epochs_with_no_improvement = 0
else:
self._is_best_so_far = False
self._epochs_with_no_improvement += 1
self._epoch_number += 1
|
[
"def",
"add_metric",
"(",
"self",
",",
"metric",
":",
"float",
")",
"->",
"None",
":",
"new_best",
"=",
"(",
"(",
"self",
".",
"_best_so_far",
"is",
"None",
")",
"or",
"(",
"self",
".",
"_should_decrease",
"and",
"metric",
"<",
"self",
".",
"_best_so_far",
")",
"or",
"(",
"not",
"self",
".",
"_should_decrease",
"and",
"metric",
">",
"self",
".",
"_best_so_far",
")",
")",
"if",
"new_best",
":",
"self",
".",
"best_epoch",
"=",
"self",
".",
"_epoch_number",
"self",
".",
"_is_best_so_far",
"=",
"True",
"self",
".",
"_best_so_far",
"=",
"metric",
"self",
".",
"_epochs_with_no_improvement",
"=",
"0",
"else",
":",
"self",
".",
"_is_best_so_far",
"=",
"False",
"self",
".",
"_epochs_with_no_improvement",
"+=",
"1",
"self",
".",
"_epoch_number",
"+=",
"1"
] |
Record a new value of the metric and update the various things that depend on it.
|
[
"Record",
"a",
"new",
"value",
"of",
"the",
"metric",
"and",
"update",
"the",
"various",
"things",
"that",
"depend",
"on",
"it",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/training/metric_tracker.py#L97-L113
|
train
|
allenai/allennlp
|
allennlp/training/metric_tracker.py
|
MetricTracker.add_metrics
|
def add_metrics(self, metrics: Iterable[float]) -> None:
"""
Helper to add multiple metrics at once.
"""
for metric in metrics:
self.add_metric(metric)
|
python
|
def add_metrics(self, metrics: Iterable[float]) -> None:
"""
Helper to add multiple metrics at once.
"""
for metric in metrics:
self.add_metric(metric)
|
[
"def",
"add_metrics",
"(",
"self",
",",
"metrics",
":",
"Iterable",
"[",
"float",
"]",
")",
"->",
"None",
":",
"for",
"metric",
"in",
"metrics",
":",
"self",
".",
"add_metric",
"(",
"metric",
")"
] |
Helper to add multiple metrics at once.
|
[
"Helper",
"to",
"add",
"multiple",
"metrics",
"at",
"once",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/training/metric_tracker.py#L115-L120
|
train
|
allenai/allennlp
|
allennlp/training/metric_tracker.py
|
MetricTracker.should_stop_early
|
def should_stop_early(self) -> bool:
"""
Returns true if improvement has stopped for long enough.
"""
if self._patience is None:
return False
else:
return self._epochs_with_no_improvement >= self._patience
|
python
|
def should_stop_early(self) -> bool:
"""
Returns true if improvement has stopped for long enough.
"""
if self._patience is None:
return False
else:
return self._epochs_with_no_improvement >= self._patience
|
[
"def",
"should_stop_early",
"(",
"self",
")",
"->",
"bool",
":",
"if",
"self",
".",
"_patience",
"is",
"None",
":",
"return",
"False",
"else",
":",
"return",
"self",
".",
"_epochs_with_no_improvement",
">=",
"self",
".",
"_patience"
] |
Returns true if improvement has stopped for long enough.
|
[
"Returns",
"true",
"if",
"improvement",
"has",
"stopped",
"for",
"long",
"enough",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/training/metric_tracker.py#L128-L135
|
train
|
allenai/allennlp
|
allennlp/models/archival.py
|
archive_model
|
def archive_model(serialization_dir: str,
weights: str = _DEFAULT_WEIGHTS,
files_to_archive: Dict[str, str] = None,
archive_path: str = None) -> None:
"""
Archive the model weights, its training configuration, and its
vocabulary to `model.tar.gz`. Include the additional ``files_to_archive``
if provided.
Parameters
----------
serialization_dir: ``str``
The directory where the weights and vocabulary are written out.
weights: ``str``, optional (default=_DEFAULT_WEIGHTS)
Which weights file to include in the archive. The default is ``best.th``.
files_to_archive: ``Dict[str, str]``, optional (default=None)
A mapping {flattened_key -> filename} of supplementary files to include
in the archive. That is, if you wanted to include ``params['model']['weights']``
then you would specify the key as `"model.weights"`.
archive_path : ``str``, optional, (default = None)
A full path to serialize the model to. The default is "model.tar.gz" inside the
serialization_dir. If you pass a directory here, we'll serialize the model
to "model.tar.gz" inside the directory.
"""
weights_file = os.path.join(serialization_dir, weights)
if not os.path.exists(weights_file):
logger.error("weights file %s does not exist, unable to archive model", weights_file)
return
config_file = os.path.join(serialization_dir, CONFIG_NAME)
if not os.path.exists(config_file):
logger.error("config file %s does not exist, unable to archive model", config_file)
# If there are files we want to archive, write out the mapping
# so that we can use it during de-archiving.
if files_to_archive:
fta_filename = os.path.join(serialization_dir, _FTA_NAME)
with open(fta_filename, 'w') as fta_file:
fta_file.write(json.dumps(files_to_archive))
if archive_path is not None:
archive_file = archive_path
if os.path.isdir(archive_file):
archive_file = os.path.join(archive_file, "model.tar.gz")
else:
archive_file = os.path.join(serialization_dir, "model.tar.gz")
logger.info("archiving weights and vocabulary to %s", archive_file)
with tarfile.open(archive_file, 'w:gz') as archive:
archive.add(config_file, arcname=CONFIG_NAME)
archive.add(weights_file, arcname=_WEIGHTS_NAME)
archive.add(os.path.join(serialization_dir, "vocabulary"),
arcname="vocabulary")
# If there are supplemental files to archive:
if files_to_archive:
# Archive the { flattened_key -> original_filename } mapping.
archive.add(fta_filename, arcname=_FTA_NAME)
# And add each requested file to the archive.
for key, filename in files_to_archive.items():
archive.add(filename, arcname=f"fta/{key}")
|
python
|
def archive_model(serialization_dir: str,
weights: str = _DEFAULT_WEIGHTS,
files_to_archive: Dict[str, str] = None,
archive_path: str = None) -> None:
"""
Archive the model weights, its training configuration, and its
vocabulary to `model.tar.gz`. Include the additional ``files_to_archive``
if provided.
Parameters
----------
serialization_dir: ``str``
The directory where the weights and vocabulary are written out.
weights: ``str``, optional (default=_DEFAULT_WEIGHTS)
Which weights file to include in the archive. The default is ``best.th``.
files_to_archive: ``Dict[str, str]``, optional (default=None)
A mapping {flattened_key -> filename} of supplementary files to include
in the archive. That is, if you wanted to include ``params['model']['weights']``
then you would specify the key as `"model.weights"`.
archive_path : ``str``, optional, (default = None)
A full path to serialize the model to. The default is "model.tar.gz" inside the
serialization_dir. If you pass a directory here, we'll serialize the model
to "model.tar.gz" inside the directory.
"""
weights_file = os.path.join(serialization_dir, weights)
if not os.path.exists(weights_file):
logger.error("weights file %s does not exist, unable to archive model", weights_file)
return
config_file = os.path.join(serialization_dir, CONFIG_NAME)
if not os.path.exists(config_file):
logger.error("config file %s does not exist, unable to archive model", config_file)
# If there are files we want to archive, write out the mapping
# so that we can use it during de-archiving.
if files_to_archive:
fta_filename = os.path.join(serialization_dir, _FTA_NAME)
with open(fta_filename, 'w') as fta_file:
fta_file.write(json.dumps(files_to_archive))
if archive_path is not None:
archive_file = archive_path
if os.path.isdir(archive_file):
archive_file = os.path.join(archive_file, "model.tar.gz")
else:
archive_file = os.path.join(serialization_dir, "model.tar.gz")
logger.info("archiving weights and vocabulary to %s", archive_file)
with tarfile.open(archive_file, 'w:gz') as archive:
archive.add(config_file, arcname=CONFIG_NAME)
archive.add(weights_file, arcname=_WEIGHTS_NAME)
archive.add(os.path.join(serialization_dir, "vocabulary"),
arcname="vocabulary")
# If there are supplemental files to archive:
if files_to_archive:
# Archive the { flattened_key -> original_filename } mapping.
archive.add(fta_filename, arcname=_FTA_NAME)
# And add each requested file to the archive.
for key, filename in files_to_archive.items():
archive.add(filename, arcname=f"fta/{key}")
|
[
"def",
"archive_model",
"(",
"serialization_dir",
":",
"str",
",",
"weights",
":",
"str",
"=",
"_DEFAULT_WEIGHTS",
",",
"files_to_archive",
":",
"Dict",
"[",
"str",
",",
"str",
"]",
"=",
"None",
",",
"archive_path",
":",
"str",
"=",
"None",
")",
"->",
"None",
":",
"weights_file",
"=",
"os",
".",
"path",
".",
"join",
"(",
"serialization_dir",
",",
"weights",
")",
"if",
"not",
"os",
".",
"path",
".",
"exists",
"(",
"weights_file",
")",
":",
"logger",
".",
"error",
"(",
"\"weights file %s does not exist, unable to archive model\"",
",",
"weights_file",
")",
"return",
"config_file",
"=",
"os",
".",
"path",
".",
"join",
"(",
"serialization_dir",
",",
"CONFIG_NAME",
")",
"if",
"not",
"os",
".",
"path",
".",
"exists",
"(",
"config_file",
")",
":",
"logger",
".",
"error",
"(",
"\"config file %s does not exist, unable to archive model\"",
",",
"config_file",
")",
"# If there are files we want to archive, write out the mapping",
"# so that we can use it during de-archiving.",
"if",
"files_to_archive",
":",
"fta_filename",
"=",
"os",
".",
"path",
".",
"join",
"(",
"serialization_dir",
",",
"_FTA_NAME",
")",
"with",
"open",
"(",
"fta_filename",
",",
"'w'",
")",
"as",
"fta_file",
":",
"fta_file",
".",
"write",
"(",
"json",
".",
"dumps",
"(",
"files_to_archive",
")",
")",
"if",
"archive_path",
"is",
"not",
"None",
":",
"archive_file",
"=",
"archive_path",
"if",
"os",
".",
"path",
".",
"isdir",
"(",
"archive_file",
")",
":",
"archive_file",
"=",
"os",
".",
"path",
".",
"join",
"(",
"archive_file",
",",
"\"model.tar.gz\"",
")",
"else",
":",
"archive_file",
"=",
"os",
".",
"path",
".",
"join",
"(",
"serialization_dir",
",",
"\"model.tar.gz\"",
")",
"logger",
".",
"info",
"(",
"\"archiving weights and vocabulary to %s\"",
",",
"archive_file",
")",
"with",
"tarfile",
".",
"open",
"(",
"archive_file",
",",
"'w:gz'",
")",
"as",
"archive",
":",
"archive",
".",
"add",
"(",
"config_file",
",",
"arcname",
"=",
"CONFIG_NAME",
")",
"archive",
".",
"add",
"(",
"weights_file",
",",
"arcname",
"=",
"_WEIGHTS_NAME",
")",
"archive",
".",
"add",
"(",
"os",
".",
"path",
".",
"join",
"(",
"serialization_dir",
",",
"\"vocabulary\"",
")",
",",
"arcname",
"=",
"\"vocabulary\"",
")",
"# If there are supplemental files to archive:",
"if",
"files_to_archive",
":",
"# Archive the { flattened_key -> original_filename } mapping.",
"archive",
".",
"add",
"(",
"fta_filename",
",",
"arcname",
"=",
"_FTA_NAME",
")",
"# And add each requested file to the archive.",
"for",
"key",
",",
"filename",
"in",
"files_to_archive",
".",
"items",
"(",
")",
":",
"archive",
".",
"add",
"(",
"filename",
",",
"arcname",
"=",
"f\"fta/{key}\"",
")"
] |
Archive the model weights, its training configuration, and its
vocabulary to `model.tar.gz`. Include the additional ``files_to_archive``
if provided.
Parameters
----------
serialization_dir: ``str``
The directory where the weights and vocabulary are written out.
weights: ``str``, optional (default=_DEFAULT_WEIGHTS)
Which weights file to include in the archive. The default is ``best.th``.
files_to_archive: ``Dict[str, str]``, optional (default=None)
A mapping {flattened_key -> filename} of supplementary files to include
in the archive. That is, if you wanted to include ``params['model']['weights']``
then you would specify the key as `"model.weights"`.
archive_path : ``str``, optional, (default = None)
A full path to serialize the model to. The default is "model.tar.gz" inside the
serialization_dir. If you pass a directory here, we'll serialize the model
to "model.tar.gz" inside the directory.
|
[
"Archive",
"the",
"model",
"weights",
"its",
"training",
"configuration",
"and",
"its",
"vocabulary",
"to",
"model",
".",
"tar",
".",
"gz",
".",
"Include",
"the",
"additional",
"files_to_archive",
"if",
"provided",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/models/archival.py#L89-L148
|
train
|
allenai/allennlp
|
allennlp/models/archival.py
|
load_archive
|
def load_archive(archive_file: str,
cuda_device: int = -1,
overrides: str = "",
weights_file: str = None) -> Archive:
"""
Instantiates an Archive from an archived `tar.gz` file.
Parameters
----------
archive_file: ``str``
The archive file to load the model from.
weights_file: ``str``, optional (default = None)
The weights file to use. If unspecified, weights.th in the archive_file will be used.
cuda_device: ``int``, optional (default = -1)
If `cuda_device` is >= 0, the model will be loaded onto the
corresponding GPU. Otherwise it will be loaded onto the CPU.
overrides: ``str``, optional (default = "")
JSON overrides to apply to the unarchived ``Params`` object.
"""
# redirect to the cache, if necessary
resolved_archive_file = cached_path(archive_file)
if resolved_archive_file == archive_file:
logger.info(f"loading archive file {archive_file}")
else:
logger.info(f"loading archive file {archive_file} from cache at {resolved_archive_file}")
if os.path.isdir(resolved_archive_file):
serialization_dir = resolved_archive_file
else:
# Extract archive to temp dir
tempdir = tempfile.mkdtemp()
logger.info(f"extracting archive file {resolved_archive_file} to temp dir {tempdir}")
with tarfile.open(resolved_archive_file, 'r:gz') as archive:
archive.extractall(tempdir)
# Postpone cleanup until exit in case the unarchived contents are needed outside
# this function.
atexit.register(_cleanup_archive_dir, tempdir)
serialization_dir = tempdir
# Check for supplemental files in archive
fta_filename = os.path.join(serialization_dir, _FTA_NAME)
if os.path.exists(fta_filename):
with open(fta_filename, 'r') as fta_file:
files_to_archive = json.loads(fta_file.read())
# Add these replacements to overrides
replacements_dict: Dict[str, Any] = {}
for key, original_filename in files_to_archive.items():
replacement_filename = os.path.join(serialization_dir, f"fta/{key}")
if os.path.exists(replacement_filename):
replacements_dict[key] = replacement_filename
else:
logger.warning(f"Archived file {replacement_filename} not found! At train time "
f"this file was located at {original_filename}. This may be "
"because you are loading a serialization directory. Attempting to "
"load the file from its train-time location.")
overrides_dict = parse_overrides(overrides)
combined_dict = with_fallback(preferred=overrides_dict, fallback=unflatten(replacements_dict))
overrides = json.dumps(combined_dict)
# Load config
config = Params.from_file(os.path.join(serialization_dir, CONFIG_NAME), overrides)
config.loading_from_archive = True
if weights_file:
weights_path = weights_file
else:
weights_path = os.path.join(serialization_dir, _WEIGHTS_NAME)
# Fallback for serialization directories.
if not os.path.exists(weights_path):
weights_path = os.path.join(serialization_dir, _DEFAULT_WEIGHTS)
# Instantiate model. Use a duplicate of the config, as it will get consumed.
model = Model.load(config.duplicate(),
weights_file=weights_path,
serialization_dir=serialization_dir,
cuda_device=cuda_device)
return Archive(model=model, config=config)
|
python
|
def load_archive(archive_file: str,
cuda_device: int = -1,
overrides: str = "",
weights_file: str = None) -> Archive:
"""
Instantiates an Archive from an archived `tar.gz` file.
Parameters
----------
archive_file: ``str``
The archive file to load the model from.
weights_file: ``str``, optional (default = None)
The weights file to use. If unspecified, weights.th in the archive_file will be used.
cuda_device: ``int``, optional (default = -1)
If `cuda_device` is >= 0, the model will be loaded onto the
corresponding GPU. Otherwise it will be loaded onto the CPU.
overrides: ``str``, optional (default = "")
JSON overrides to apply to the unarchived ``Params`` object.
"""
# redirect to the cache, if necessary
resolved_archive_file = cached_path(archive_file)
if resolved_archive_file == archive_file:
logger.info(f"loading archive file {archive_file}")
else:
logger.info(f"loading archive file {archive_file} from cache at {resolved_archive_file}")
if os.path.isdir(resolved_archive_file):
serialization_dir = resolved_archive_file
else:
# Extract archive to temp dir
tempdir = tempfile.mkdtemp()
logger.info(f"extracting archive file {resolved_archive_file} to temp dir {tempdir}")
with tarfile.open(resolved_archive_file, 'r:gz') as archive:
archive.extractall(tempdir)
# Postpone cleanup until exit in case the unarchived contents are needed outside
# this function.
atexit.register(_cleanup_archive_dir, tempdir)
serialization_dir = tempdir
# Check for supplemental files in archive
fta_filename = os.path.join(serialization_dir, _FTA_NAME)
if os.path.exists(fta_filename):
with open(fta_filename, 'r') as fta_file:
files_to_archive = json.loads(fta_file.read())
# Add these replacements to overrides
replacements_dict: Dict[str, Any] = {}
for key, original_filename in files_to_archive.items():
replacement_filename = os.path.join(serialization_dir, f"fta/{key}")
if os.path.exists(replacement_filename):
replacements_dict[key] = replacement_filename
else:
logger.warning(f"Archived file {replacement_filename} not found! At train time "
f"this file was located at {original_filename}. This may be "
"because you are loading a serialization directory. Attempting to "
"load the file from its train-time location.")
overrides_dict = parse_overrides(overrides)
combined_dict = with_fallback(preferred=overrides_dict, fallback=unflatten(replacements_dict))
overrides = json.dumps(combined_dict)
# Load config
config = Params.from_file(os.path.join(serialization_dir, CONFIG_NAME), overrides)
config.loading_from_archive = True
if weights_file:
weights_path = weights_file
else:
weights_path = os.path.join(serialization_dir, _WEIGHTS_NAME)
# Fallback for serialization directories.
if not os.path.exists(weights_path):
weights_path = os.path.join(serialization_dir, _DEFAULT_WEIGHTS)
# Instantiate model. Use a duplicate of the config, as it will get consumed.
model = Model.load(config.duplicate(),
weights_file=weights_path,
serialization_dir=serialization_dir,
cuda_device=cuda_device)
return Archive(model=model, config=config)
|
[
"def",
"load_archive",
"(",
"archive_file",
":",
"str",
",",
"cuda_device",
":",
"int",
"=",
"-",
"1",
",",
"overrides",
":",
"str",
"=",
"\"\"",
",",
"weights_file",
":",
"str",
"=",
"None",
")",
"->",
"Archive",
":",
"# redirect to the cache, if necessary",
"resolved_archive_file",
"=",
"cached_path",
"(",
"archive_file",
")",
"if",
"resolved_archive_file",
"==",
"archive_file",
":",
"logger",
".",
"info",
"(",
"f\"loading archive file {archive_file}\"",
")",
"else",
":",
"logger",
".",
"info",
"(",
"f\"loading archive file {archive_file} from cache at {resolved_archive_file}\"",
")",
"if",
"os",
".",
"path",
".",
"isdir",
"(",
"resolved_archive_file",
")",
":",
"serialization_dir",
"=",
"resolved_archive_file",
"else",
":",
"# Extract archive to temp dir",
"tempdir",
"=",
"tempfile",
".",
"mkdtemp",
"(",
")",
"logger",
".",
"info",
"(",
"f\"extracting archive file {resolved_archive_file} to temp dir {tempdir}\"",
")",
"with",
"tarfile",
".",
"open",
"(",
"resolved_archive_file",
",",
"'r:gz'",
")",
"as",
"archive",
":",
"archive",
".",
"extractall",
"(",
"tempdir",
")",
"# Postpone cleanup until exit in case the unarchived contents are needed outside",
"# this function.",
"atexit",
".",
"register",
"(",
"_cleanup_archive_dir",
",",
"tempdir",
")",
"serialization_dir",
"=",
"tempdir",
"# Check for supplemental files in archive",
"fta_filename",
"=",
"os",
".",
"path",
".",
"join",
"(",
"serialization_dir",
",",
"_FTA_NAME",
")",
"if",
"os",
".",
"path",
".",
"exists",
"(",
"fta_filename",
")",
":",
"with",
"open",
"(",
"fta_filename",
",",
"'r'",
")",
"as",
"fta_file",
":",
"files_to_archive",
"=",
"json",
".",
"loads",
"(",
"fta_file",
".",
"read",
"(",
")",
")",
"# Add these replacements to overrides",
"replacements_dict",
":",
"Dict",
"[",
"str",
",",
"Any",
"]",
"=",
"{",
"}",
"for",
"key",
",",
"original_filename",
"in",
"files_to_archive",
".",
"items",
"(",
")",
":",
"replacement_filename",
"=",
"os",
".",
"path",
".",
"join",
"(",
"serialization_dir",
",",
"f\"fta/{key}\"",
")",
"if",
"os",
".",
"path",
".",
"exists",
"(",
"replacement_filename",
")",
":",
"replacements_dict",
"[",
"key",
"]",
"=",
"replacement_filename",
"else",
":",
"logger",
".",
"warning",
"(",
"f\"Archived file {replacement_filename} not found! At train time \"",
"f\"this file was located at {original_filename}. This may be \"",
"\"because you are loading a serialization directory. Attempting to \"",
"\"load the file from its train-time location.\"",
")",
"overrides_dict",
"=",
"parse_overrides",
"(",
"overrides",
")",
"combined_dict",
"=",
"with_fallback",
"(",
"preferred",
"=",
"overrides_dict",
",",
"fallback",
"=",
"unflatten",
"(",
"replacements_dict",
")",
")",
"overrides",
"=",
"json",
".",
"dumps",
"(",
"combined_dict",
")",
"# Load config",
"config",
"=",
"Params",
".",
"from_file",
"(",
"os",
".",
"path",
".",
"join",
"(",
"serialization_dir",
",",
"CONFIG_NAME",
")",
",",
"overrides",
")",
"config",
".",
"loading_from_archive",
"=",
"True",
"if",
"weights_file",
":",
"weights_path",
"=",
"weights_file",
"else",
":",
"weights_path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"serialization_dir",
",",
"_WEIGHTS_NAME",
")",
"# Fallback for serialization directories.",
"if",
"not",
"os",
".",
"path",
".",
"exists",
"(",
"weights_path",
")",
":",
"weights_path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"serialization_dir",
",",
"_DEFAULT_WEIGHTS",
")",
"# Instantiate model. Use a duplicate of the config, as it will get consumed.",
"model",
"=",
"Model",
".",
"load",
"(",
"config",
".",
"duplicate",
"(",
")",
",",
"weights_file",
"=",
"weights_path",
",",
"serialization_dir",
"=",
"serialization_dir",
",",
"cuda_device",
"=",
"cuda_device",
")",
"return",
"Archive",
"(",
"model",
"=",
"model",
",",
"config",
"=",
"config",
")"
] |
Instantiates an Archive from an archived `tar.gz` file.
Parameters
----------
archive_file: ``str``
The archive file to load the model from.
weights_file: ``str``, optional (default = None)
The weights file to use. If unspecified, weights.th in the archive_file will be used.
cuda_device: ``int``, optional (default = -1)
If `cuda_device` is >= 0, the model will be loaded onto the
corresponding GPU. Otherwise it will be loaded onto the CPU.
overrides: ``str``, optional (default = "")
JSON overrides to apply to the unarchived ``Params`` object.
|
[
"Instantiates",
"an",
"Archive",
"from",
"an",
"archived",
"tar",
".",
"gz",
"file",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/models/archival.py#L150-L232
|
train
|
allenai/allennlp
|
allennlp/models/archival.py
|
Archive.extract_module
|
def extract_module(self, path: str, freeze: bool = True) -> Module:
"""
This method can be used to load a module from the pretrained model archive.
It is also used implicitly in FromParams based construction. So instead of using standard
params to construct a module, you can instead load a pretrained module from the model
archive directly. For eg, instead of using params like {"type": "module_type", ...}, you
can use the following template::
{
"_pretrained": {
"archive_file": "../path/to/model.tar.gz",
"path": "path.to.module.in.model",
"freeze": False
}
}
If you use this feature with FromParams, take care of the following caveat: Call to
initializer(self) at end of model initializer can potentially wipe the transferred parameters
by reinitializing them. This can happen if you have setup initializer regex that also
matches parameters of the transferred module. To safe-guard against this, you can either
update your initializer regex to prevent conflicting match or add extra initializer::
[
[".*transferred_module_name.*", "prevent"]]
]
Parameters
----------
path : ``str``, required
Path of target module to be loaded from the model.
Eg. "_textfield_embedder.token_embedder_tokens"
freeze : ``bool``, optional (default=True)
Whether to freeze the module parameters or not.
"""
modules_dict = {path: module for path, module in self.model.named_modules()}
module = modules_dict.get(path, None)
if not module:
raise ConfigurationError(f"You asked to transfer module at path {path} from "
f"the model {type(self.model)}. But it's not present.")
if not isinstance(module, Module):
raise ConfigurationError(f"The transferred object from model {type(self.model)} at path "
f"{path} is not a PyTorch Module.")
for parameter in module.parameters(): # type: ignore
parameter.requires_grad_(not freeze)
return module
|
python
|
def extract_module(self, path: str, freeze: bool = True) -> Module:
"""
This method can be used to load a module from the pretrained model archive.
It is also used implicitly in FromParams based construction. So instead of using standard
params to construct a module, you can instead load a pretrained module from the model
archive directly. For eg, instead of using params like {"type": "module_type", ...}, you
can use the following template::
{
"_pretrained": {
"archive_file": "../path/to/model.tar.gz",
"path": "path.to.module.in.model",
"freeze": False
}
}
If you use this feature with FromParams, take care of the following caveat: Call to
initializer(self) at end of model initializer can potentially wipe the transferred parameters
by reinitializing them. This can happen if you have setup initializer regex that also
matches parameters of the transferred module. To safe-guard against this, you can either
update your initializer regex to prevent conflicting match or add extra initializer::
[
[".*transferred_module_name.*", "prevent"]]
]
Parameters
----------
path : ``str``, required
Path of target module to be loaded from the model.
Eg. "_textfield_embedder.token_embedder_tokens"
freeze : ``bool``, optional (default=True)
Whether to freeze the module parameters or not.
"""
modules_dict = {path: module for path, module in self.model.named_modules()}
module = modules_dict.get(path, None)
if not module:
raise ConfigurationError(f"You asked to transfer module at path {path} from "
f"the model {type(self.model)}. But it's not present.")
if not isinstance(module, Module):
raise ConfigurationError(f"The transferred object from model {type(self.model)} at path "
f"{path} is not a PyTorch Module.")
for parameter in module.parameters(): # type: ignore
parameter.requires_grad_(not freeze)
return module
|
[
"def",
"extract_module",
"(",
"self",
",",
"path",
":",
"str",
",",
"freeze",
":",
"bool",
"=",
"True",
")",
"->",
"Module",
":",
"modules_dict",
"=",
"{",
"path",
":",
"module",
"for",
"path",
",",
"module",
"in",
"self",
".",
"model",
".",
"named_modules",
"(",
")",
"}",
"module",
"=",
"modules_dict",
".",
"get",
"(",
"path",
",",
"None",
")",
"if",
"not",
"module",
":",
"raise",
"ConfigurationError",
"(",
"f\"You asked to transfer module at path {path} from \"",
"f\"the model {type(self.model)}. But it's not present.\"",
")",
"if",
"not",
"isinstance",
"(",
"module",
",",
"Module",
")",
":",
"raise",
"ConfigurationError",
"(",
"f\"The transferred object from model {type(self.model)} at path \"",
"f\"{path} is not a PyTorch Module.\"",
")",
"for",
"parameter",
"in",
"module",
".",
"parameters",
"(",
")",
":",
"# type: ignore",
"parameter",
".",
"requires_grad_",
"(",
"not",
"freeze",
")",
"return",
"module"
] |
This method can be used to load a module from the pretrained model archive.
It is also used implicitly in FromParams based construction. So instead of using standard
params to construct a module, you can instead load a pretrained module from the model
archive directly. For eg, instead of using params like {"type": "module_type", ...}, you
can use the following template::
{
"_pretrained": {
"archive_file": "../path/to/model.tar.gz",
"path": "path.to.module.in.model",
"freeze": False
}
}
If you use this feature with FromParams, take care of the following caveat: Call to
initializer(self) at end of model initializer can potentially wipe the transferred parameters
by reinitializing them. This can happen if you have setup initializer regex that also
matches parameters of the transferred module. To safe-guard against this, you can either
update your initializer regex to prevent conflicting match or add extra initializer::
[
[".*transferred_module_name.*", "prevent"]]
]
Parameters
----------
path : ``str``, required
Path of target module to be loaded from the model.
Eg. "_textfield_embedder.token_embedder_tokens"
freeze : ``bool``, optional (default=True)
Whether to freeze the module parameters or not.
|
[
"This",
"method",
"can",
"be",
"used",
"to",
"load",
"a",
"module",
"from",
"the",
"pretrained",
"model",
"archive",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/models/archival.py#L28-L76
|
train
|
allenai/allennlp
|
allennlp/models/semantic_parsing/nlvr/nlvr_semantic_parser.py
|
NlvrSemanticParser._get_action_strings
|
def _get_action_strings(cls,
possible_actions: List[List[ProductionRule]],
action_indices: Dict[int, List[List[int]]]) -> List[List[List[str]]]:
"""
Takes a list of possible actions and indices of decoded actions into those possible actions
for a batch and returns sequences of action strings. We assume ``action_indices`` is a dict
mapping batch indices to k-best decoded sequence lists.
"""
all_action_strings: List[List[List[str]]] = []
batch_size = len(possible_actions)
for i in range(batch_size):
batch_actions = possible_actions[i]
batch_best_sequences = action_indices[i] if i in action_indices else []
# This will append an empty list to ``all_action_strings`` if ``batch_best_sequences``
# is empty.
action_strings = [[batch_actions[rule_id][0] for rule_id in sequence]
for sequence in batch_best_sequences]
all_action_strings.append(action_strings)
return all_action_strings
|
python
|
def _get_action_strings(cls,
possible_actions: List[List[ProductionRule]],
action_indices: Dict[int, List[List[int]]]) -> List[List[List[str]]]:
"""
Takes a list of possible actions and indices of decoded actions into those possible actions
for a batch and returns sequences of action strings. We assume ``action_indices`` is a dict
mapping batch indices to k-best decoded sequence lists.
"""
all_action_strings: List[List[List[str]]] = []
batch_size = len(possible_actions)
for i in range(batch_size):
batch_actions = possible_actions[i]
batch_best_sequences = action_indices[i] if i in action_indices else []
# This will append an empty list to ``all_action_strings`` if ``batch_best_sequences``
# is empty.
action_strings = [[batch_actions[rule_id][0] for rule_id in sequence]
for sequence in batch_best_sequences]
all_action_strings.append(action_strings)
return all_action_strings
|
[
"def",
"_get_action_strings",
"(",
"cls",
",",
"possible_actions",
":",
"List",
"[",
"List",
"[",
"ProductionRule",
"]",
"]",
",",
"action_indices",
":",
"Dict",
"[",
"int",
",",
"List",
"[",
"List",
"[",
"int",
"]",
"]",
"]",
")",
"->",
"List",
"[",
"List",
"[",
"List",
"[",
"str",
"]",
"]",
"]",
":",
"all_action_strings",
":",
"List",
"[",
"List",
"[",
"List",
"[",
"str",
"]",
"]",
"]",
"=",
"[",
"]",
"batch_size",
"=",
"len",
"(",
"possible_actions",
")",
"for",
"i",
"in",
"range",
"(",
"batch_size",
")",
":",
"batch_actions",
"=",
"possible_actions",
"[",
"i",
"]",
"batch_best_sequences",
"=",
"action_indices",
"[",
"i",
"]",
"if",
"i",
"in",
"action_indices",
"else",
"[",
"]",
"# This will append an empty list to ``all_action_strings`` if ``batch_best_sequences``",
"# is empty.",
"action_strings",
"=",
"[",
"[",
"batch_actions",
"[",
"rule_id",
"]",
"[",
"0",
"]",
"for",
"rule_id",
"in",
"sequence",
"]",
"for",
"sequence",
"in",
"batch_best_sequences",
"]",
"all_action_strings",
".",
"append",
"(",
"action_strings",
")",
"return",
"all_action_strings"
] |
Takes a list of possible actions and indices of decoded actions into those possible actions
for a batch and returns sequences of action strings. We assume ``action_indices`` is a dict
mapping batch indices to k-best decoded sequence lists.
|
[
"Takes",
"a",
"list",
"of",
"possible",
"actions",
"and",
"indices",
"of",
"decoded",
"actions",
"into",
"those",
"possible",
"actions",
"for",
"a",
"batch",
"and",
"returns",
"sequences",
"of",
"action",
"strings",
".",
"We",
"assume",
"action_indices",
"is",
"a",
"dict",
"mapping",
"batch",
"indices",
"to",
"k",
"-",
"best",
"decoded",
"sequence",
"lists",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/models/semantic_parsing/nlvr/nlvr_semantic_parser.py#L122-L140
|
train
|
allenai/allennlp
|
allennlp/models/semantic_parsing/nlvr/nlvr_semantic_parser.py
|
NlvrSemanticParser.decode
|
def decode(self, output_dict: Dict[str, torch.Tensor]) -> Dict[str, torch.Tensor]:
"""
This method overrides ``Model.decode``, which gets called after ``Model.forward``, at test
time, to finalize predictions. We only transform the action string sequences into logical
forms here.
"""
best_action_strings = output_dict["best_action_strings"]
# Instantiating an empty world for getting logical forms.
world = NlvrLanguage(set())
logical_forms = []
for instance_action_sequences in best_action_strings:
instance_logical_forms = []
for action_strings in instance_action_sequences:
if action_strings:
instance_logical_forms.append(world.action_sequence_to_logical_form(action_strings))
else:
instance_logical_forms.append('')
logical_forms.append(instance_logical_forms)
action_mapping = output_dict['action_mapping']
best_actions = output_dict['best_action_strings']
debug_infos = output_dict['debug_info']
batch_action_info = []
for batch_index, (predicted_actions, debug_info) in enumerate(zip(best_actions, debug_infos)):
instance_action_info = []
for predicted_action, action_debug_info in zip(predicted_actions[0], debug_info):
action_info = {}
action_info['predicted_action'] = predicted_action
considered_actions = action_debug_info['considered_actions']
probabilities = action_debug_info['probabilities']
actions = []
for action, probability in zip(considered_actions, probabilities):
if action != -1:
actions.append((action_mapping[(batch_index, action)], probability))
actions.sort()
considered_actions, probabilities = zip(*actions)
action_info['considered_actions'] = considered_actions
action_info['action_probabilities'] = probabilities
action_info['question_attention'] = action_debug_info.get('question_attention', [])
instance_action_info.append(action_info)
batch_action_info.append(instance_action_info)
output_dict["predicted_actions"] = batch_action_info
output_dict["logical_form"] = logical_forms
return output_dict
|
python
|
def decode(self, output_dict: Dict[str, torch.Tensor]) -> Dict[str, torch.Tensor]:
"""
This method overrides ``Model.decode``, which gets called after ``Model.forward``, at test
time, to finalize predictions. We only transform the action string sequences into logical
forms here.
"""
best_action_strings = output_dict["best_action_strings"]
# Instantiating an empty world for getting logical forms.
world = NlvrLanguage(set())
logical_forms = []
for instance_action_sequences in best_action_strings:
instance_logical_forms = []
for action_strings in instance_action_sequences:
if action_strings:
instance_logical_forms.append(world.action_sequence_to_logical_form(action_strings))
else:
instance_logical_forms.append('')
logical_forms.append(instance_logical_forms)
action_mapping = output_dict['action_mapping']
best_actions = output_dict['best_action_strings']
debug_infos = output_dict['debug_info']
batch_action_info = []
for batch_index, (predicted_actions, debug_info) in enumerate(zip(best_actions, debug_infos)):
instance_action_info = []
for predicted_action, action_debug_info in zip(predicted_actions[0], debug_info):
action_info = {}
action_info['predicted_action'] = predicted_action
considered_actions = action_debug_info['considered_actions']
probabilities = action_debug_info['probabilities']
actions = []
for action, probability in zip(considered_actions, probabilities):
if action != -1:
actions.append((action_mapping[(batch_index, action)], probability))
actions.sort()
considered_actions, probabilities = zip(*actions)
action_info['considered_actions'] = considered_actions
action_info['action_probabilities'] = probabilities
action_info['question_attention'] = action_debug_info.get('question_attention', [])
instance_action_info.append(action_info)
batch_action_info.append(instance_action_info)
output_dict["predicted_actions"] = batch_action_info
output_dict["logical_form"] = logical_forms
return output_dict
|
[
"def",
"decode",
"(",
"self",
",",
"output_dict",
":",
"Dict",
"[",
"str",
",",
"torch",
".",
"Tensor",
"]",
")",
"->",
"Dict",
"[",
"str",
",",
"torch",
".",
"Tensor",
"]",
":",
"best_action_strings",
"=",
"output_dict",
"[",
"\"best_action_strings\"",
"]",
"# Instantiating an empty world for getting logical forms.",
"world",
"=",
"NlvrLanguage",
"(",
"set",
"(",
")",
")",
"logical_forms",
"=",
"[",
"]",
"for",
"instance_action_sequences",
"in",
"best_action_strings",
":",
"instance_logical_forms",
"=",
"[",
"]",
"for",
"action_strings",
"in",
"instance_action_sequences",
":",
"if",
"action_strings",
":",
"instance_logical_forms",
".",
"append",
"(",
"world",
".",
"action_sequence_to_logical_form",
"(",
"action_strings",
")",
")",
"else",
":",
"instance_logical_forms",
".",
"append",
"(",
"''",
")",
"logical_forms",
".",
"append",
"(",
"instance_logical_forms",
")",
"action_mapping",
"=",
"output_dict",
"[",
"'action_mapping'",
"]",
"best_actions",
"=",
"output_dict",
"[",
"'best_action_strings'",
"]",
"debug_infos",
"=",
"output_dict",
"[",
"'debug_info'",
"]",
"batch_action_info",
"=",
"[",
"]",
"for",
"batch_index",
",",
"(",
"predicted_actions",
",",
"debug_info",
")",
"in",
"enumerate",
"(",
"zip",
"(",
"best_actions",
",",
"debug_infos",
")",
")",
":",
"instance_action_info",
"=",
"[",
"]",
"for",
"predicted_action",
",",
"action_debug_info",
"in",
"zip",
"(",
"predicted_actions",
"[",
"0",
"]",
",",
"debug_info",
")",
":",
"action_info",
"=",
"{",
"}",
"action_info",
"[",
"'predicted_action'",
"]",
"=",
"predicted_action",
"considered_actions",
"=",
"action_debug_info",
"[",
"'considered_actions'",
"]",
"probabilities",
"=",
"action_debug_info",
"[",
"'probabilities'",
"]",
"actions",
"=",
"[",
"]",
"for",
"action",
",",
"probability",
"in",
"zip",
"(",
"considered_actions",
",",
"probabilities",
")",
":",
"if",
"action",
"!=",
"-",
"1",
":",
"actions",
".",
"append",
"(",
"(",
"action_mapping",
"[",
"(",
"batch_index",
",",
"action",
")",
"]",
",",
"probability",
")",
")",
"actions",
".",
"sort",
"(",
")",
"considered_actions",
",",
"probabilities",
"=",
"zip",
"(",
"*",
"actions",
")",
"action_info",
"[",
"'considered_actions'",
"]",
"=",
"considered_actions",
"action_info",
"[",
"'action_probabilities'",
"]",
"=",
"probabilities",
"action_info",
"[",
"'question_attention'",
"]",
"=",
"action_debug_info",
".",
"get",
"(",
"'question_attention'",
",",
"[",
"]",
")",
"instance_action_info",
".",
"append",
"(",
"action_info",
")",
"batch_action_info",
".",
"append",
"(",
"instance_action_info",
")",
"output_dict",
"[",
"\"predicted_actions\"",
"]",
"=",
"batch_action_info",
"output_dict",
"[",
"\"logical_form\"",
"]",
"=",
"logical_forms",
"return",
"output_dict"
] |
This method overrides ``Model.decode``, which gets called after ``Model.forward``, at test
time, to finalize predictions. We only transform the action string sequences into logical
forms here.
|
[
"This",
"method",
"overrides",
"Model",
".",
"decode",
"which",
"gets",
"called",
"after",
"Model",
".",
"forward",
"at",
"test",
"time",
"to",
"finalize",
"predictions",
".",
"We",
"only",
"transform",
"the",
"action",
"string",
"sequences",
"into",
"logical",
"forms",
"here",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/models/semantic_parsing/nlvr/nlvr_semantic_parser.py#L201-L244
|
train
|
allenai/allennlp
|
allennlp/models/semantic_parsing/nlvr/nlvr_semantic_parser.py
|
NlvrSemanticParser._check_state_denotations
|
def _check_state_denotations(self, state: GrammarBasedState, worlds: List[NlvrLanguage]) -> List[bool]:
"""
Returns whether action history in the state evaluates to the correct denotations over all
worlds. Only defined when the state is finished.
"""
assert state.is_finished(), "Cannot compute denotations for unfinished states!"
# Since this is a finished state, its group size must be 1.
batch_index = state.batch_indices[0]
instance_label_strings = state.extras[batch_index]
history = state.action_history[0]
all_actions = state.possible_actions[0]
action_sequence = [all_actions[action][0] for action in history]
return self._check_denotation(action_sequence, instance_label_strings, worlds)
|
python
|
def _check_state_denotations(self, state: GrammarBasedState, worlds: List[NlvrLanguage]) -> List[bool]:
"""
Returns whether action history in the state evaluates to the correct denotations over all
worlds. Only defined when the state is finished.
"""
assert state.is_finished(), "Cannot compute denotations for unfinished states!"
# Since this is a finished state, its group size must be 1.
batch_index = state.batch_indices[0]
instance_label_strings = state.extras[batch_index]
history = state.action_history[0]
all_actions = state.possible_actions[0]
action_sequence = [all_actions[action][0] for action in history]
return self._check_denotation(action_sequence, instance_label_strings, worlds)
|
[
"def",
"_check_state_denotations",
"(",
"self",
",",
"state",
":",
"GrammarBasedState",
",",
"worlds",
":",
"List",
"[",
"NlvrLanguage",
"]",
")",
"->",
"List",
"[",
"bool",
"]",
":",
"assert",
"state",
".",
"is_finished",
"(",
")",
",",
"\"Cannot compute denotations for unfinished states!\"",
"# Since this is a finished state, its group size must be 1.",
"batch_index",
"=",
"state",
".",
"batch_indices",
"[",
"0",
"]",
"instance_label_strings",
"=",
"state",
".",
"extras",
"[",
"batch_index",
"]",
"history",
"=",
"state",
".",
"action_history",
"[",
"0",
"]",
"all_actions",
"=",
"state",
".",
"possible_actions",
"[",
"0",
"]",
"action_sequence",
"=",
"[",
"all_actions",
"[",
"action",
"]",
"[",
"0",
"]",
"for",
"action",
"in",
"history",
"]",
"return",
"self",
".",
"_check_denotation",
"(",
"action_sequence",
",",
"instance_label_strings",
",",
"worlds",
")"
] |
Returns whether action history in the state evaluates to the correct denotations over all
worlds. Only defined when the state is finished.
|
[
"Returns",
"whether",
"action",
"history",
"in",
"the",
"state",
"evaluates",
"to",
"the",
"correct",
"denotations",
"over",
"all",
"worlds",
".",
"Only",
"defined",
"when",
"the",
"state",
"is",
"finished",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/models/semantic_parsing/nlvr/nlvr_semantic_parser.py#L246-L258
|
train
|
allenai/allennlp
|
allennlp/commands/find_learning_rate.py
|
find_learning_rate_from_args
|
def find_learning_rate_from_args(args: argparse.Namespace) -> None:
"""
Start learning rate finder for given args
"""
params = Params.from_file(args.param_path, args.overrides)
find_learning_rate_model(params, args.serialization_dir,
start_lr=args.start_lr,
end_lr=args.end_lr,
num_batches=args.num_batches,
linear_steps=args.linear,
stopping_factor=args.stopping_factor,
force=args.force)
|
python
|
def find_learning_rate_from_args(args: argparse.Namespace) -> None:
"""
Start learning rate finder for given args
"""
params = Params.from_file(args.param_path, args.overrides)
find_learning_rate_model(params, args.serialization_dir,
start_lr=args.start_lr,
end_lr=args.end_lr,
num_batches=args.num_batches,
linear_steps=args.linear,
stopping_factor=args.stopping_factor,
force=args.force)
|
[
"def",
"find_learning_rate_from_args",
"(",
"args",
":",
"argparse",
".",
"Namespace",
")",
"->",
"None",
":",
"params",
"=",
"Params",
".",
"from_file",
"(",
"args",
".",
"param_path",
",",
"args",
".",
"overrides",
")",
"find_learning_rate_model",
"(",
"params",
",",
"args",
".",
"serialization_dir",
",",
"start_lr",
"=",
"args",
".",
"start_lr",
",",
"end_lr",
"=",
"args",
".",
"end_lr",
",",
"num_batches",
"=",
"args",
".",
"num_batches",
",",
"linear_steps",
"=",
"args",
".",
"linear",
",",
"stopping_factor",
"=",
"args",
".",
"stopping_factor",
",",
"force",
"=",
"args",
".",
"force",
")"
] |
Start learning rate finder for given args
|
[
"Start",
"learning",
"rate",
"finder",
"for",
"given",
"args"
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/commands/find_learning_rate.py#L121-L132
|
train
|
allenai/allennlp
|
allennlp/commands/find_learning_rate.py
|
find_learning_rate_model
|
def find_learning_rate_model(params: Params, serialization_dir: str,
start_lr: float = 1e-5,
end_lr: float = 10,
num_batches: int = 100,
linear_steps: bool = False,
stopping_factor: float = None,
force: bool = False) -> None:
"""
Runs learning rate search for given `num_batches` and saves the results in ``serialization_dir``
Parameters
----------
params : ``Params``
A parameter object specifying an AllenNLP Experiment.
serialization_dir : ``str``
The directory in which to save results.
start_lr: ``float``
Learning rate to start the search.
end_lr: ``float``
Learning rate upto which search is done.
num_batches: ``int``
Number of mini-batches to run Learning rate finder.
linear_steps: ``bool``
Increase learning rate linearly if False exponentially.
stopping_factor: ``float``
Stop the search when the current loss exceeds the best loss recorded by
multiple of stopping factor. If ``None`` search proceeds till the ``end_lr``
force: ``bool``
If True and the serialization directory already exists, everything in it will
be removed prior to finding the learning rate.
"""
if os.path.exists(serialization_dir) and force:
shutil.rmtree(serialization_dir)
if os.path.exists(serialization_dir) and os.listdir(serialization_dir):
raise ConfigurationError(f'Serialization directory {serialization_dir} already exists and is '
f'not empty.')
else:
os.makedirs(serialization_dir, exist_ok=True)
prepare_environment(params)
cuda_device = params.params.get('trainer').get('cuda_device', -1)
check_for_gpu(cuda_device)
all_datasets = datasets_from_params(params)
datasets_for_vocab_creation = set(params.pop("datasets_for_vocab_creation", all_datasets))
for dataset in datasets_for_vocab_creation:
if dataset not in all_datasets:
raise ConfigurationError(f"invalid 'dataset_for_vocab_creation' {dataset}")
logger.info("From dataset instances, %s will be considered for vocabulary creation.",
", ".join(datasets_for_vocab_creation))
vocab = Vocabulary.from_params(
params.pop("vocabulary", {}),
(instance for key, dataset in all_datasets.items()
for instance in dataset
if key in datasets_for_vocab_creation)
)
model = Model.from_params(vocab=vocab, params=params.pop('model'))
iterator = DataIterator.from_params(params.pop("iterator"))
iterator.index_with(vocab)
train_data = all_datasets['train']
trainer_params = params.pop("trainer")
no_grad_regexes = trainer_params.pop("no_grad", ())
for name, parameter in model.named_parameters():
if any(re.search(regex, name) for regex in no_grad_regexes):
parameter.requires_grad_(False)
trainer_choice = trainer_params.pop("type", "default")
if trainer_choice != "default":
raise ConfigurationError("currently find-learning-rate only works with the default Trainer")
trainer = Trainer.from_params(model=model,
serialization_dir=serialization_dir,
iterator=iterator,
train_data=train_data,
validation_data=None,
params=trainer_params,
validation_iterator=None)
logger.info(f'Starting learning rate search from {start_lr} to {end_lr} in {num_batches} iterations.')
learning_rates, losses = search_learning_rate(trainer,
start_lr=start_lr,
end_lr=end_lr,
num_batches=num_batches,
linear_steps=linear_steps,
stopping_factor=stopping_factor)
logger.info(f'Finished learning rate search.')
losses = _smooth(losses, 0.98)
_save_plot(learning_rates, losses, os.path.join(serialization_dir, 'lr-losses.png'))
|
python
|
def find_learning_rate_model(params: Params, serialization_dir: str,
start_lr: float = 1e-5,
end_lr: float = 10,
num_batches: int = 100,
linear_steps: bool = False,
stopping_factor: float = None,
force: bool = False) -> None:
"""
Runs learning rate search for given `num_batches` and saves the results in ``serialization_dir``
Parameters
----------
params : ``Params``
A parameter object specifying an AllenNLP Experiment.
serialization_dir : ``str``
The directory in which to save results.
start_lr: ``float``
Learning rate to start the search.
end_lr: ``float``
Learning rate upto which search is done.
num_batches: ``int``
Number of mini-batches to run Learning rate finder.
linear_steps: ``bool``
Increase learning rate linearly if False exponentially.
stopping_factor: ``float``
Stop the search when the current loss exceeds the best loss recorded by
multiple of stopping factor. If ``None`` search proceeds till the ``end_lr``
force: ``bool``
If True and the serialization directory already exists, everything in it will
be removed prior to finding the learning rate.
"""
if os.path.exists(serialization_dir) and force:
shutil.rmtree(serialization_dir)
if os.path.exists(serialization_dir) and os.listdir(serialization_dir):
raise ConfigurationError(f'Serialization directory {serialization_dir} already exists and is '
f'not empty.')
else:
os.makedirs(serialization_dir, exist_ok=True)
prepare_environment(params)
cuda_device = params.params.get('trainer').get('cuda_device', -1)
check_for_gpu(cuda_device)
all_datasets = datasets_from_params(params)
datasets_for_vocab_creation = set(params.pop("datasets_for_vocab_creation", all_datasets))
for dataset in datasets_for_vocab_creation:
if dataset not in all_datasets:
raise ConfigurationError(f"invalid 'dataset_for_vocab_creation' {dataset}")
logger.info("From dataset instances, %s will be considered for vocabulary creation.",
", ".join(datasets_for_vocab_creation))
vocab = Vocabulary.from_params(
params.pop("vocabulary", {}),
(instance for key, dataset in all_datasets.items()
for instance in dataset
if key in datasets_for_vocab_creation)
)
model = Model.from_params(vocab=vocab, params=params.pop('model'))
iterator = DataIterator.from_params(params.pop("iterator"))
iterator.index_with(vocab)
train_data = all_datasets['train']
trainer_params = params.pop("trainer")
no_grad_regexes = trainer_params.pop("no_grad", ())
for name, parameter in model.named_parameters():
if any(re.search(regex, name) for regex in no_grad_regexes):
parameter.requires_grad_(False)
trainer_choice = trainer_params.pop("type", "default")
if trainer_choice != "default":
raise ConfigurationError("currently find-learning-rate only works with the default Trainer")
trainer = Trainer.from_params(model=model,
serialization_dir=serialization_dir,
iterator=iterator,
train_data=train_data,
validation_data=None,
params=trainer_params,
validation_iterator=None)
logger.info(f'Starting learning rate search from {start_lr} to {end_lr} in {num_batches} iterations.')
learning_rates, losses = search_learning_rate(trainer,
start_lr=start_lr,
end_lr=end_lr,
num_batches=num_batches,
linear_steps=linear_steps,
stopping_factor=stopping_factor)
logger.info(f'Finished learning rate search.')
losses = _smooth(losses, 0.98)
_save_plot(learning_rates, losses, os.path.join(serialization_dir, 'lr-losses.png'))
|
[
"def",
"find_learning_rate_model",
"(",
"params",
":",
"Params",
",",
"serialization_dir",
":",
"str",
",",
"start_lr",
":",
"float",
"=",
"1e-5",
",",
"end_lr",
":",
"float",
"=",
"10",
",",
"num_batches",
":",
"int",
"=",
"100",
",",
"linear_steps",
":",
"bool",
"=",
"False",
",",
"stopping_factor",
":",
"float",
"=",
"None",
",",
"force",
":",
"bool",
"=",
"False",
")",
"->",
"None",
":",
"if",
"os",
".",
"path",
".",
"exists",
"(",
"serialization_dir",
")",
"and",
"force",
":",
"shutil",
".",
"rmtree",
"(",
"serialization_dir",
")",
"if",
"os",
".",
"path",
".",
"exists",
"(",
"serialization_dir",
")",
"and",
"os",
".",
"listdir",
"(",
"serialization_dir",
")",
":",
"raise",
"ConfigurationError",
"(",
"f'Serialization directory {serialization_dir} already exists and is '",
"f'not empty.'",
")",
"else",
":",
"os",
".",
"makedirs",
"(",
"serialization_dir",
",",
"exist_ok",
"=",
"True",
")",
"prepare_environment",
"(",
"params",
")",
"cuda_device",
"=",
"params",
".",
"params",
".",
"get",
"(",
"'trainer'",
")",
".",
"get",
"(",
"'cuda_device'",
",",
"-",
"1",
")",
"check_for_gpu",
"(",
"cuda_device",
")",
"all_datasets",
"=",
"datasets_from_params",
"(",
"params",
")",
"datasets_for_vocab_creation",
"=",
"set",
"(",
"params",
".",
"pop",
"(",
"\"datasets_for_vocab_creation\"",
",",
"all_datasets",
")",
")",
"for",
"dataset",
"in",
"datasets_for_vocab_creation",
":",
"if",
"dataset",
"not",
"in",
"all_datasets",
":",
"raise",
"ConfigurationError",
"(",
"f\"invalid 'dataset_for_vocab_creation' {dataset}\"",
")",
"logger",
".",
"info",
"(",
"\"From dataset instances, %s will be considered for vocabulary creation.\"",
",",
"\", \"",
".",
"join",
"(",
"datasets_for_vocab_creation",
")",
")",
"vocab",
"=",
"Vocabulary",
".",
"from_params",
"(",
"params",
".",
"pop",
"(",
"\"vocabulary\"",
",",
"{",
"}",
")",
",",
"(",
"instance",
"for",
"key",
",",
"dataset",
"in",
"all_datasets",
".",
"items",
"(",
")",
"for",
"instance",
"in",
"dataset",
"if",
"key",
"in",
"datasets_for_vocab_creation",
")",
")",
"model",
"=",
"Model",
".",
"from_params",
"(",
"vocab",
"=",
"vocab",
",",
"params",
"=",
"params",
".",
"pop",
"(",
"'model'",
")",
")",
"iterator",
"=",
"DataIterator",
".",
"from_params",
"(",
"params",
".",
"pop",
"(",
"\"iterator\"",
")",
")",
"iterator",
".",
"index_with",
"(",
"vocab",
")",
"train_data",
"=",
"all_datasets",
"[",
"'train'",
"]",
"trainer_params",
"=",
"params",
".",
"pop",
"(",
"\"trainer\"",
")",
"no_grad_regexes",
"=",
"trainer_params",
".",
"pop",
"(",
"\"no_grad\"",
",",
"(",
")",
")",
"for",
"name",
",",
"parameter",
"in",
"model",
".",
"named_parameters",
"(",
")",
":",
"if",
"any",
"(",
"re",
".",
"search",
"(",
"regex",
",",
"name",
")",
"for",
"regex",
"in",
"no_grad_regexes",
")",
":",
"parameter",
".",
"requires_grad_",
"(",
"False",
")",
"trainer_choice",
"=",
"trainer_params",
".",
"pop",
"(",
"\"type\"",
",",
"\"default\"",
")",
"if",
"trainer_choice",
"!=",
"\"default\"",
":",
"raise",
"ConfigurationError",
"(",
"\"currently find-learning-rate only works with the default Trainer\"",
")",
"trainer",
"=",
"Trainer",
".",
"from_params",
"(",
"model",
"=",
"model",
",",
"serialization_dir",
"=",
"serialization_dir",
",",
"iterator",
"=",
"iterator",
",",
"train_data",
"=",
"train_data",
",",
"validation_data",
"=",
"None",
",",
"params",
"=",
"trainer_params",
",",
"validation_iterator",
"=",
"None",
")",
"logger",
".",
"info",
"(",
"f'Starting learning rate search from {start_lr} to {end_lr} in {num_batches} iterations.'",
")",
"learning_rates",
",",
"losses",
"=",
"search_learning_rate",
"(",
"trainer",
",",
"start_lr",
"=",
"start_lr",
",",
"end_lr",
"=",
"end_lr",
",",
"num_batches",
"=",
"num_batches",
",",
"linear_steps",
"=",
"linear_steps",
",",
"stopping_factor",
"=",
"stopping_factor",
")",
"logger",
".",
"info",
"(",
"f'Finished learning rate search.'",
")",
"losses",
"=",
"_smooth",
"(",
"losses",
",",
"0.98",
")",
"_save_plot",
"(",
"learning_rates",
",",
"losses",
",",
"os",
".",
"path",
".",
"join",
"(",
"serialization_dir",
",",
"'lr-losses.png'",
")",
")"
] |
Runs learning rate search for given `num_batches` and saves the results in ``serialization_dir``
Parameters
----------
params : ``Params``
A parameter object specifying an AllenNLP Experiment.
serialization_dir : ``str``
The directory in which to save results.
start_lr: ``float``
Learning rate to start the search.
end_lr: ``float``
Learning rate upto which search is done.
num_batches: ``int``
Number of mini-batches to run Learning rate finder.
linear_steps: ``bool``
Increase learning rate linearly if False exponentially.
stopping_factor: ``float``
Stop the search when the current loss exceeds the best loss recorded by
multiple of stopping factor. If ``None`` search proceeds till the ``end_lr``
force: ``bool``
If True and the serialization directory already exists, everything in it will
be removed prior to finding the learning rate.
|
[
"Runs",
"learning",
"rate",
"search",
"for",
"given",
"num_batches",
"and",
"saves",
"the",
"results",
"in",
"serialization_dir"
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/commands/find_learning_rate.py#L134-L229
|
train
|
allenai/allennlp
|
allennlp/commands/find_learning_rate.py
|
search_learning_rate
|
def search_learning_rate(trainer: Trainer,
start_lr: float = 1e-5,
end_lr: float = 10,
num_batches: int = 100,
linear_steps: bool = False,
stopping_factor: float = None) -> Tuple[List[float], List[float]]:
"""
Runs training loop on the model using :class:`~allennlp.training.trainer.Trainer`
increasing learning rate from ``start_lr`` to ``end_lr`` recording the losses.
Parameters
----------
trainer: :class:`~allennlp.training.trainer.Trainer`
start_lr: ``float``
The learning rate to start the search.
end_lr: ``float``
The learning rate upto which search is done.
num_batches: ``int``
Number of batches to run the learning rate finder.
linear_steps: ``bool``
Increase learning rate linearly if False exponentially.
stopping_factor: ``float``
Stop the search when the current loss exceeds the best loss recorded by
multiple of stopping factor. If ``None`` search proceeds till the ``end_lr``
Returns
-------
(learning_rates, losses): ``Tuple[List[float], List[float]]``
Returns list of learning rates and corresponding losses.
Note: The losses are recorded before applying the corresponding learning rate
"""
if num_batches <= 10:
raise ConfigurationError('The number of iterations for learning rate finder should be greater than 10.')
trainer.model.train()
num_gpus = len(trainer._cuda_devices) # pylint: disable=protected-access
raw_train_generator = trainer.iterator(trainer.train_data,
shuffle=trainer.shuffle)
train_generator = lazy_groups_of(raw_train_generator, num_gpus)
train_generator_tqdm = Tqdm.tqdm(train_generator,
total=num_batches)
learning_rates = []
losses = []
best = 1e9
if linear_steps:
lr_update_factor = (end_lr - start_lr) / num_batches
else:
lr_update_factor = (end_lr / start_lr) ** (1.0 / num_batches)
for i, batch_group in enumerate(train_generator_tqdm):
if linear_steps:
current_lr = start_lr + (lr_update_factor * i)
else:
current_lr = start_lr * (lr_update_factor ** i)
for param_group in trainer.optimizer.param_groups:
param_group['lr'] = current_lr
trainer.optimizer.zero_grad()
loss = trainer.batch_loss(batch_group, for_training=True)
loss.backward()
loss = loss.detach().cpu().item()
if stopping_factor is not None and (math.isnan(loss) or loss > stopping_factor * best):
logger.info(f'Loss ({loss}) exceeds stopping_factor * lowest recorded loss.')
break
trainer.rescale_gradients()
trainer.optimizer.step()
learning_rates.append(current_lr)
losses.append(loss)
if loss < best and i > 10:
best = loss
if i == num_batches:
break
return learning_rates, losses
|
python
|
def search_learning_rate(trainer: Trainer,
start_lr: float = 1e-5,
end_lr: float = 10,
num_batches: int = 100,
linear_steps: bool = False,
stopping_factor: float = None) -> Tuple[List[float], List[float]]:
"""
Runs training loop on the model using :class:`~allennlp.training.trainer.Trainer`
increasing learning rate from ``start_lr`` to ``end_lr`` recording the losses.
Parameters
----------
trainer: :class:`~allennlp.training.trainer.Trainer`
start_lr: ``float``
The learning rate to start the search.
end_lr: ``float``
The learning rate upto which search is done.
num_batches: ``int``
Number of batches to run the learning rate finder.
linear_steps: ``bool``
Increase learning rate linearly if False exponentially.
stopping_factor: ``float``
Stop the search when the current loss exceeds the best loss recorded by
multiple of stopping factor. If ``None`` search proceeds till the ``end_lr``
Returns
-------
(learning_rates, losses): ``Tuple[List[float], List[float]]``
Returns list of learning rates and corresponding losses.
Note: The losses are recorded before applying the corresponding learning rate
"""
if num_batches <= 10:
raise ConfigurationError('The number of iterations for learning rate finder should be greater than 10.')
trainer.model.train()
num_gpus = len(trainer._cuda_devices) # pylint: disable=protected-access
raw_train_generator = trainer.iterator(trainer.train_data,
shuffle=trainer.shuffle)
train_generator = lazy_groups_of(raw_train_generator, num_gpus)
train_generator_tqdm = Tqdm.tqdm(train_generator,
total=num_batches)
learning_rates = []
losses = []
best = 1e9
if linear_steps:
lr_update_factor = (end_lr - start_lr) / num_batches
else:
lr_update_factor = (end_lr / start_lr) ** (1.0 / num_batches)
for i, batch_group in enumerate(train_generator_tqdm):
if linear_steps:
current_lr = start_lr + (lr_update_factor * i)
else:
current_lr = start_lr * (lr_update_factor ** i)
for param_group in trainer.optimizer.param_groups:
param_group['lr'] = current_lr
trainer.optimizer.zero_grad()
loss = trainer.batch_loss(batch_group, for_training=True)
loss.backward()
loss = loss.detach().cpu().item()
if stopping_factor is not None and (math.isnan(loss) or loss > stopping_factor * best):
logger.info(f'Loss ({loss}) exceeds stopping_factor * lowest recorded loss.')
break
trainer.rescale_gradients()
trainer.optimizer.step()
learning_rates.append(current_lr)
losses.append(loss)
if loss < best and i > 10:
best = loss
if i == num_batches:
break
return learning_rates, losses
|
[
"def",
"search_learning_rate",
"(",
"trainer",
":",
"Trainer",
",",
"start_lr",
":",
"float",
"=",
"1e-5",
",",
"end_lr",
":",
"float",
"=",
"10",
",",
"num_batches",
":",
"int",
"=",
"100",
",",
"linear_steps",
":",
"bool",
"=",
"False",
",",
"stopping_factor",
":",
"float",
"=",
"None",
")",
"->",
"Tuple",
"[",
"List",
"[",
"float",
"]",
",",
"List",
"[",
"float",
"]",
"]",
":",
"if",
"num_batches",
"<=",
"10",
":",
"raise",
"ConfigurationError",
"(",
"'The number of iterations for learning rate finder should be greater than 10.'",
")",
"trainer",
".",
"model",
".",
"train",
"(",
")",
"num_gpus",
"=",
"len",
"(",
"trainer",
".",
"_cuda_devices",
")",
"# pylint: disable=protected-access",
"raw_train_generator",
"=",
"trainer",
".",
"iterator",
"(",
"trainer",
".",
"train_data",
",",
"shuffle",
"=",
"trainer",
".",
"shuffle",
")",
"train_generator",
"=",
"lazy_groups_of",
"(",
"raw_train_generator",
",",
"num_gpus",
")",
"train_generator_tqdm",
"=",
"Tqdm",
".",
"tqdm",
"(",
"train_generator",
",",
"total",
"=",
"num_batches",
")",
"learning_rates",
"=",
"[",
"]",
"losses",
"=",
"[",
"]",
"best",
"=",
"1e9",
"if",
"linear_steps",
":",
"lr_update_factor",
"=",
"(",
"end_lr",
"-",
"start_lr",
")",
"/",
"num_batches",
"else",
":",
"lr_update_factor",
"=",
"(",
"end_lr",
"/",
"start_lr",
")",
"**",
"(",
"1.0",
"/",
"num_batches",
")",
"for",
"i",
",",
"batch_group",
"in",
"enumerate",
"(",
"train_generator_tqdm",
")",
":",
"if",
"linear_steps",
":",
"current_lr",
"=",
"start_lr",
"+",
"(",
"lr_update_factor",
"*",
"i",
")",
"else",
":",
"current_lr",
"=",
"start_lr",
"*",
"(",
"lr_update_factor",
"**",
"i",
")",
"for",
"param_group",
"in",
"trainer",
".",
"optimizer",
".",
"param_groups",
":",
"param_group",
"[",
"'lr'",
"]",
"=",
"current_lr",
"trainer",
".",
"optimizer",
".",
"zero_grad",
"(",
")",
"loss",
"=",
"trainer",
".",
"batch_loss",
"(",
"batch_group",
",",
"for_training",
"=",
"True",
")",
"loss",
".",
"backward",
"(",
")",
"loss",
"=",
"loss",
".",
"detach",
"(",
")",
".",
"cpu",
"(",
")",
".",
"item",
"(",
")",
"if",
"stopping_factor",
"is",
"not",
"None",
"and",
"(",
"math",
".",
"isnan",
"(",
"loss",
")",
"or",
"loss",
">",
"stopping_factor",
"*",
"best",
")",
":",
"logger",
".",
"info",
"(",
"f'Loss ({loss}) exceeds stopping_factor * lowest recorded loss.'",
")",
"break",
"trainer",
".",
"rescale_gradients",
"(",
")",
"trainer",
".",
"optimizer",
".",
"step",
"(",
")",
"learning_rates",
".",
"append",
"(",
"current_lr",
")",
"losses",
".",
"append",
"(",
"loss",
")",
"if",
"loss",
"<",
"best",
"and",
"i",
">",
"10",
":",
"best",
"=",
"loss",
"if",
"i",
"==",
"num_batches",
":",
"break",
"return",
"learning_rates",
",",
"losses"
] |
Runs training loop on the model using :class:`~allennlp.training.trainer.Trainer`
increasing learning rate from ``start_lr`` to ``end_lr`` recording the losses.
Parameters
----------
trainer: :class:`~allennlp.training.trainer.Trainer`
start_lr: ``float``
The learning rate to start the search.
end_lr: ``float``
The learning rate upto which search is done.
num_batches: ``int``
Number of batches to run the learning rate finder.
linear_steps: ``bool``
Increase learning rate linearly if False exponentially.
stopping_factor: ``float``
Stop the search when the current loss exceeds the best loss recorded by
multiple of stopping factor. If ``None`` search proceeds till the ``end_lr``
Returns
-------
(learning_rates, losses): ``Tuple[List[float], List[float]]``
Returns list of learning rates and corresponding losses.
Note: The losses are recorded before applying the corresponding learning rate
|
[
"Runs",
"training",
"loop",
"on",
"the",
"model",
"using",
":",
"class",
":",
"~allennlp",
".",
"training",
".",
"trainer",
".",
"Trainer",
"increasing",
"learning",
"rate",
"from",
"start_lr",
"to",
"end_lr",
"recording",
"the",
"losses",
".",
"Parameters",
"----------",
"trainer",
":",
":",
"class",
":",
"~allennlp",
".",
"training",
".",
"trainer",
".",
"Trainer",
"start_lr",
":",
"float",
"The",
"learning",
"rate",
"to",
"start",
"the",
"search",
".",
"end_lr",
":",
"float",
"The",
"learning",
"rate",
"upto",
"which",
"search",
"is",
"done",
".",
"num_batches",
":",
"int",
"Number",
"of",
"batches",
"to",
"run",
"the",
"learning",
"rate",
"finder",
".",
"linear_steps",
":",
"bool",
"Increase",
"learning",
"rate",
"linearly",
"if",
"False",
"exponentially",
".",
"stopping_factor",
":",
"float",
"Stop",
"the",
"search",
"when",
"the",
"current",
"loss",
"exceeds",
"the",
"best",
"loss",
"recorded",
"by",
"multiple",
"of",
"stopping",
"factor",
".",
"If",
"None",
"search",
"proceeds",
"till",
"the",
"end_lr",
"Returns",
"-------",
"(",
"learning_rates",
"losses",
")",
":",
"Tuple",
"[",
"List",
"[",
"float",
"]",
"List",
"[",
"float",
"]]",
"Returns",
"list",
"of",
"learning",
"rates",
"and",
"corresponding",
"losses",
".",
"Note",
":",
"The",
"losses",
"are",
"recorded",
"before",
"applying",
"the",
"corresponding",
"learning",
"rate"
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/commands/find_learning_rate.py#L231-L312
|
train
|
allenai/allennlp
|
allennlp/commands/find_learning_rate.py
|
_smooth
|
def _smooth(values: List[float], beta: float) -> List[float]:
""" Exponential smoothing of values """
avg_value = 0.
smoothed = []
for i, value in enumerate(values):
avg_value = beta * avg_value + (1 - beta) * value
smoothed.append(avg_value / (1 - beta ** (i + 1)))
return smoothed
|
python
|
def _smooth(values: List[float], beta: float) -> List[float]:
""" Exponential smoothing of values """
avg_value = 0.
smoothed = []
for i, value in enumerate(values):
avg_value = beta * avg_value + (1 - beta) * value
smoothed.append(avg_value / (1 - beta ** (i + 1)))
return smoothed
|
[
"def",
"_smooth",
"(",
"values",
":",
"List",
"[",
"float",
"]",
",",
"beta",
":",
"float",
")",
"->",
"List",
"[",
"float",
"]",
":",
"avg_value",
"=",
"0.",
"smoothed",
"=",
"[",
"]",
"for",
"i",
",",
"value",
"in",
"enumerate",
"(",
"values",
")",
":",
"avg_value",
"=",
"beta",
"*",
"avg_value",
"+",
"(",
"1",
"-",
"beta",
")",
"*",
"value",
"smoothed",
".",
"append",
"(",
"avg_value",
"/",
"(",
"1",
"-",
"beta",
"**",
"(",
"i",
"+",
"1",
")",
")",
")",
"return",
"smoothed"
] |
Exponential smoothing of values
|
[
"Exponential",
"smoothing",
"of",
"values"
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/commands/find_learning_rate.py#L315-L322
|
train
|
allenai/allennlp
|
allennlp/modules/scalar_mix.py
|
ScalarMix.forward
|
def forward(self, tensors: List[torch.Tensor], # pylint: disable=arguments-differ
mask: torch.Tensor = None) -> torch.Tensor:
"""
Compute a weighted average of the ``tensors``. The input tensors an be any shape
with at least two dimensions, but must all be the same shape.
When ``do_layer_norm=True``, the ``mask`` is required input. If the ``tensors`` are
dimensioned ``(dim_0, ..., dim_{n-1}, dim_n)``, then the ``mask`` is dimensioned
``(dim_0, ..., dim_{n-1})``, as in the typical case with ``tensors`` of shape
``(batch_size, timesteps, dim)`` and ``mask`` of shape ``(batch_size, timesteps)``.
When ``do_layer_norm=False`` the ``mask`` is ignored.
"""
if len(tensors) != self.mixture_size:
raise ConfigurationError("{} tensors were passed, but the module was initialized to "
"mix {} tensors.".format(len(tensors), self.mixture_size))
def _do_layer_norm(tensor, broadcast_mask, num_elements_not_masked):
tensor_masked = tensor * broadcast_mask
mean = torch.sum(tensor_masked) / num_elements_not_masked
variance = torch.sum(((tensor_masked - mean) * broadcast_mask)**2) / num_elements_not_masked
return (tensor - mean) / torch.sqrt(variance + 1E-12)
normed_weights = torch.nn.functional.softmax(torch.cat([parameter for parameter
in self.scalar_parameters]), dim=0)
normed_weights = torch.split(normed_weights, split_size_or_sections=1)
if not self.do_layer_norm:
pieces = []
for weight, tensor in zip(normed_weights, tensors):
pieces.append(weight * tensor)
return self.gamma * sum(pieces)
else:
mask_float = mask.float()
broadcast_mask = mask_float.unsqueeze(-1)
input_dim = tensors[0].size(-1)
num_elements_not_masked = torch.sum(mask_float) * input_dim
pieces = []
for weight, tensor in zip(normed_weights, tensors):
pieces.append(weight * _do_layer_norm(tensor,
broadcast_mask, num_elements_not_masked))
return self.gamma * sum(pieces)
|
python
|
def forward(self, tensors: List[torch.Tensor], # pylint: disable=arguments-differ
mask: torch.Tensor = None) -> torch.Tensor:
"""
Compute a weighted average of the ``tensors``. The input tensors an be any shape
with at least two dimensions, but must all be the same shape.
When ``do_layer_norm=True``, the ``mask`` is required input. If the ``tensors`` are
dimensioned ``(dim_0, ..., dim_{n-1}, dim_n)``, then the ``mask`` is dimensioned
``(dim_0, ..., dim_{n-1})``, as in the typical case with ``tensors`` of shape
``(batch_size, timesteps, dim)`` and ``mask`` of shape ``(batch_size, timesteps)``.
When ``do_layer_norm=False`` the ``mask`` is ignored.
"""
if len(tensors) != self.mixture_size:
raise ConfigurationError("{} tensors were passed, but the module was initialized to "
"mix {} tensors.".format(len(tensors), self.mixture_size))
def _do_layer_norm(tensor, broadcast_mask, num_elements_not_masked):
tensor_masked = tensor * broadcast_mask
mean = torch.sum(tensor_masked) / num_elements_not_masked
variance = torch.sum(((tensor_masked - mean) * broadcast_mask)**2) / num_elements_not_masked
return (tensor - mean) / torch.sqrt(variance + 1E-12)
normed_weights = torch.nn.functional.softmax(torch.cat([parameter for parameter
in self.scalar_parameters]), dim=0)
normed_weights = torch.split(normed_weights, split_size_or_sections=1)
if not self.do_layer_norm:
pieces = []
for weight, tensor in zip(normed_weights, tensors):
pieces.append(weight * tensor)
return self.gamma * sum(pieces)
else:
mask_float = mask.float()
broadcast_mask = mask_float.unsqueeze(-1)
input_dim = tensors[0].size(-1)
num_elements_not_masked = torch.sum(mask_float) * input_dim
pieces = []
for weight, tensor in zip(normed_weights, tensors):
pieces.append(weight * _do_layer_norm(tensor,
broadcast_mask, num_elements_not_masked))
return self.gamma * sum(pieces)
|
[
"def",
"forward",
"(",
"self",
",",
"tensors",
":",
"List",
"[",
"torch",
".",
"Tensor",
"]",
",",
"# pylint: disable=arguments-differ",
"mask",
":",
"torch",
".",
"Tensor",
"=",
"None",
")",
"->",
"torch",
".",
"Tensor",
":",
"if",
"len",
"(",
"tensors",
")",
"!=",
"self",
".",
"mixture_size",
":",
"raise",
"ConfigurationError",
"(",
"\"{} tensors were passed, but the module was initialized to \"",
"\"mix {} tensors.\"",
".",
"format",
"(",
"len",
"(",
"tensors",
")",
",",
"self",
".",
"mixture_size",
")",
")",
"def",
"_do_layer_norm",
"(",
"tensor",
",",
"broadcast_mask",
",",
"num_elements_not_masked",
")",
":",
"tensor_masked",
"=",
"tensor",
"*",
"broadcast_mask",
"mean",
"=",
"torch",
".",
"sum",
"(",
"tensor_masked",
")",
"/",
"num_elements_not_masked",
"variance",
"=",
"torch",
".",
"sum",
"(",
"(",
"(",
"tensor_masked",
"-",
"mean",
")",
"*",
"broadcast_mask",
")",
"**",
"2",
")",
"/",
"num_elements_not_masked",
"return",
"(",
"tensor",
"-",
"mean",
")",
"/",
"torch",
".",
"sqrt",
"(",
"variance",
"+",
"1E-12",
")",
"normed_weights",
"=",
"torch",
".",
"nn",
".",
"functional",
".",
"softmax",
"(",
"torch",
".",
"cat",
"(",
"[",
"parameter",
"for",
"parameter",
"in",
"self",
".",
"scalar_parameters",
"]",
")",
",",
"dim",
"=",
"0",
")",
"normed_weights",
"=",
"torch",
".",
"split",
"(",
"normed_weights",
",",
"split_size_or_sections",
"=",
"1",
")",
"if",
"not",
"self",
".",
"do_layer_norm",
":",
"pieces",
"=",
"[",
"]",
"for",
"weight",
",",
"tensor",
"in",
"zip",
"(",
"normed_weights",
",",
"tensors",
")",
":",
"pieces",
".",
"append",
"(",
"weight",
"*",
"tensor",
")",
"return",
"self",
".",
"gamma",
"*",
"sum",
"(",
"pieces",
")",
"else",
":",
"mask_float",
"=",
"mask",
".",
"float",
"(",
")",
"broadcast_mask",
"=",
"mask_float",
".",
"unsqueeze",
"(",
"-",
"1",
")",
"input_dim",
"=",
"tensors",
"[",
"0",
"]",
".",
"size",
"(",
"-",
"1",
")",
"num_elements_not_masked",
"=",
"torch",
".",
"sum",
"(",
"mask_float",
")",
"*",
"input_dim",
"pieces",
"=",
"[",
"]",
"for",
"weight",
",",
"tensor",
"in",
"zip",
"(",
"normed_weights",
",",
"tensors",
")",
":",
"pieces",
".",
"append",
"(",
"weight",
"*",
"_do_layer_norm",
"(",
"tensor",
",",
"broadcast_mask",
",",
"num_elements_not_masked",
")",
")",
"return",
"self",
".",
"gamma",
"*",
"sum",
"(",
"pieces",
")"
] |
Compute a weighted average of the ``tensors``. The input tensors an be any shape
with at least two dimensions, but must all be the same shape.
When ``do_layer_norm=True``, the ``mask`` is required input. If the ``tensors`` are
dimensioned ``(dim_0, ..., dim_{n-1}, dim_n)``, then the ``mask`` is dimensioned
``(dim_0, ..., dim_{n-1})``, as in the typical case with ``tensors`` of shape
``(batch_size, timesteps, dim)`` and ``mask`` of shape ``(batch_size, timesteps)``.
When ``do_layer_norm=False`` the ``mask`` is ignored.
|
[
"Compute",
"a",
"weighted",
"average",
"of",
"the",
"tensors",
".",
"The",
"input",
"tensors",
"an",
"be",
"any",
"shape",
"with",
"at",
"least",
"two",
"dimensions",
"but",
"must",
"all",
"be",
"the",
"same",
"shape",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/modules/scalar_mix.py#L38-L81
|
train
|
allenai/allennlp
|
allennlp/semparse/domain_languages/domain_language.py
|
predicate_with_side_args
|
def predicate_with_side_args(side_arguments: List[str]) -> Callable: # pylint: disable=invalid-name
"""
Like :func:`predicate`, but used when some of the arguments to the function are meant to be
provided by the decoder or other state, instead of from the language. For example, you might
want to have a function use the decoder's attention over some input text when a terminal was
predicted. That attention won't show up in the language productions. Use this decorator, and
pass in the required state to :func:`DomainLanguage.execute_action_sequence`, if you need to
ignore some arguments when doing grammar induction.
In order for this to work out, the side arguments `must` be after any non-side arguments. This
is because we use ``*args`` to pass the non-side arguments, and ``**kwargs`` to pass the side
arguments, and python requires that ``*args`` be before ``**kwargs``.
"""
def decorator(function: Callable) -> Callable:
setattr(function, '_side_arguments', side_arguments)
return predicate(function)
return decorator
|
python
|
def predicate_with_side_args(side_arguments: List[str]) -> Callable: # pylint: disable=invalid-name
"""
Like :func:`predicate`, but used when some of the arguments to the function are meant to be
provided by the decoder or other state, instead of from the language. For example, you might
want to have a function use the decoder's attention over some input text when a terminal was
predicted. That attention won't show up in the language productions. Use this decorator, and
pass in the required state to :func:`DomainLanguage.execute_action_sequence`, if you need to
ignore some arguments when doing grammar induction.
In order for this to work out, the side arguments `must` be after any non-side arguments. This
is because we use ``*args`` to pass the non-side arguments, and ``**kwargs`` to pass the side
arguments, and python requires that ``*args`` be before ``**kwargs``.
"""
def decorator(function: Callable) -> Callable:
setattr(function, '_side_arguments', side_arguments)
return predicate(function)
return decorator
|
[
"def",
"predicate_with_side_args",
"(",
"side_arguments",
":",
"List",
"[",
"str",
"]",
")",
"->",
"Callable",
":",
"# pylint: disable=invalid-name",
"def",
"decorator",
"(",
"function",
":",
"Callable",
")",
"->",
"Callable",
":",
"setattr",
"(",
"function",
",",
"'_side_arguments'",
",",
"side_arguments",
")",
"return",
"predicate",
"(",
"function",
")",
"return",
"decorator"
] |
Like :func:`predicate`, but used when some of the arguments to the function are meant to be
provided by the decoder or other state, instead of from the language. For example, you might
want to have a function use the decoder's attention over some input text when a terminal was
predicted. That attention won't show up in the language productions. Use this decorator, and
pass in the required state to :func:`DomainLanguage.execute_action_sequence`, if you need to
ignore some arguments when doing grammar induction.
In order for this to work out, the side arguments `must` be after any non-side arguments. This
is because we use ``*args`` to pass the non-side arguments, and ``**kwargs`` to pass the side
arguments, and python requires that ``*args`` be before ``**kwargs``.
|
[
"Like",
":",
"func",
":",
"predicate",
"but",
"used",
"when",
"some",
"of",
"the",
"arguments",
"to",
"the",
"function",
"are",
"meant",
"to",
"be",
"provided",
"by",
"the",
"decoder",
"or",
"other",
"state",
"instead",
"of",
"from",
"the",
"language",
".",
"For",
"example",
"you",
"might",
"want",
"to",
"have",
"a",
"function",
"use",
"the",
"decoder",
"s",
"attention",
"over",
"some",
"input",
"text",
"when",
"a",
"terminal",
"was",
"predicted",
".",
"That",
"attention",
"won",
"t",
"show",
"up",
"in",
"the",
"language",
"productions",
".",
"Use",
"this",
"decorator",
"and",
"pass",
"in",
"the",
"required",
"state",
"to",
":",
"func",
":",
"DomainLanguage",
".",
"execute_action_sequence",
"if",
"you",
"need",
"to",
"ignore",
"some",
"arguments",
"when",
"doing",
"grammar",
"induction",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/semparse/domain_languages/domain_language.py#L182-L198
|
train
|
allenai/allennlp
|
allennlp/semparse/domain_languages/domain_language.py
|
nltk_tree_to_logical_form
|
def nltk_tree_to_logical_form(tree: Tree) -> str:
"""
Given an ``nltk.Tree`` representing the syntax tree that generates a logical form, this method
produces the actual (lisp-like) logical form, with all of the non-terminal symbols converted
into the correct number of parentheses.
This is used in the logic that converts action sequences back into logical forms. It's very
unlikely that you will need this anywhere else.
"""
# nltk.Tree actually inherits from `list`, so you use `len()` to get the number of children.
# We're going to be explicit about checking length, instead of using `if tree:`, just to avoid
# any funny business nltk might have done (e.g., it's really odd if `if tree:` evaluates to
# `False` if there's a single leaf node with no children).
if len(tree) == 0: # pylint: disable=len-as-condition
return tree.label()
if len(tree) == 1:
return tree[0].label()
return '(' + ' '.join(nltk_tree_to_logical_form(child) for child in tree) + ')'
|
python
|
def nltk_tree_to_logical_form(tree: Tree) -> str:
"""
Given an ``nltk.Tree`` representing the syntax tree that generates a logical form, this method
produces the actual (lisp-like) logical form, with all of the non-terminal symbols converted
into the correct number of parentheses.
This is used in the logic that converts action sequences back into logical forms. It's very
unlikely that you will need this anywhere else.
"""
# nltk.Tree actually inherits from `list`, so you use `len()` to get the number of children.
# We're going to be explicit about checking length, instead of using `if tree:`, just to avoid
# any funny business nltk might have done (e.g., it's really odd if `if tree:` evaluates to
# `False` if there's a single leaf node with no children).
if len(tree) == 0: # pylint: disable=len-as-condition
return tree.label()
if len(tree) == 1:
return tree[0].label()
return '(' + ' '.join(nltk_tree_to_logical_form(child) for child in tree) + ')'
|
[
"def",
"nltk_tree_to_logical_form",
"(",
"tree",
":",
"Tree",
")",
"->",
"str",
":",
"# nltk.Tree actually inherits from `list`, so you use `len()` to get the number of children.",
"# We're going to be explicit about checking length, instead of using `if tree:`, just to avoid",
"# any funny business nltk might have done (e.g., it's really odd if `if tree:` evaluates to",
"# `False` if there's a single leaf node with no children).",
"if",
"len",
"(",
"tree",
")",
"==",
"0",
":",
"# pylint: disable=len-as-condition",
"return",
"tree",
".",
"label",
"(",
")",
"if",
"len",
"(",
"tree",
")",
"==",
"1",
":",
"return",
"tree",
"[",
"0",
"]",
".",
"label",
"(",
")",
"return",
"'('",
"+",
"' '",
".",
"join",
"(",
"nltk_tree_to_logical_form",
"(",
"child",
")",
"for",
"child",
"in",
"tree",
")",
"+",
"')'"
] |
Given an ``nltk.Tree`` representing the syntax tree that generates a logical form, this method
produces the actual (lisp-like) logical form, with all of the non-terminal symbols converted
into the correct number of parentheses.
This is used in the logic that converts action sequences back into logical forms. It's very
unlikely that you will need this anywhere else.
|
[
"Given",
"an",
"nltk",
".",
"Tree",
"representing",
"the",
"syntax",
"tree",
"that",
"generates",
"a",
"logical",
"form",
"this",
"method",
"produces",
"the",
"actual",
"(",
"lisp",
"-",
"like",
")",
"logical",
"form",
"with",
"all",
"of",
"the",
"non",
"-",
"terminal",
"symbols",
"converted",
"into",
"the",
"correct",
"number",
"of",
"parentheses",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/semparse/domain_languages/domain_language.py#L201-L218
|
train
|
allenai/allennlp
|
allennlp/semparse/domain_languages/domain_language.py
|
PredicateType.get_type
|
def get_type(type_: Type) -> 'PredicateType':
"""
Converts a python ``Type`` (as you might get from a type annotation) into a
``PredicateType``. If the ``Type`` is callable, this will return a ``FunctionType``;
otherwise, it will return a ``BasicType``.
``BasicTypes`` have a single ``name`` parameter - we typically get this from
``type_.__name__``. This doesn't work for generic types (like ``List[str]``), so we handle
those specially, so that the ``name`` for the ``BasicType`` remains ``List[str]``, as you
would expect.
"""
if is_callable(type_):
callable_args = type_.__args__
argument_types = [PredicateType.get_type(t) for t in callable_args[:-1]]
return_type = PredicateType.get_type(callable_args[-1])
return FunctionType(argument_types, return_type)
elif is_generic(type_):
# This is something like List[int]. type_.__name__ doesn't do the right thing (and
# crashes in python 3.7), so we need to do some magic here.
name = get_generic_name(type_)
else:
name = type_.__name__
return BasicType(name)
|
python
|
def get_type(type_: Type) -> 'PredicateType':
"""
Converts a python ``Type`` (as you might get from a type annotation) into a
``PredicateType``. If the ``Type`` is callable, this will return a ``FunctionType``;
otherwise, it will return a ``BasicType``.
``BasicTypes`` have a single ``name`` parameter - we typically get this from
``type_.__name__``. This doesn't work for generic types (like ``List[str]``), so we handle
those specially, so that the ``name`` for the ``BasicType`` remains ``List[str]``, as you
would expect.
"""
if is_callable(type_):
callable_args = type_.__args__
argument_types = [PredicateType.get_type(t) for t in callable_args[:-1]]
return_type = PredicateType.get_type(callable_args[-1])
return FunctionType(argument_types, return_type)
elif is_generic(type_):
# This is something like List[int]. type_.__name__ doesn't do the right thing (and
# crashes in python 3.7), so we need to do some magic here.
name = get_generic_name(type_)
else:
name = type_.__name__
return BasicType(name)
|
[
"def",
"get_type",
"(",
"type_",
":",
"Type",
")",
"->",
"'PredicateType'",
":",
"if",
"is_callable",
"(",
"type_",
")",
":",
"callable_args",
"=",
"type_",
".",
"__args__",
"argument_types",
"=",
"[",
"PredicateType",
".",
"get_type",
"(",
"t",
")",
"for",
"t",
"in",
"callable_args",
"[",
":",
"-",
"1",
"]",
"]",
"return_type",
"=",
"PredicateType",
".",
"get_type",
"(",
"callable_args",
"[",
"-",
"1",
"]",
")",
"return",
"FunctionType",
"(",
"argument_types",
",",
"return_type",
")",
"elif",
"is_generic",
"(",
"type_",
")",
":",
"# This is something like List[int]. type_.__name__ doesn't do the right thing (and",
"# crashes in python 3.7), so we need to do some magic here.",
"name",
"=",
"get_generic_name",
"(",
"type_",
")",
"else",
":",
"name",
"=",
"type_",
".",
"__name__",
"return",
"BasicType",
"(",
"name",
")"
] |
Converts a python ``Type`` (as you might get from a type annotation) into a
``PredicateType``. If the ``Type`` is callable, this will return a ``FunctionType``;
otherwise, it will return a ``BasicType``.
``BasicTypes`` have a single ``name`` parameter - we typically get this from
``type_.__name__``. This doesn't work for generic types (like ``List[str]``), so we handle
those specially, so that the ``name`` for the ``BasicType`` remains ``List[str]``, as you
would expect.
|
[
"Converts",
"a",
"python",
"Type",
"(",
"as",
"you",
"might",
"get",
"from",
"a",
"type",
"annotation",
")",
"into",
"a",
"PredicateType",
".",
"If",
"the",
"Type",
"is",
"callable",
"this",
"will",
"return",
"a",
"FunctionType",
";",
"otherwise",
"it",
"will",
"return",
"a",
"BasicType",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/semparse/domain_languages/domain_language.py#L60-L82
|
train
|
allenai/allennlp
|
allennlp/semparse/domain_languages/domain_language.py
|
DomainLanguage.execute
|
def execute(self, logical_form: str):
"""Executes a logical form, using whatever predicates you have defined."""
if not hasattr(self, '_functions'):
raise RuntimeError("You must call super().__init__() in your Language constructor")
logical_form = logical_form.replace(",", " ")
expression = util.lisp_to_nested_expression(logical_form)
return self._execute_expression(expression)
|
python
|
def execute(self, logical_form: str):
"""Executes a logical form, using whatever predicates you have defined."""
if not hasattr(self, '_functions'):
raise RuntimeError("You must call super().__init__() in your Language constructor")
logical_form = logical_form.replace(",", " ")
expression = util.lisp_to_nested_expression(logical_form)
return self._execute_expression(expression)
|
[
"def",
"execute",
"(",
"self",
",",
"logical_form",
":",
"str",
")",
":",
"if",
"not",
"hasattr",
"(",
"self",
",",
"'_functions'",
")",
":",
"raise",
"RuntimeError",
"(",
"\"You must call super().__init__() in your Language constructor\"",
")",
"logical_form",
"=",
"logical_form",
".",
"replace",
"(",
"\",\"",
",",
"\" \"",
")",
"expression",
"=",
"util",
".",
"lisp_to_nested_expression",
"(",
"logical_form",
")",
"return",
"self",
".",
"_execute_expression",
"(",
"expression",
")"
] |
Executes a logical form, using whatever predicates you have defined.
|
[
"Executes",
"a",
"logical",
"form",
"using",
"whatever",
"predicates",
"you",
"have",
"defined",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/semparse/domain_languages/domain_language.py#L307-L313
|
train
|
allenai/allennlp
|
allennlp/semparse/domain_languages/domain_language.py
|
DomainLanguage.execute_action_sequence
|
def execute_action_sequence(self, action_sequence: List[str], side_arguments: List[Dict] = None):
"""
Executes the program defined by an action sequence directly, without needing the overhead
of translating to a logical form first. For any given program, :func:`execute` and this
function are equivalent, they just take different representations of the program, so you
can use whichever is more efficient.
Also, if you have state or side arguments associated with particular production rules
(e.g., the decoder's attention on an input utterance when a predicate was predicted), you
`must` use this function to execute the logical form, instead of :func:`execute`, so that
we can match the side arguments with the right functions.
"""
# We'll strip off the first action, because it doesn't matter for execution.
first_action = action_sequence[0]
left_side = first_action.split(' -> ')[0]
if left_side != '@start@':
raise ExecutionError('invalid action sequence')
remaining_side_args = side_arguments[1:] if side_arguments else None
return self._execute_sequence(action_sequence[1:], remaining_side_args)[0]
|
python
|
def execute_action_sequence(self, action_sequence: List[str], side_arguments: List[Dict] = None):
"""
Executes the program defined by an action sequence directly, without needing the overhead
of translating to a logical form first. For any given program, :func:`execute` and this
function are equivalent, they just take different representations of the program, so you
can use whichever is more efficient.
Also, if you have state or side arguments associated with particular production rules
(e.g., the decoder's attention on an input utterance when a predicate was predicted), you
`must` use this function to execute the logical form, instead of :func:`execute`, so that
we can match the side arguments with the right functions.
"""
# We'll strip off the first action, because it doesn't matter for execution.
first_action = action_sequence[0]
left_side = first_action.split(' -> ')[0]
if left_side != '@start@':
raise ExecutionError('invalid action sequence')
remaining_side_args = side_arguments[1:] if side_arguments else None
return self._execute_sequence(action_sequence[1:], remaining_side_args)[0]
|
[
"def",
"execute_action_sequence",
"(",
"self",
",",
"action_sequence",
":",
"List",
"[",
"str",
"]",
",",
"side_arguments",
":",
"List",
"[",
"Dict",
"]",
"=",
"None",
")",
":",
"# We'll strip off the first action, because it doesn't matter for execution.",
"first_action",
"=",
"action_sequence",
"[",
"0",
"]",
"left_side",
"=",
"first_action",
".",
"split",
"(",
"' -> '",
")",
"[",
"0",
"]",
"if",
"left_side",
"!=",
"'@start@'",
":",
"raise",
"ExecutionError",
"(",
"'invalid action sequence'",
")",
"remaining_side_args",
"=",
"side_arguments",
"[",
"1",
":",
"]",
"if",
"side_arguments",
"else",
"None",
"return",
"self",
".",
"_execute_sequence",
"(",
"action_sequence",
"[",
"1",
":",
"]",
",",
"remaining_side_args",
")",
"[",
"0",
"]"
] |
Executes the program defined by an action sequence directly, without needing the overhead
of translating to a logical form first. For any given program, :func:`execute` and this
function are equivalent, they just take different representations of the program, so you
can use whichever is more efficient.
Also, if you have state or side arguments associated with particular production rules
(e.g., the decoder's attention on an input utterance when a predicate was predicted), you
`must` use this function to execute the logical form, instead of :func:`execute`, so that
we can match the side arguments with the right functions.
|
[
"Executes",
"the",
"program",
"defined",
"by",
"an",
"action",
"sequence",
"directly",
"without",
"needing",
"the",
"overhead",
"of",
"translating",
"to",
"a",
"logical",
"form",
"first",
".",
"For",
"any",
"given",
"program",
":",
"func",
":",
"execute",
"and",
"this",
"function",
"are",
"equivalent",
"they",
"just",
"take",
"different",
"representations",
"of",
"the",
"program",
"so",
"you",
"can",
"use",
"whichever",
"is",
"more",
"efficient",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/semparse/domain_languages/domain_language.py#L315-L333
|
train
|
allenai/allennlp
|
allennlp/semparse/domain_languages/domain_language.py
|
DomainLanguage.get_nonterminal_productions
|
def get_nonterminal_productions(self) -> Dict[str, List[str]]:
"""
Induces a grammar from the defined collection of predicates in this language and returns
all productions in that grammar, keyed by the non-terminal they are expanding.
This includes terminal productions implied by each predicate as well as productions for the
`return type` of each defined predicate. For example, defining a "multiply" predicate adds
a "<int,int:int> -> multiply" terminal production to the grammar, and `also` a "int ->
[<int,int:int>, int, int]" non-terminal production, because I can use the "multiply"
predicate to produce an int.
"""
if not self._nonterminal_productions:
actions: Dict[str, Set[str]] = defaultdict(set)
# If you didn't give us a set of valid start types, we'll assume all types we know
# about (including functional types) are valid start types.
if self._start_types:
start_types = self._start_types
else:
start_types = set()
for type_list in self._function_types.values():
start_types.update(type_list)
for start_type in start_types:
actions[START_SYMBOL].add(f"{START_SYMBOL} -> {start_type}")
for name, function_type_list in self._function_types.items():
for function_type in function_type_list:
actions[str(function_type)].add(f"{function_type} -> {name}")
if isinstance(function_type, FunctionType):
return_type = function_type.return_type
arg_types = function_type.argument_types
right_side = f"[{function_type}, {', '.join(str(arg_type) for arg_type in arg_types)}]"
actions[str(return_type)].add(f"{return_type} -> {right_side}")
self._nonterminal_productions = {key: sorted(value) for key, value in actions.items()}
return self._nonterminal_productions
|
python
|
def get_nonterminal_productions(self) -> Dict[str, List[str]]:
"""
Induces a grammar from the defined collection of predicates in this language and returns
all productions in that grammar, keyed by the non-terminal they are expanding.
This includes terminal productions implied by each predicate as well as productions for the
`return type` of each defined predicate. For example, defining a "multiply" predicate adds
a "<int,int:int> -> multiply" terminal production to the grammar, and `also` a "int ->
[<int,int:int>, int, int]" non-terminal production, because I can use the "multiply"
predicate to produce an int.
"""
if not self._nonterminal_productions:
actions: Dict[str, Set[str]] = defaultdict(set)
# If you didn't give us a set of valid start types, we'll assume all types we know
# about (including functional types) are valid start types.
if self._start_types:
start_types = self._start_types
else:
start_types = set()
for type_list in self._function_types.values():
start_types.update(type_list)
for start_type in start_types:
actions[START_SYMBOL].add(f"{START_SYMBOL} -> {start_type}")
for name, function_type_list in self._function_types.items():
for function_type in function_type_list:
actions[str(function_type)].add(f"{function_type} -> {name}")
if isinstance(function_type, FunctionType):
return_type = function_type.return_type
arg_types = function_type.argument_types
right_side = f"[{function_type}, {', '.join(str(arg_type) for arg_type in arg_types)}]"
actions[str(return_type)].add(f"{return_type} -> {right_side}")
self._nonterminal_productions = {key: sorted(value) for key, value in actions.items()}
return self._nonterminal_productions
|
[
"def",
"get_nonterminal_productions",
"(",
"self",
")",
"->",
"Dict",
"[",
"str",
",",
"List",
"[",
"str",
"]",
"]",
":",
"if",
"not",
"self",
".",
"_nonterminal_productions",
":",
"actions",
":",
"Dict",
"[",
"str",
",",
"Set",
"[",
"str",
"]",
"]",
"=",
"defaultdict",
"(",
"set",
")",
"# If you didn't give us a set of valid start types, we'll assume all types we know",
"# about (including functional types) are valid start types.",
"if",
"self",
".",
"_start_types",
":",
"start_types",
"=",
"self",
".",
"_start_types",
"else",
":",
"start_types",
"=",
"set",
"(",
")",
"for",
"type_list",
"in",
"self",
".",
"_function_types",
".",
"values",
"(",
")",
":",
"start_types",
".",
"update",
"(",
"type_list",
")",
"for",
"start_type",
"in",
"start_types",
":",
"actions",
"[",
"START_SYMBOL",
"]",
".",
"add",
"(",
"f\"{START_SYMBOL} -> {start_type}\"",
")",
"for",
"name",
",",
"function_type_list",
"in",
"self",
".",
"_function_types",
".",
"items",
"(",
")",
":",
"for",
"function_type",
"in",
"function_type_list",
":",
"actions",
"[",
"str",
"(",
"function_type",
")",
"]",
".",
"add",
"(",
"f\"{function_type} -> {name}\"",
")",
"if",
"isinstance",
"(",
"function_type",
",",
"FunctionType",
")",
":",
"return_type",
"=",
"function_type",
".",
"return_type",
"arg_types",
"=",
"function_type",
".",
"argument_types",
"right_side",
"=",
"f\"[{function_type}, {', '.join(str(arg_type) for arg_type in arg_types)}]\"",
"actions",
"[",
"str",
"(",
"return_type",
")",
"]",
".",
"add",
"(",
"f\"{return_type} -> {right_side}\"",
")",
"self",
".",
"_nonterminal_productions",
"=",
"{",
"key",
":",
"sorted",
"(",
"value",
")",
"for",
"key",
",",
"value",
"in",
"actions",
".",
"items",
"(",
")",
"}",
"return",
"self",
".",
"_nonterminal_productions"
] |
Induces a grammar from the defined collection of predicates in this language and returns
all productions in that grammar, keyed by the non-terminal they are expanding.
This includes terminal productions implied by each predicate as well as productions for the
`return type` of each defined predicate. For example, defining a "multiply" predicate adds
a "<int,int:int> -> multiply" terminal production to the grammar, and `also` a "int ->
[<int,int:int>, int, int]" non-terminal production, because I can use the "multiply"
predicate to produce an int.
|
[
"Induces",
"a",
"grammar",
"from",
"the",
"defined",
"collection",
"of",
"predicates",
"in",
"this",
"language",
"and",
"returns",
"all",
"productions",
"in",
"that",
"grammar",
"keyed",
"by",
"the",
"non",
"-",
"terminal",
"they",
"are",
"expanding",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/semparse/domain_languages/domain_language.py#L335-L367
|
train
|
allenai/allennlp
|
allennlp/semparse/domain_languages/domain_language.py
|
DomainLanguage.all_possible_productions
|
def all_possible_productions(self) -> List[str]:
"""
Returns a sorted list of all production rules in the grammar induced by
:func:`get_nonterminal_productions`.
"""
all_actions = set()
for action_set in self.get_nonterminal_productions().values():
all_actions.update(action_set)
return sorted(all_actions)
|
python
|
def all_possible_productions(self) -> List[str]:
"""
Returns a sorted list of all production rules in the grammar induced by
:func:`get_nonterminal_productions`.
"""
all_actions = set()
for action_set in self.get_nonterminal_productions().values():
all_actions.update(action_set)
return sorted(all_actions)
|
[
"def",
"all_possible_productions",
"(",
"self",
")",
"->",
"List",
"[",
"str",
"]",
":",
"all_actions",
"=",
"set",
"(",
")",
"for",
"action_set",
"in",
"self",
".",
"get_nonterminal_productions",
"(",
")",
".",
"values",
"(",
")",
":",
"all_actions",
".",
"update",
"(",
"action_set",
")",
"return",
"sorted",
"(",
"all_actions",
")"
] |
Returns a sorted list of all production rules in the grammar induced by
:func:`get_nonterminal_productions`.
|
[
"Returns",
"a",
"sorted",
"list",
"of",
"all",
"production",
"rules",
"in",
"the",
"grammar",
"induced",
"by",
":",
"func",
":",
"get_nonterminal_productions",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/semparse/domain_languages/domain_language.py#L369-L377
|
train
|
allenai/allennlp
|
allennlp/semparse/domain_languages/domain_language.py
|
DomainLanguage.logical_form_to_action_sequence
|
def logical_form_to_action_sequence(self, logical_form: str) -> List[str]:
"""
Converts a logical form into a linearization of the production rules from its abstract
syntax tree. The linearization is top-down, depth-first.
Each production rule is formatted as "LHS -> RHS", where "LHS" is a single non-terminal
type, and RHS is either a terminal or a list of non-terminals (other possible values for
RHS in a more general context-free grammar are not produced by our grammar induction
logic).
Non-terminals are `types` in the grammar, either basic types (like ``int``, ``str``, or
some class that you define), or functional types, represented with angle brackets with a
colon separating arguments from the return type. Multi-argument functions have commas
separating their argument types. For example, ``<int:int>`` is a function that takes an
integer and returns an integer, and ``<int,int:int>`` is a function that takes two integer
arguments and returns an integer.
As an example translation from logical form to complete action sequence, the logical form
``(add 2 3)`` would be translated to ``['@start@ -> int', 'int -> [<int,int:int>, int, int]',
'<int,int:int> -> add', 'int -> 2', 'int -> 3']``.
"""
expression = util.lisp_to_nested_expression(logical_form)
try:
transitions, start_type = self._get_transitions(expression, expected_type=None)
if self._start_types and start_type not in self._start_types:
raise ParsingError(f"Expression had unallowed start type of {start_type}: {expression}")
except ParsingError:
logger.error(f'Error parsing logical form: {logical_form}')
raise
transitions.insert(0, f'@start@ -> {start_type}')
return transitions
|
python
|
def logical_form_to_action_sequence(self, logical_form: str) -> List[str]:
"""
Converts a logical form into a linearization of the production rules from its abstract
syntax tree. The linearization is top-down, depth-first.
Each production rule is formatted as "LHS -> RHS", where "LHS" is a single non-terminal
type, and RHS is either a terminal or a list of non-terminals (other possible values for
RHS in a more general context-free grammar are not produced by our grammar induction
logic).
Non-terminals are `types` in the grammar, either basic types (like ``int``, ``str``, or
some class that you define), or functional types, represented with angle brackets with a
colon separating arguments from the return type. Multi-argument functions have commas
separating their argument types. For example, ``<int:int>`` is a function that takes an
integer and returns an integer, and ``<int,int:int>`` is a function that takes two integer
arguments and returns an integer.
As an example translation from logical form to complete action sequence, the logical form
``(add 2 3)`` would be translated to ``['@start@ -> int', 'int -> [<int,int:int>, int, int]',
'<int,int:int> -> add', 'int -> 2', 'int -> 3']``.
"""
expression = util.lisp_to_nested_expression(logical_form)
try:
transitions, start_type = self._get_transitions(expression, expected_type=None)
if self._start_types and start_type not in self._start_types:
raise ParsingError(f"Expression had unallowed start type of {start_type}: {expression}")
except ParsingError:
logger.error(f'Error parsing logical form: {logical_form}')
raise
transitions.insert(0, f'@start@ -> {start_type}')
return transitions
|
[
"def",
"logical_form_to_action_sequence",
"(",
"self",
",",
"logical_form",
":",
"str",
")",
"->",
"List",
"[",
"str",
"]",
":",
"expression",
"=",
"util",
".",
"lisp_to_nested_expression",
"(",
"logical_form",
")",
"try",
":",
"transitions",
",",
"start_type",
"=",
"self",
".",
"_get_transitions",
"(",
"expression",
",",
"expected_type",
"=",
"None",
")",
"if",
"self",
".",
"_start_types",
"and",
"start_type",
"not",
"in",
"self",
".",
"_start_types",
":",
"raise",
"ParsingError",
"(",
"f\"Expression had unallowed start type of {start_type}: {expression}\"",
")",
"except",
"ParsingError",
":",
"logger",
".",
"error",
"(",
"f'Error parsing logical form: {logical_form}'",
")",
"raise",
"transitions",
".",
"insert",
"(",
"0",
",",
"f'@start@ -> {start_type}'",
")",
"return",
"transitions"
] |
Converts a logical form into a linearization of the production rules from its abstract
syntax tree. The linearization is top-down, depth-first.
Each production rule is formatted as "LHS -> RHS", where "LHS" is a single non-terminal
type, and RHS is either a terminal or a list of non-terminals (other possible values for
RHS in a more general context-free grammar are not produced by our grammar induction
logic).
Non-terminals are `types` in the grammar, either basic types (like ``int``, ``str``, or
some class that you define), or functional types, represented with angle brackets with a
colon separating arguments from the return type. Multi-argument functions have commas
separating their argument types. For example, ``<int:int>`` is a function that takes an
integer and returns an integer, and ``<int,int:int>`` is a function that takes two integer
arguments and returns an integer.
As an example translation from logical form to complete action sequence, the logical form
``(add 2 3)`` would be translated to ``['@start@ -> int', 'int -> [<int,int:int>, int, int]',
'<int,int:int> -> add', 'int -> 2', 'int -> 3']``.
|
[
"Converts",
"a",
"logical",
"form",
"into",
"a",
"linearization",
"of",
"the",
"production",
"rules",
"from",
"its",
"abstract",
"syntax",
"tree",
".",
"The",
"linearization",
"is",
"top",
"-",
"down",
"depth",
"-",
"first",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/semparse/domain_languages/domain_language.py#L379-L409
|
train
|
allenai/allennlp
|
allennlp/semparse/domain_languages/domain_language.py
|
DomainLanguage.action_sequence_to_logical_form
|
def action_sequence_to_logical_form(self, action_sequence: List[str]) -> str:
"""
Takes an action sequence as produced by :func:`logical_form_to_action_sequence`, which is a
linearization of an abstract syntax tree, and reconstructs the logical form defined by that
abstract syntax tree.
"""
# Basic outline: we assume that the bracketing that we get in the RHS of each action is the
# correct bracketing for reconstructing the logical form. This is true when there is no
# currying in the action sequence. Given this assumption, we just need to construct a tree
# from the action sequence, then output all of the leaves in the tree, with brackets around
# the children of all non-terminal nodes.
remaining_actions = [action.split(" -> ") for action in action_sequence]
tree = Tree(remaining_actions[0][1], [])
try:
remaining_actions = self._construct_node_from_actions(tree, remaining_actions[1:])
except ParsingError:
logger.error("Error parsing action sequence: %s", action_sequence)
raise
if remaining_actions:
logger.error("Error parsing action sequence: %s", action_sequence)
logger.error("Remaining actions were: %s", remaining_actions)
raise ParsingError("Extra actions in action sequence")
return nltk_tree_to_logical_form(tree)
|
python
|
def action_sequence_to_logical_form(self, action_sequence: List[str]) -> str:
"""
Takes an action sequence as produced by :func:`logical_form_to_action_sequence`, which is a
linearization of an abstract syntax tree, and reconstructs the logical form defined by that
abstract syntax tree.
"""
# Basic outline: we assume that the bracketing that we get in the RHS of each action is the
# correct bracketing for reconstructing the logical form. This is true when there is no
# currying in the action sequence. Given this assumption, we just need to construct a tree
# from the action sequence, then output all of the leaves in the tree, with brackets around
# the children of all non-terminal nodes.
remaining_actions = [action.split(" -> ") for action in action_sequence]
tree = Tree(remaining_actions[0][1], [])
try:
remaining_actions = self._construct_node_from_actions(tree, remaining_actions[1:])
except ParsingError:
logger.error("Error parsing action sequence: %s", action_sequence)
raise
if remaining_actions:
logger.error("Error parsing action sequence: %s", action_sequence)
logger.error("Remaining actions were: %s", remaining_actions)
raise ParsingError("Extra actions in action sequence")
return nltk_tree_to_logical_form(tree)
|
[
"def",
"action_sequence_to_logical_form",
"(",
"self",
",",
"action_sequence",
":",
"List",
"[",
"str",
"]",
")",
"->",
"str",
":",
"# Basic outline: we assume that the bracketing that we get in the RHS of each action is the",
"# correct bracketing for reconstructing the logical form. This is true when there is no",
"# currying in the action sequence. Given this assumption, we just need to construct a tree",
"# from the action sequence, then output all of the leaves in the tree, with brackets around",
"# the children of all non-terminal nodes.",
"remaining_actions",
"=",
"[",
"action",
".",
"split",
"(",
"\" -> \"",
")",
"for",
"action",
"in",
"action_sequence",
"]",
"tree",
"=",
"Tree",
"(",
"remaining_actions",
"[",
"0",
"]",
"[",
"1",
"]",
",",
"[",
"]",
")",
"try",
":",
"remaining_actions",
"=",
"self",
".",
"_construct_node_from_actions",
"(",
"tree",
",",
"remaining_actions",
"[",
"1",
":",
"]",
")",
"except",
"ParsingError",
":",
"logger",
".",
"error",
"(",
"\"Error parsing action sequence: %s\"",
",",
"action_sequence",
")",
"raise",
"if",
"remaining_actions",
":",
"logger",
".",
"error",
"(",
"\"Error parsing action sequence: %s\"",
",",
"action_sequence",
")",
"logger",
".",
"error",
"(",
"\"Remaining actions were: %s\"",
",",
"remaining_actions",
")",
"raise",
"ParsingError",
"(",
"\"Extra actions in action sequence\"",
")",
"return",
"nltk_tree_to_logical_form",
"(",
"tree",
")"
] |
Takes an action sequence as produced by :func:`logical_form_to_action_sequence`, which is a
linearization of an abstract syntax tree, and reconstructs the logical form defined by that
abstract syntax tree.
|
[
"Takes",
"an",
"action",
"sequence",
"as",
"produced",
"by",
":",
"func",
":",
"logical_form_to_action_sequence",
"which",
"is",
"a",
"linearization",
"of",
"an",
"abstract",
"syntax",
"tree",
"and",
"reconstructs",
"the",
"logical",
"form",
"defined",
"by",
"that",
"abstract",
"syntax",
"tree",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/semparse/domain_languages/domain_language.py#L411-L436
|
train
|
allenai/allennlp
|
allennlp/semparse/domain_languages/domain_language.py
|
DomainLanguage.add_predicate
|
def add_predicate(self, name: str, function: Callable, side_arguments: List[str] = None):
"""
Adds a predicate to this domain language. Typically you do this with the ``@predicate``
decorator on the methods in your class. But, if you need to for whatever reason, you can
also call this function yourself with a (type-annotated) function to add it to your
language.
Parameters
----------
name : ``str``
The name that we will use in the induced language for this function.
function : ``Callable``
The function that gets called when executing a predicate with the given name.
side_arguments : ``List[str]``, optional
If given, we will ignore these arguments for the purposes of grammar induction. This
is to allow passing extra arguments from the decoder state that are not explicitly part
of the language the decoder produces, such as the decoder's attention over the question
when a terminal was predicted. If you use this functionality, you also `must` use
``language.execute_action_sequence()`` instead of ``language.execute()``, and you must
pass the additional side arguments needed to that function. See
:func:`execute_action_sequence` for more information.
"""
side_arguments = side_arguments or []
signature = inspect.signature(function)
argument_types = [param.annotation for name, param in signature.parameters.items()
if name not in side_arguments]
return_type = signature.return_annotation
argument_nltk_types: List[PredicateType] = [PredicateType.get_type(arg_type)
for arg_type in argument_types]
return_nltk_type = PredicateType.get_type(return_type)
function_nltk_type = PredicateType.get_function_type(argument_nltk_types, return_nltk_type)
self._functions[name] = function
self._function_types[name].append(function_nltk_type)
|
python
|
def add_predicate(self, name: str, function: Callable, side_arguments: List[str] = None):
"""
Adds a predicate to this domain language. Typically you do this with the ``@predicate``
decorator on the methods in your class. But, if you need to for whatever reason, you can
also call this function yourself with a (type-annotated) function to add it to your
language.
Parameters
----------
name : ``str``
The name that we will use in the induced language for this function.
function : ``Callable``
The function that gets called when executing a predicate with the given name.
side_arguments : ``List[str]``, optional
If given, we will ignore these arguments for the purposes of grammar induction. This
is to allow passing extra arguments from the decoder state that are not explicitly part
of the language the decoder produces, such as the decoder's attention over the question
when a terminal was predicted. If you use this functionality, you also `must` use
``language.execute_action_sequence()`` instead of ``language.execute()``, and you must
pass the additional side arguments needed to that function. See
:func:`execute_action_sequence` for more information.
"""
side_arguments = side_arguments or []
signature = inspect.signature(function)
argument_types = [param.annotation for name, param in signature.parameters.items()
if name not in side_arguments]
return_type = signature.return_annotation
argument_nltk_types: List[PredicateType] = [PredicateType.get_type(arg_type)
for arg_type in argument_types]
return_nltk_type = PredicateType.get_type(return_type)
function_nltk_type = PredicateType.get_function_type(argument_nltk_types, return_nltk_type)
self._functions[name] = function
self._function_types[name].append(function_nltk_type)
|
[
"def",
"add_predicate",
"(",
"self",
",",
"name",
":",
"str",
",",
"function",
":",
"Callable",
",",
"side_arguments",
":",
"List",
"[",
"str",
"]",
"=",
"None",
")",
":",
"side_arguments",
"=",
"side_arguments",
"or",
"[",
"]",
"signature",
"=",
"inspect",
".",
"signature",
"(",
"function",
")",
"argument_types",
"=",
"[",
"param",
".",
"annotation",
"for",
"name",
",",
"param",
"in",
"signature",
".",
"parameters",
".",
"items",
"(",
")",
"if",
"name",
"not",
"in",
"side_arguments",
"]",
"return_type",
"=",
"signature",
".",
"return_annotation",
"argument_nltk_types",
":",
"List",
"[",
"PredicateType",
"]",
"=",
"[",
"PredicateType",
".",
"get_type",
"(",
"arg_type",
")",
"for",
"arg_type",
"in",
"argument_types",
"]",
"return_nltk_type",
"=",
"PredicateType",
".",
"get_type",
"(",
"return_type",
")",
"function_nltk_type",
"=",
"PredicateType",
".",
"get_function_type",
"(",
"argument_nltk_types",
",",
"return_nltk_type",
")",
"self",
".",
"_functions",
"[",
"name",
"]",
"=",
"function",
"self",
".",
"_function_types",
"[",
"name",
"]",
".",
"append",
"(",
"function_nltk_type",
")"
] |
Adds a predicate to this domain language. Typically you do this with the ``@predicate``
decorator on the methods in your class. But, if you need to for whatever reason, you can
also call this function yourself with a (type-annotated) function to add it to your
language.
Parameters
----------
name : ``str``
The name that we will use in the induced language for this function.
function : ``Callable``
The function that gets called when executing a predicate with the given name.
side_arguments : ``List[str]``, optional
If given, we will ignore these arguments for the purposes of grammar induction. This
is to allow passing extra arguments from the decoder state that are not explicitly part
of the language the decoder produces, such as the decoder's attention over the question
when a terminal was predicted. If you use this functionality, you also `must` use
``language.execute_action_sequence()`` instead of ``language.execute()``, and you must
pass the additional side arguments needed to that function. See
:func:`execute_action_sequence` for more information.
|
[
"Adds",
"a",
"predicate",
"to",
"this",
"domain",
"language",
".",
"Typically",
"you",
"do",
"this",
"with",
"the",
"@predicate",
"decorator",
"on",
"the",
"methods",
"in",
"your",
"class",
".",
"But",
"if",
"you",
"need",
"to",
"for",
"whatever",
"reason",
"you",
"can",
"also",
"call",
"this",
"function",
"yourself",
"with",
"a",
"(",
"type",
"-",
"annotated",
")",
"function",
"to",
"add",
"it",
"to",
"your",
"language",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/semparse/domain_languages/domain_language.py#L438-L470
|
train
|
allenai/allennlp
|
allennlp/semparse/domain_languages/domain_language.py
|
DomainLanguage.add_constant
|
def add_constant(self, name: str, value: Any, type_: Type = None):
"""
Adds a constant to this domain language. You would typically just pass in a list of
constants to the ``super().__init__()`` call in your constructor, but you can also call
this method to add constants if it is more convenient.
Because we construct a grammar over this language for you, in order for the grammar to be
finite we cannot allow arbitrary constants. Having a finite grammar is important when
you're doing semantic parsing - we need to be able to search over this space, and compute
normalized probability distributions.
"""
value_type = type_ if type_ else type(value)
constant_type = PredicateType.get_type(value_type)
self._functions[name] = lambda: value
self._function_types[name].append(constant_type)
|
python
|
def add_constant(self, name: str, value: Any, type_: Type = None):
"""
Adds a constant to this domain language. You would typically just pass in a list of
constants to the ``super().__init__()`` call in your constructor, but you can also call
this method to add constants if it is more convenient.
Because we construct a grammar over this language for you, in order for the grammar to be
finite we cannot allow arbitrary constants. Having a finite grammar is important when
you're doing semantic parsing - we need to be able to search over this space, and compute
normalized probability distributions.
"""
value_type = type_ if type_ else type(value)
constant_type = PredicateType.get_type(value_type)
self._functions[name] = lambda: value
self._function_types[name].append(constant_type)
|
[
"def",
"add_constant",
"(",
"self",
",",
"name",
":",
"str",
",",
"value",
":",
"Any",
",",
"type_",
":",
"Type",
"=",
"None",
")",
":",
"value_type",
"=",
"type_",
"if",
"type_",
"else",
"type",
"(",
"value",
")",
"constant_type",
"=",
"PredicateType",
".",
"get_type",
"(",
"value_type",
")",
"self",
".",
"_functions",
"[",
"name",
"]",
"=",
"lambda",
":",
"value",
"self",
".",
"_function_types",
"[",
"name",
"]",
".",
"append",
"(",
"constant_type",
")"
] |
Adds a constant to this domain language. You would typically just pass in a list of
constants to the ``super().__init__()`` call in your constructor, but you can also call
this method to add constants if it is more convenient.
Because we construct a grammar over this language for you, in order for the grammar to be
finite we cannot allow arbitrary constants. Having a finite grammar is important when
you're doing semantic parsing - we need to be able to search over this space, and compute
normalized probability distributions.
|
[
"Adds",
"a",
"constant",
"to",
"this",
"domain",
"language",
".",
"You",
"would",
"typically",
"just",
"pass",
"in",
"a",
"list",
"of",
"constants",
"to",
"the",
"super",
"()",
".",
"__init__",
"()",
"call",
"in",
"your",
"constructor",
"but",
"you",
"can",
"also",
"call",
"this",
"method",
"to",
"add",
"constants",
"if",
"it",
"is",
"more",
"convenient",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/semparse/domain_languages/domain_language.py#L472-L486
|
train
|
allenai/allennlp
|
allennlp/semparse/domain_languages/domain_language.py
|
DomainLanguage.is_nonterminal
|
def is_nonterminal(self, symbol: str) -> bool:
"""
Determines whether an input symbol is a valid non-terminal in the grammar.
"""
nonterminal_productions = self.get_nonterminal_productions()
return symbol in nonterminal_productions
|
python
|
def is_nonterminal(self, symbol: str) -> bool:
"""
Determines whether an input symbol is a valid non-terminal in the grammar.
"""
nonterminal_productions = self.get_nonterminal_productions()
return symbol in nonterminal_productions
|
[
"def",
"is_nonterminal",
"(",
"self",
",",
"symbol",
":",
"str",
")",
"->",
"bool",
":",
"nonterminal_productions",
"=",
"self",
".",
"get_nonterminal_productions",
"(",
")",
"return",
"symbol",
"in",
"nonterminal_productions"
] |
Determines whether an input symbol is a valid non-terminal in the grammar.
|
[
"Determines",
"whether",
"an",
"input",
"symbol",
"is",
"a",
"valid",
"non",
"-",
"terminal",
"in",
"the",
"grammar",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/semparse/domain_languages/domain_language.py#L488-L493
|
train
|
allenai/allennlp
|
allennlp/semparse/domain_languages/domain_language.py
|
DomainLanguage._execute_expression
|
def _execute_expression(self, expression: Any):
"""
This does the bulk of the work of executing a logical form, recursively executing a single
expression. Basically, if the expression is a function we know about, we evaluate its
arguments then call the function. If it's a list, we evaluate all elements of the list.
If it's a constant (or a zero-argument function), we evaluate the constant.
"""
# pylint: disable=too-many-return-statements
if isinstance(expression, list):
if isinstance(expression[0], list):
function = self._execute_expression(expression[0])
elif expression[0] in self._functions:
function = self._functions[expression[0]]
else:
if isinstance(expression[0], str):
raise ExecutionError(f"Unrecognized function: {expression[0]}")
else:
raise ExecutionError(f"Unsupported expression type: {expression}")
arguments = [self._execute_expression(arg) for arg in expression[1:]]
try:
return function(*arguments)
except (TypeError, ValueError):
traceback.print_exc()
raise ExecutionError(f"Error executing expression {expression} (see stderr for stack trace)")
elif isinstance(expression, str):
if expression not in self._functions:
raise ExecutionError(f"Unrecognized constant: {expression}")
# This is a bit of a quirk in how we represent constants and zero-argument functions.
# For consistency, constants are wrapped in a zero-argument lambda. So both constants
# and zero-argument functions are callable in `self._functions`, and are `BasicTypes`
# in `self._function_types`. For these, we want to return
# `self._functions[expression]()` _calling_ the zero-argument function. If we get a
# `FunctionType` in here, that means we're referring to the function as a first-class
# object, instead of calling it (maybe as an argument to a higher-order function). In
# that case, we return the function _without_ calling it.
# Also, we just check the first function type here, because we assume you haven't
# registered the same function with both a constant type and a `FunctionType`.
if isinstance(self._function_types[expression][0], FunctionType):
return self._functions[expression]
else:
return self._functions[expression]()
return self._functions[expression]
else:
raise ExecutionError("Not sure how you got here. Please open a github issue with details.")
|
python
|
def _execute_expression(self, expression: Any):
"""
This does the bulk of the work of executing a logical form, recursively executing a single
expression. Basically, if the expression is a function we know about, we evaluate its
arguments then call the function. If it's a list, we evaluate all elements of the list.
If it's a constant (or a zero-argument function), we evaluate the constant.
"""
# pylint: disable=too-many-return-statements
if isinstance(expression, list):
if isinstance(expression[0], list):
function = self._execute_expression(expression[0])
elif expression[0] in self._functions:
function = self._functions[expression[0]]
else:
if isinstance(expression[0], str):
raise ExecutionError(f"Unrecognized function: {expression[0]}")
else:
raise ExecutionError(f"Unsupported expression type: {expression}")
arguments = [self._execute_expression(arg) for arg in expression[1:]]
try:
return function(*arguments)
except (TypeError, ValueError):
traceback.print_exc()
raise ExecutionError(f"Error executing expression {expression} (see stderr for stack trace)")
elif isinstance(expression, str):
if expression not in self._functions:
raise ExecutionError(f"Unrecognized constant: {expression}")
# This is a bit of a quirk in how we represent constants and zero-argument functions.
# For consistency, constants are wrapped in a zero-argument lambda. So both constants
# and zero-argument functions are callable in `self._functions`, and are `BasicTypes`
# in `self._function_types`. For these, we want to return
# `self._functions[expression]()` _calling_ the zero-argument function. If we get a
# `FunctionType` in here, that means we're referring to the function as a first-class
# object, instead of calling it (maybe as an argument to a higher-order function). In
# that case, we return the function _without_ calling it.
# Also, we just check the first function type here, because we assume you haven't
# registered the same function with both a constant type and a `FunctionType`.
if isinstance(self._function_types[expression][0], FunctionType):
return self._functions[expression]
else:
return self._functions[expression]()
return self._functions[expression]
else:
raise ExecutionError("Not sure how you got here. Please open a github issue with details.")
|
[
"def",
"_execute_expression",
"(",
"self",
",",
"expression",
":",
"Any",
")",
":",
"# pylint: disable=too-many-return-statements",
"if",
"isinstance",
"(",
"expression",
",",
"list",
")",
":",
"if",
"isinstance",
"(",
"expression",
"[",
"0",
"]",
",",
"list",
")",
":",
"function",
"=",
"self",
".",
"_execute_expression",
"(",
"expression",
"[",
"0",
"]",
")",
"elif",
"expression",
"[",
"0",
"]",
"in",
"self",
".",
"_functions",
":",
"function",
"=",
"self",
".",
"_functions",
"[",
"expression",
"[",
"0",
"]",
"]",
"else",
":",
"if",
"isinstance",
"(",
"expression",
"[",
"0",
"]",
",",
"str",
")",
":",
"raise",
"ExecutionError",
"(",
"f\"Unrecognized function: {expression[0]}\"",
")",
"else",
":",
"raise",
"ExecutionError",
"(",
"f\"Unsupported expression type: {expression}\"",
")",
"arguments",
"=",
"[",
"self",
".",
"_execute_expression",
"(",
"arg",
")",
"for",
"arg",
"in",
"expression",
"[",
"1",
":",
"]",
"]",
"try",
":",
"return",
"function",
"(",
"*",
"arguments",
")",
"except",
"(",
"TypeError",
",",
"ValueError",
")",
":",
"traceback",
".",
"print_exc",
"(",
")",
"raise",
"ExecutionError",
"(",
"f\"Error executing expression {expression} (see stderr for stack trace)\"",
")",
"elif",
"isinstance",
"(",
"expression",
",",
"str",
")",
":",
"if",
"expression",
"not",
"in",
"self",
".",
"_functions",
":",
"raise",
"ExecutionError",
"(",
"f\"Unrecognized constant: {expression}\"",
")",
"# This is a bit of a quirk in how we represent constants and zero-argument functions.",
"# For consistency, constants are wrapped in a zero-argument lambda. So both constants",
"# and zero-argument functions are callable in `self._functions`, and are `BasicTypes`",
"# in `self._function_types`. For these, we want to return",
"# `self._functions[expression]()` _calling_ the zero-argument function. If we get a",
"# `FunctionType` in here, that means we're referring to the function as a first-class",
"# object, instead of calling it (maybe as an argument to a higher-order function). In",
"# that case, we return the function _without_ calling it.",
"# Also, we just check the first function type here, because we assume you haven't",
"# registered the same function with both a constant type and a `FunctionType`.",
"if",
"isinstance",
"(",
"self",
".",
"_function_types",
"[",
"expression",
"]",
"[",
"0",
"]",
",",
"FunctionType",
")",
":",
"return",
"self",
".",
"_functions",
"[",
"expression",
"]",
"else",
":",
"return",
"self",
".",
"_functions",
"[",
"expression",
"]",
"(",
")",
"return",
"self",
".",
"_functions",
"[",
"expression",
"]",
"else",
":",
"raise",
"ExecutionError",
"(",
"\"Not sure how you got here. Please open a github issue with details.\"",
")"
] |
This does the bulk of the work of executing a logical form, recursively executing a single
expression. Basically, if the expression is a function we know about, we evaluate its
arguments then call the function. If it's a list, we evaluate all elements of the list.
If it's a constant (or a zero-argument function), we evaluate the constant.
|
[
"This",
"does",
"the",
"bulk",
"of",
"the",
"work",
"of",
"executing",
"a",
"logical",
"form",
"recursively",
"executing",
"a",
"single",
"expression",
".",
"Basically",
"if",
"the",
"expression",
"is",
"a",
"function",
"we",
"know",
"about",
"we",
"evaluate",
"its",
"arguments",
"then",
"call",
"the",
"function",
".",
"If",
"it",
"s",
"a",
"list",
"we",
"evaluate",
"all",
"elements",
"of",
"the",
"list",
".",
"If",
"it",
"s",
"a",
"constant",
"(",
"or",
"a",
"zero",
"-",
"argument",
"function",
")",
"we",
"evaluate",
"the",
"constant",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/semparse/domain_languages/domain_language.py#L496-L539
|
train
|
allenai/allennlp
|
allennlp/semparse/domain_languages/domain_language.py
|
DomainLanguage._execute_sequence
|
def _execute_sequence(self,
action_sequence: List[str],
side_arguments: List[Dict]) -> Tuple[Any, List[str], List[Dict]]:
"""
This does the bulk of the work of :func:`execute_action_sequence`, recursively executing
the functions it finds and trimming actions off of the action sequence. The return value
is a tuple of (execution, remaining_actions), where the second value is necessary to handle
the recursion.
"""
first_action = action_sequence[0]
remaining_actions = action_sequence[1:]
remaining_side_args = side_arguments[1:] if side_arguments else None
right_side = first_action.split(' -> ')[1]
if right_side in self._functions:
function = self._functions[right_side]
# mypy doesn't like this check, saying that Callable isn't a reasonable thing to pass
# here. But it works just fine; I'm not sure why mypy complains about it.
if isinstance(function, Callable): # type: ignore
function_arguments = inspect.signature(function).parameters
if not function_arguments:
# This was a zero-argument function / constant that was registered as a lambda
# function, for consistency of execution in `execute()`.
execution_value = function()
elif side_arguments:
kwargs = {}
non_kwargs = []
for argument_name in function_arguments:
if argument_name in side_arguments[0]:
kwargs[argument_name] = side_arguments[0][argument_name]
else:
non_kwargs.append(argument_name)
if kwargs and non_kwargs:
# This is a function that has both side arguments and logical form
# arguments - we curry the function so only the logical form arguments are
# left.
def curried_function(*args):
return function(*args, **kwargs)
execution_value = curried_function
elif kwargs:
# This is a function that _only_ has side arguments - we just call the
# function and return a value.
execution_value = function(**kwargs)
else:
# This is a function that has logical form arguments, but no side arguments
# that match what we were given - just return the function itself.
execution_value = function
else:
execution_value = function
return execution_value, remaining_actions, remaining_side_args
else:
# This is a non-terminal expansion, like 'int -> [<int:int>, int, int]'. We need to
# get the function and its arguments, then call the function with its arguments.
# Because we linearize the abstract syntax tree depth first, left-to-right, we can just
# recursively call `_execute_sequence` for the function and all of its arguments, and
# things will just work.
right_side_parts = right_side.split(', ')
# We don't really need to know what the types are, just how many of them there are, so
# we recurse the right number of times.
function, remaining_actions, remaining_side_args = self._execute_sequence(remaining_actions,
remaining_side_args)
arguments = []
for _ in right_side_parts[1:]:
argument, remaining_actions, remaining_side_args = self._execute_sequence(remaining_actions,
remaining_side_args)
arguments.append(argument)
return function(*arguments), remaining_actions, remaining_side_args
|
python
|
def _execute_sequence(self,
action_sequence: List[str],
side_arguments: List[Dict]) -> Tuple[Any, List[str], List[Dict]]:
"""
This does the bulk of the work of :func:`execute_action_sequence`, recursively executing
the functions it finds and trimming actions off of the action sequence. The return value
is a tuple of (execution, remaining_actions), where the second value is necessary to handle
the recursion.
"""
first_action = action_sequence[0]
remaining_actions = action_sequence[1:]
remaining_side_args = side_arguments[1:] if side_arguments else None
right_side = first_action.split(' -> ')[1]
if right_side in self._functions:
function = self._functions[right_side]
# mypy doesn't like this check, saying that Callable isn't a reasonable thing to pass
# here. But it works just fine; I'm not sure why mypy complains about it.
if isinstance(function, Callable): # type: ignore
function_arguments = inspect.signature(function).parameters
if not function_arguments:
# This was a zero-argument function / constant that was registered as a lambda
# function, for consistency of execution in `execute()`.
execution_value = function()
elif side_arguments:
kwargs = {}
non_kwargs = []
for argument_name in function_arguments:
if argument_name in side_arguments[0]:
kwargs[argument_name] = side_arguments[0][argument_name]
else:
non_kwargs.append(argument_name)
if kwargs and non_kwargs:
# This is a function that has both side arguments and logical form
# arguments - we curry the function so only the logical form arguments are
# left.
def curried_function(*args):
return function(*args, **kwargs)
execution_value = curried_function
elif kwargs:
# This is a function that _only_ has side arguments - we just call the
# function and return a value.
execution_value = function(**kwargs)
else:
# This is a function that has logical form arguments, but no side arguments
# that match what we were given - just return the function itself.
execution_value = function
else:
execution_value = function
return execution_value, remaining_actions, remaining_side_args
else:
# This is a non-terminal expansion, like 'int -> [<int:int>, int, int]'. We need to
# get the function and its arguments, then call the function with its arguments.
# Because we linearize the abstract syntax tree depth first, left-to-right, we can just
# recursively call `_execute_sequence` for the function and all of its arguments, and
# things will just work.
right_side_parts = right_side.split(', ')
# We don't really need to know what the types are, just how many of them there are, so
# we recurse the right number of times.
function, remaining_actions, remaining_side_args = self._execute_sequence(remaining_actions,
remaining_side_args)
arguments = []
for _ in right_side_parts[1:]:
argument, remaining_actions, remaining_side_args = self._execute_sequence(remaining_actions,
remaining_side_args)
arguments.append(argument)
return function(*arguments), remaining_actions, remaining_side_args
|
[
"def",
"_execute_sequence",
"(",
"self",
",",
"action_sequence",
":",
"List",
"[",
"str",
"]",
",",
"side_arguments",
":",
"List",
"[",
"Dict",
"]",
")",
"->",
"Tuple",
"[",
"Any",
",",
"List",
"[",
"str",
"]",
",",
"List",
"[",
"Dict",
"]",
"]",
":",
"first_action",
"=",
"action_sequence",
"[",
"0",
"]",
"remaining_actions",
"=",
"action_sequence",
"[",
"1",
":",
"]",
"remaining_side_args",
"=",
"side_arguments",
"[",
"1",
":",
"]",
"if",
"side_arguments",
"else",
"None",
"right_side",
"=",
"first_action",
".",
"split",
"(",
"' -> '",
")",
"[",
"1",
"]",
"if",
"right_side",
"in",
"self",
".",
"_functions",
":",
"function",
"=",
"self",
".",
"_functions",
"[",
"right_side",
"]",
"# mypy doesn't like this check, saying that Callable isn't a reasonable thing to pass",
"# here. But it works just fine; I'm not sure why mypy complains about it.",
"if",
"isinstance",
"(",
"function",
",",
"Callable",
")",
":",
"# type: ignore",
"function_arguments",
"=",
"inspect",
".",
"signature",
"(",
"function",
")",
".",
"parameters",
"if",
"not",
"function_arguments",
":",
"# This was a zero-argument function / constant that was registered as a lambda",
"# function, for consistency of execution in `execute()`.",
"execution_value",
"=",
"function",
"(",
")",
"elif",
"side_arguments",
":",
"kwargs",
"=",
"{",
"}",
"non_kwargs",
"=",
"[",
"]",
"for",
"argument_name",
"in",
"function_arguments",
":",
"if",
"argument_name",
"in",
"side_arguments",
"[",
"0",
"]",
":",
"kwargs",
"[",
"argument_name",
"]",
"=",
"side_arguments",
"[",
"0",
"]",
"[",
"argument_name",
"]",
"else",
":",
"non_kwargs",
".",
"append",
"(",
"argument_name",
")",
"if",
"kwargs",
"and",
"non_kwargs",
":",
"# This is a function that has both side arguments and logical form",
"# arguments - we curry the function so only the logical form arguments are",
"# left.",
"def",
"curried_function",
"(",
"*",
"args",
")",
":",
"return",
"function",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"execution_value",
"=",
"curried_function",
"elif",
"kwargs",
":",
"# This is a function that _only_ has side arguments - we just call the",
"# function and return a value.",
"execution_value",
"=",
"function",
"(",
"*",
"*",
"kwargs",
")",
"else",
":",
"# This is a function that has logical form arguments, but no side arguments",
"# that match what we were given - just return the function itself.",
"execution_value",
"=",
"function",
"else",
":",
"execution_value",
"=",
"function",
"return",
"execution_value",
",",
"remaining_actions",
",",
"remaining_side_args",
"else",
":",
"# This is a non-terminal expansion, like 'int -> [<int:int>, int, int]'. We need to",
"# get the function and its arguments, then call the function with its arguments.",
"# Because we linearize the abstract syntax tree depth first, left-to-right, we can just",
"# recursively call `_execute_sequence` for the function and all of its arguments, and",
"# things will just work.",
"right_side_parts",
"=",
"right_side",
".",
"split",
"(",
"', '",
")",
"# We don't really need to know what the types are, just how many of them there are, so",
"# we recurse the right number of times.",
"function",
",",
"remaining_actions",
",",
"remaining_side_args",
"=",
"self",
".",
"_execute_sequence",
"(",
"remaining_actions",
",",
"remaining_side_args",
")",
"arguments",
"=",
"[",
"]",
"for",
"_",
"in",
"right_side_parts",
"[",
"1",
":",
"]",
":",
"argument",
",",
"remaining_actions",
",",
"remaining_side_args",
"=",
"self",
".",
"_execute_sequence",
"(",
"remaining_actions",
",",
"remaining_side_args",
")",
"arguments",
".",
"append",
"(",
"argument",
")",
"return",
"function",
"(",
"*",
"arguments",
")",
",",
"remaining_actions",
",",
"remaining_side_args"
] |
This does the bulk of the work of :func:`execute_action_sequence`, recursively executing
the functions it finds and trimming actions off of the action sequence. The return value
is a tuple of (execution, remaining_actions), where the second value is necessary to handle
the recursion.
|
[
"This",
"does",
"the",
"bulk",
"of",
"the",
"work",
"of",
":",
"func",
":",
"execute_action_sequence",
"recursively",
"executing",
"the",
"functions",
"it",
"finds",
"and",
"trimming",
"actions",
"off",
"of",
"the",
"action",
"sequence",
".",
"The",
"return",
"value",
"is",
"a",
"tuple",
"of",
"(",
"execution",
"remaining_actions",
")",
"where",
"the",
"second",
"value",
"is",
"necessary",
"to",
"handle",
"the",
"recursion",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/semparse/domain_languages/domain_language.py#L541-L607
|
train
|
allenai/allennlp
|
allennlp/semparse/domain_languages/domain_language.py
|
DomainLanguage._get_transitions
|
def _get_transitions(self, expression: Any, expected_type: PredicateType) -> Tuple[List[str], PredicateType]:
"""
This is used when converting a logical form into an action sequence. This piece
recursively translates a lisp expression into an action sequence, making sure we match the
expected type (or using the expected type to get the right type for constant expressions).
"""
if isinstance(expression, (list, tuple)):
function_transitions, return_type, argument_types = self._get_function_transitions(expression[0],
expected_type)
if len(argument_types) != len(expression[1:]):
raise ParsingError(f'Wrong number of arguments for function in {expression}')
argument_transitions = []
for argument_type, subexpression in zip(argument_types, expression[1:]):
argument_transitions.extend(self._get_transitions(subexpression, argument_type)[0])
return function_transitions + argument_transitions, return_type
elif isinstance(expression, str):
if expression not in self._functions:
raise ParsingError(f"Unrecognized constant: {expression}")
constant_types = self._function_types[expression]
if len(constant_types) == 1:
constant_type = constant_types[0]
# This constant had only one type; that's the easy case.
if expected_type and expected_type != constant_type:
raise ParsingError(f'{expression} did not have expected type {expected_type} '
f'(found {constant_type})')
return [f'{constant_type} -> {expression}'], constant_type
else:
if not expected_type:
raise ParsingError('With no expected type and multiple types to pick from '
f"I don't know what type to use (constant was {expression})")
if expected_type not in constant_types:
raise ParsingError(f'{expression} did not have expected type {expected_type} '
f'(found these options: {constant_types}; none matched)')
return [f'{expected_type} -> {expression}'], expected_type
else:
raise ParsingError('Not sure how you got here. Please open an issue on github with details.')
|
python
|
def _get_transitions(self, expression: Any, expected_type: PredicateType) -> Tuple[List[str], PredicateType]:
"""
This is used when converting a logical form into an action sequence. This piece
recursively translates a lisp expression into an action sequence, making sure we match the
expected type (or using the expected type to get the right type for constant expressions).
"""
if isinstance(expression, (list, tuple)):
function_transitions, return_type, argument_types = self._get_function_transitions(expression[0],
expected_type)
if len(argument_types) != len(expression[1:]):
raise ParsingError(f'Wrong number of arguments for function in {expression}')
argument_transitions = []
for argument_type, subexpression in zip(argument_types, expression[1:]):
argument_transitions.extend(self._get_transitions(subexpression, argument_type)[0])
return function_transitions + argument_transitions, return_type
elif isinstance(expression, str):
if expression not in self._functions:
raise ParsingError(f"Unrecognized constant: {expression}")
constant_types = self._function_types[expression]
if len(constant_types) == 1:
constant_type = constant_types[0]
# This constant had only one type; that's the easy case.
if expected_type and expected_type != constant_type:
raise ParsingError(f'{expression} did not have expected type {expected_type} '
f'(found {constant_type})')
return [f'{constant_type} -> {expression}'], constant_type
else:
if not expected_type:
raise ParsingError('With no expected type and multiple types to pick from '
f"I don't know what type to use (constant was {expression})")
if expected_type not in constant_types:
raise ParsingError(f'{expression} did not have expected type {expected_type} '
f'(found these options: {constant_types}; none matched)')
return [f'{expected_type} -> {expression}'], expected_type
else:
raise ParsingError('Not sure how you got here. Please open an issue on github with details.')
|
[
"def",
"_get_transitions",
"(",
"self",
",",
"expression",
":",
"Any",
",",
"expected_type",
":",
"PredicateType",
")",
"->",
"Tuple",
"[",
"List",
"[",
"str",
"]",
",",
"PredicateType",
"]",
":",
"if",
"isinstance",
"(",
"expression",
",",
"(",
"list",
",",
"tuple",
")",
")",
":",
"function_transitions",
",",
"return_type",
",",
"argument_types",
"=",
"self",
".",
"_get_function_transitions",
"(",
"expression",
"[",
"0",
"]",
",",
"expected_type",
")",
"if",
"len",
"(",
"argument_types",
")",
"!=",
"len",
"(",
"expression",
"[",
"1",
":",
"]",
")",
":",
"raise",
"ParsingError",
"(",
"f'Wrong number of arguments for function in {expression}'",
")",
"argument_transitions",
"=",
"[",
"]",
"for",
"argument_type",
",",
"subexpression",
"in",
"zip",
"(",
"argument_types",
",",
"expression",
"[",
"1",
":",
"]",
")",
":",
"argument_transitions",
".",
"extend",
"(",
"self",
".",
"_get_transitions",
"(",
"subexpression",
",",
"argument_type",
")",
"[",
"0",
"]",
")",
"return",
"function_transitions",
"+",
"argument_transitions",
",",
"return_type",
"elif",
"isinstance",
"(",
"expression",
",",
"str",
")",
":",
"if",
"expression",
"not",
"in",
"self",
".",
"_functions",
":",
"raise",
"ParsingError",
"(",
"f\"Unrecognized constant: {expression}\"",
")",
"constant_types",
"=",
"self",
".",
"_function_types",
"[",
"expression",
"]",
"if",
"len",
"(",
"constant_types",
")",
"==",
"1",
":",
"constant_type",
"=",
"constant_types",
"[",
"0",
"]",
"# This constant had only one type; that's the easy case.",
"if",
"expected_type",
"and",
"expected_type",
"!=",
"constant_type",
":",
"raise",
"ParsingError",
"(",
"f'{expression} did not have expected type {expected_type} '",
"f'(found {constant_type})'",
")",
"return",
"[",
"f'{constant_type} -> {expression}'",
"]",
",",
"constant_type",
"else",
":",
"if",
"not",
"expected_type",
":",
"raise",
"ParsingError",
"(",
"'With no expected type and multiple types to pick from '",
"f\"I don't know what type to use (constant was {expression})\"",
")",
"if",
"expected_type",
"not",
"in",
"constant_types",
":",
"raise",
"ParsingError",
"(",
"f'{expression} did not have expected type {expected_type} '",
"f'(found these options: {constant_types}; none matched)'",
")",
"return",
"[",
"f'{expected_type} -> {expression}'",
"]",
",",
"expected_type",
"else",
":",
"raise",
"ParsingError",
"(",
"'Not sure how you got here. Please open an issue on github with details.'",
")"
] |
This is used when converting a logical form into an action sequence. This piece
recursively translates a lisp expression into an action sequence, making sure we match the
expected type (or using the expected type to get the right type for constant expressions).
|
[
"This",
"is",
"used",
"when",
"converting",
"a",
"logical",
"form",
"into",
"an",
"action",
"sequence",
".",
"This",
"piece",
"recursively",
"translates",
"a",
"lisp",
"expression",
"into",
"an",
"action",
"sequence",
"making",
"sure",
"we",
"match",
"the",
"expected",
"type",
"(",
"or",
"using",
"the",
"expected",
"type",
"to",
"get",
"the",
"right",
"type",
"for",
"constant",
"expressions",
")",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/semparse/domain_languages/domain_language.py#L609-L645
|
train
|
allenai/allennlp
|
allennlp/semparse/domain_languages/domain_language.py
|
DomainLanguage._get_function_transitions
|
def _get_function_transitions(self,
expression: Union[str, List],
expected_type: PredicateType) -> Tuple[List[str],
PredicateType,
List[PredicateType]]:
"""
A helper method for ``_get_transitions``. This gets the transitions for the predicate
itself in a function call. If we only had simple functions (e.g., "(add 2 3)"), this would
be pretty straightforward and we wouldn't need a separate method to handle it. We split it
out into its own method because handling higher-order functions is complicated (e.g.,
something like "((negate add) 2 3)").
"""
# This first block handles getting the transitions and function type (and some error
# checking) _just for the function itself_. If this is a simple function, this is easy; if
# it's a higher-order function, it involves some recursion.
if isinstance(expression, list):
# This is a higher-order function. TODO(mattg): we'll just ignore type checking on
# higher-order functions, for now.
transitions, function_type = self._get_transitions(expression, None)
elif expression in self._functions:
name = expression
function_types = self._function_types[expression]
if len(function_types) != 1:
raise ParsingError(f"{expression} had multiple types; this is not yet supported for functions")
function_type = function_types[0]
transitions = [f'{function_type} -> {name}']
else:
if isinstance(expression, str):
raise ParsingError(f"Unrecognized function: {expression[0]}")
else:
raise ParsingError(f"Unsupported expression type: {expression}")
if not isinstance(function_type, FunctionType):
raise ParsingError(f'Zero-arg function or constant called with arguments: {name}')
# Now that we have the transitions for the function itself, and the function's type, we can
# get argument types and do the rest of the transitions.
argument_types = function_type.argument_types
return_type = function_type.return_type
right_side = f'[{function_type}, {", ".join(str(arg) for arg in argument_types)}]'
first_transition = f'{return_type} -> {right_side}'
transitions.insert(0, first_transition)
if expected_type and expected_type != return_type:
raise ParsingError(f'{expression} did not have expected type {expected_type} '
f'(found {return_type})')
return transitions, return_type, argument_types
|
python
|
def _get_function_transitions(self,
expression: Union[str, List],
expected_type: PredicateType) -> Tuple[List[str],
PredicateType,
List[PredicateType]]:
"""
A helper method for ``_get_transitions``. This gets the transitions for the predicate
itself in a function call. If we only had simple functions (e.g., "(add 2 3)"), this would
be pretty straightforward and we wouldn't need a separate method to handle it. We split it
out into its own method because handling higher-order functions is complicated (e.g.,
something like "((negate add) 2 3)").
"""
# This first block handles getting the transitions and function type (and some error
# checking) _just for the function itself_. If this is a simple function, this is easy; if
# it's a higher-order function, it involves some recursion.
if isinstance(expression, list):
# This is a higher-order function. TODO(mattg): we'll just ignore type checking on
# higher-order functions, for now.
transitions, function_type = self._get_transitions(expression, None)
elif expression in self._functions:
name = expression
function_types = self._function_types[expression]
if len(function_types) != 1:
raise ParsingError(f"{expression} had multiple types; this is not yet supported for functions")
function_type = function_types[0]
transitions = [f'{function_type} -> {name}']
else:
if isinstance(expression, str):
raise ParsingError(f"Unrecognized function: {expression[0]}")
else:
raise ParsingError(f"Unsupported expression type: {expression}")
if not isinstance(function_type, FunctionType):
raise ParsingError(f'Zero-arg function or constant called with arguments: {name}')
# Now that we have the transitions for the function itself, and the function's type, we can
# get argument types and do the rest of the transitions.
argument_types = function_type.argument_types
return_type = function_type.return_type
right_side = f'[{function_type}, {", ".join(str(arg) for arg in argument_types)}]'
first_transition = f'{return_type} -> {right_side}'
transitions.insert(0, first_transition)
if expected_type and expected_type != return_type:
raise ParsingError(f'{expression} did not have expected type {expected_type} '
f'(found {return_type})')
return transitions, return_type, argument_types
|
[
"def",
"_get_function_transitions",
"(",
"self",
",",
"expression",
":",
"Union",
"[",
"str",
",",
"List",
"]",
",",
"expected_type",
":",
"PredicateType",
")",
"->",
"Tuple",
"[",
"List",
"[",
"str",
"]",
",",
"PredicateType",
",",
"List",
"[",
"PredicateType",
"]",
"]",
":",
"# This first block handles getting the transitions and function type (and some error",
"# checking) _just for the function itself_. If this is a simple function, this is easy; if",
"# it's a higher-order function, it involves some recursion.",
"if",
"isinstance",
"(",
"expression",
",",
"list",
")",
":",
"# This is a higher-order function. TODO(mattg): we'll just ignore type checking on",
"# higher-order functions, for now.",
"transitions",
",",
"function_type",
"=",
"self",
".",
"_get_transitions",
"(",
"expression",
",",
"None",
")",
"elif",
"expression",
"in",
"self",
".",
"_functions",
":",
"name",
"=",
"expression",
"function_types",
"=",
"self",
".",
"_function_types",
"[",
"expression",
"]",
"if",
"len",
"(",
"function_types",
")",
"!=",
"1",
":",
"raise",
"ParsingError",
"(",
"f\"{expression} had multiple types; this is not yet supported for functions\"",
")",
"function_type",
"=",
"function_types",
"[",
"0",
"]",
"transitions",
"=",
"[",
"f'{function_type} -> {name}'",
"]",
"else",
":",
"if",
"isinstance",
"(",
"expression",
",",
"str",
")",
":",
"raise",
"ParsingError",
"(",
"f\"Unrecognized function: {expression[0]}\"",
")",
"else",
":",
"raise",
"ParsingError",
"(",
"f\"Unsupported expression type: {expression}\"",
")",
"if",
"not",
"isinstance",
"(",
"function_type",
",",
"FunctionType",
")",
":",
"raise",
"ParsingError",
"(",
"f'Zero-arg function or constant called with arguments: {name}'",
")",
"# Now that we have the transitions for the function itself, and the function's type, we can",
"# get argument types and do the rest of the transitions.",
"argument_types",
"=",
"function_type",
".",
"argument_types",
"return_type",
"=",
"function_type",
".",
"return_type",
"right_side",
"=",
"f'[{function_type}, {\", \".join(str(arg) for arg in argument_types)}]'",
"first_transition",
"=",
"f'{return_type} -> {right_side}'",
"transitions",
".",
"insert",
"(",
"0",
",",
"first_transition",
")",
"if",
"expected_type",
"and",
"expected_type",
"!=",
"return_type",
":",
"raise",
"ParsingError",
"(",
"f'{expression} did not have expected type {expected_type} '",
"f'(found {return_type})'",
")",
"return",
"transitions",
",",
"return_type",
",",
"argument_types"
] |
A helper method for ``_get_transitions``. This gets the transitions for the predicate
itself in a function call. If we only had simple functions (e.g., "(add 2 3)"), this would
be pretty straightforward and we wouldn't need a separate method to handle it. We split it
out into its own method because handling higher-order functions is complicated (e.g.,
something like "((negate add) 2 3)").
|
[
"A",
"helper",
"method",
"for",
"_get_transitions",
".",
"This",
"gets",
"the",
"transitions",
"for",
"the",
"predicate",
"itself",
"in",
"a",
"function",
"call",
".",
"If",
"we",
"only",
"had",
"simple",
"functions",
"(",
"e",
".",
"g",
".",
"(",
"add",
"2",
"3",
")",
")",
"this",
"would",
"be",
"pretty",
"straightforward",
"and",
"we",
"wouldn",
"t",
"need",
"a",
"separate",
"method",
"to",
"handle",
"it",
".",
"We",
"split",
"it",
"out",
"into",
"its",
"own",
"method",
"because",
"handling",
"higher",
"-",
"order",
"functions",
"is",
"complicated",
"(",
"e",
".",
"g",
".",
"something",
"like",
"((",
"negate",
"add",
")",
"2",
"3",
")",
")",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/semparse/domain_languages/domain_language.py#L647-L691
|
train
|
allenai/allennlp
|
allennlp/semparse/domain_languages/domain_language.py
|
DomainLanguage._construct_node_from_actions
|
def _construct_node_from_actions(self,
current_node: Tree,
remaining_actions: List[List[str]]) -> List[List[str]]:
"""
Given a current node in the logical form tree, and a list of actions in an action sequence,
this method fills in the children of the current node from the action sequence, then
returns whatever actions are left.
For example, we could get a node with type ``c``, and an action sequence that begins with
``c -> [<r,c>, r]``. This method will add two children to the input node, consuming
actions from the action sequence for nodes of type ``<r,c>`` (and all of its children,
recursively) and ``r`` (and all of its children, recursively). This method assumes that
action sequences are produced `depth-first`, so all actions for the subtree under ``<r,c>``
appear before actions for the subtree under ``r``. If there are any actions in the action
sequence after the ``<r,c>`` and ``r`` subtrees have terminated in leaf nodes, they will be
returned.
"""
if not remaining_actions:
logger.error("No actions left to construct current node: %s", current_node)
raise ParsingError("Incomplete action sequence")
left_side, right_side = remaining_actions.pop(0)
if left_side != current_node.label():
logger.error("Current node: %s", current_node)
logger.error("Next action: %s -> %s", left_side, right_side)
logger.error("Remaining actions were: %s", remaining_actions)
raise ParsingError("Current node does not match next action")
if right_side[0] == '[':
# This is a non-terminal expansion, with more than one child node.
for child_type in right_side[1:-1].split(', '):
child_node = Tree(child_type, [])
current_node.append(child_node) # you add a child to an nltk.Tree with `append`
# For now, we assume that all children in a list like this are non-terminals, so we
# recurse on them. I'm pretty sure that will always be true for the way our
# grammar induction works. We can revisit this later if we need to.
remaining_actions = self._construct_node_from_actions(child_node, remaining_actions)
else:
# The current node is a pre-terminal; we'll add a single terminal child. By
# construction, the right-hand side of our production rules are only ever terminal
# productions or lists of non-terminals.
current_node.append(Tree(right_side, [])) # you add a child to an nltk.Tree with `append`
return remaining_actions
|
python
|
def _construct_node_from_actions(self,
current_node: Tree,
remaining_actions: List[List[str]]) -> List[List[str]]:
"""
Given a current node in the logical form tree, and a list of actions in an action sequence,
this method fills in the children of the current node from the action sequence, then
returns whatever actions are left.
For example, we could get a node with type ``c``, and an action sequence that begins with
``c -> [<r,c>, r]``. This method will add two children to the input node, consuming
actions from the action sequence for nodes of type ``<r,c>`` (and all of its children,
recursively) and ``r`` (and all of its children, recursively). This method assumes that
action sequences are produced `depth-first`, so all actions for the subtree under ``<r,c>``
appear before actions for the subtree under ``r``. If there are any actions in the action
sequence after the ``<r,c>`` and ``r`` subtrees have terminated in leaf nodes, they will be
returned.
"""
if not remaining_actions:
logger.error("No actions left to construct current node: %s", current_node)
raise ParsingError("Incomplete action sequence")
left_side, right_side = remaining_actions.pop(0)
if left_side != current_node.label():
logger.error("Current node: %s", current_node)
logger.error("Next action: %s -> %s", left_side, right_side)
logger.error("Remaining actions were: %s", remaining_actions)
raise ParsingError("Current node does not match next action")
if right_side[0] == '[':
# This is a non-terminal expansion, with more than one child node.
for child_type in right_side[1:-1].split(', '):
child_node = Tree(child_type, [])
current_node.append(child_node) # you add a child to an nltk.Tree with `append`
# For now, we assume that all children in a list like this are non-terminals, so we
# recurse on them. I'm pretty sure that will always be true for the way our
# grammar induction works. We can revisit this later if we need to.
remaining_actions = self._construct_node_from_actions(child_node, remaining_actions)
else:
# The current node is a pre-terminal; we'll add a single terminal child. By
# construction, the right-hand side of our production rules are only ever terminal
# productions or lists of non-terminals.
current_node.append(Tree(right_side, [])) # you add a child to an nltk.Tree with `append`
return remaining_actions
|
[
"def",
"_construct_node_from_actions",
"(",
"self",
",",
"current_node",
":",
"Tree",
",",
"remaining_actions",
":",
"List",
"[",
"List",
"[",
"str",
"]",
"]",
")",
"->",
"List",
"[",
"List",
"[",
"str",
"]",
"]",
":",
"if",
"not",
"remaining_actions",
":",
"logger",
".",
"error",
"(",
"\"No actions left to construct current node: %s\"",
",",
"current_node",
")",
"raise",
"ParsingError",
"(",
"\"Incomplete action sequence\"",
")",
"left_side",
",",
"right_side",
"=",
"remaining_actions",
".",
"pop",
"(",
"0",
")",
"if",
"left_side",
"!=",
"current_node",
".",
"label",
"(",
")",
":",
"logger",
".",
"error",
"(",
"\"Current node: %s\"",
",",
"current_node",
")",
"logger",
".",
"error",
"(",
"\"Next action: %s -> %s\"",
",",
"left_side",
",",
"right_side",
")",
"logger",
".",
"error",
"(",
"\"Remaining actions were: %s\"",
",",
"remaining_actions",
")",
"raise",
"ParsingError",
"(",
"\"Current node does not match next action\"",
")",
"if",
"right_side",
"[",
"0",
"]",
"==",
"'['",
":",
"# This is a non-terminal expansion, with more than one child node.",
"for",
"child_type",
"in",
"right_side",
"[",
"1",
":",
"-",
"1",
"]",
".",
"split",
"(",
"', '",
")",
":",
"child_node",
"=",
"Tree",
"(",
"child_type",
",",
"[",
"]",
")",
"current_node",
".",
"append",
"(",
"child_node",
")",
"# you add a child to an nltk.Tree with `append`",
"# For now, we assume that all children in a list like this are non-terminals, so we",
"# recurse on them. I'm pretty sure that will always be true for the way our",
"# grammar induction works. We can revisit this later if we need to.",
"remaining_actions",
"=",
"self",
".",
"_construct_node_from_actions",
"(",
"child_node",
",",
"remaining_actions",
")",
"else",
":",
"# The current node is a pre-terminal; we'll add a single terminal child. By",
"# construction, the right-hand side of our production rules are only ever terminal",
"# productions or lists of non-terminals.",
"current_node",
".",
"append",
"(",
"Tree",
"(",
"right_side",
",",
"[",
"]",
")",
")",
"# you add a child to an nltk.Tree with `append`",
"return",
"remaining_actions"
] |
Given a current node in the logical form tree, and a list of actions in an action sequence,
this method fills in the children of the current node from the action sequence, then
returns whatever actions are left.
For example, we could get a node with type ``c``, and an action sequence that begins with
``c -> [<r,c>, r]``. This method will add two children to the input node, consuming
actions from the action sequence for nodes of type ``<r,c>`` (and all of its children,
recursively) and ``r`` (and all of its children, recursively). This method assumes that
action sequences are produced `depth-first`, so all actions for the subtree under ``<r,c>``
appear before actions for the subtree under ``r``. If there are any actions in the action
sequence after the ``<r,c>`` and ``r`` subtrees have terminated in leaf nodes, they will be
returned.
|
[
"Given",
"a",
"current",
"node",
"in",
"the",
"logical",
"form",
"tree",
"and",
"a",
"list",
"of",
"actions",
"in",
"an",
"action",
"sequence",
"this",
"method",
"fills",
"in",
"the",
"children",
"of",
"the",
"current",
"node",
"from",
"the",
"action",
"sequence",
"then",
"returns",
"whatever",
"actions",
"are",
"left",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/semparse/domain_languages/domain_language.py#L693-L733
|
train
|
allenai/allennlp
|
allennlp/modules/sampled_softmax_loss.py
|
_choice
|
def _choice(num_words: int, num_samples: int) -> Tuple[np.ndarray, int]:
"""
Chooses ``num_samples`` samples without replacement from [0, ..., num_words).
Returns a tuple (samples, num_tries).
"""
num_tries = 0
num_chosen = 0
def get_buffer() -> np.ndarray:
log_samples = np.random.rand(num_samples) * np.log(num_words + 1)
samples = np.exp(log_samples).astype('int64') - 1
return np.clip(samples, a_min=0, a_max=num_words - 1)
sample_buffer = get_buffer()
buffer_index = 0
samples: Set[int] = set()
while num_chosen < num_samples:
num_tries += 1
# choose sample
sample_id = sample_buffer[buffer_index]
if sample_id not in samples:
samples.add(sample_id)
num_chosen += 1
buffer_index += 1
if buffer_index == num_samples:
# Reset the buffer
sample_buffer = get_buffer()
buffer_index = 0
return np.array(list(samples)), num_tries
|
python
|
def _choice(num_words: int, num_samples: int) -> Tuple[np.ndarray, int]:
"""
Chooses ``num_samples`` samples without replacement from [0, ..., num_words).
Returns a tuple (samples, num_tries).
"""
num_tries = 0
num_chosen = 0
def get_buffer() -> np.ndarray:
log_samples = np.random.rand(num_samples) * np.log(num_words + 1)
samples = np.exp(log_samples).astype('int64') - 1
return np.clip(samples, a_min=0, a_max=num_words - 1)
sample_buffer = get_buffer()
buffer_index = 0
samples: Set[int] = set()
while num_chosen < num_samples:
num_tries += 1
# choose sample
sample_id = sample_buffer[buffer_index]
if sample_id not in samples:
samples.add(sample_id)
num_chosen += 1
buffer_index += 1
if buffer_index == num_samples:
# Reset the buffer
sample_buffer = get_buffer()
buffer_index = 0
return np.array(list(samples)), num_tries
|
[
"def",
"_choice",
"(",
"num_words",
":",
"int",
",",
"num_samples",
":",
"int",
")",
"->",
"Tuple",
"[",
"np",
".",
"ndarray",
",",
"int",
"]",
":",
"num_tries",
"=",
"0",
"num_chosen",
"=",
"0",
"def",
"get_buffer",
"(",
")",
"->",
"np",
".",
"ndarray",
":",
"log_samples",
"=",
"np",
".",
"random",
".",
"rand",
"(",
"num_samples",
")",
"*",
"np",
".",
"log",
"(",
"num_words",
"+",
"1",
")",
"samples",
"=",
"np",
".",
"exp",
"(",
"log_samples",
")",
".",
"astype",
"(",
"'int64'",
")",
"-",
"1",
"return",
"np",
".",
"clip",
"(",
"samples",
",",
"a_min",
"=",
"0",
",",
"a_max",
"=",
"num_words",
"-",
"1",
")",
"sample_buffer",
"=",
"get_buffer",
"(",
")",
"buffer_index",
"=",
"0",
"samples",
":",
"Set",
"[",
"int",
"]",
"=",
"set",
"(",
")",
"while",
"num_chosen",
"<",
"num_samples",
":",
"num_tries",
"+=",
"1",
"# choose sample",
"sample_id",
"=",
"sample_buffer",
"[",
"buffer_index",
"]",
"if",
"sample_id",
"not",
"in",
"samples",
":",
"samples",
".",
"add",
"(",
"sample_id",
")",
"num_chosen",
"+=",
"1",
"buffer_index",
"+=",
"1",
"if",
"buffer_index",
"==",
"num_samples",
":",
"# Reset the buffer",
"sample_buffer",
"=",
"get_buffer",
"(",
")",
"buffer_index",
"=",
"0",
"return",
"np",
".",
"array",
"(",
"list",
"(",
"samples",
")",
")",
",",
"num_tries"
] |
Chooses ``num_samples`` samples without replacement from [0, ..., num_words).
Returns a tuple (samples, num_tries).
|
[
"Chooses",
"num_samples",
"samples",
"without",
"replacement",
"from",
"[",
"0",
"...",
"num_words",
")",
".",
"Returns",
"a",
"tuple",
"(",
"samples",
"num_tries",
")",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/modules/sampled_softmax_loss.py#L11-L42
|
train
|
allenai/allennlp
|
allennlp/data/token_indexers/token_indexer.py
|
TokenIndexer.tokens_to_indices
|
def tokens_to_indices(self,
tokens: List[Token],
vocabulary: Vocabulary,
index_name: str) -> Dict[str, List[TokenType]]:
"""
Takes a list of tokens and converts them to one or more sets of indices.
This could be just an ID for each token from the vocabulary.
Or it could split each token into characters and return one ID per character.
Or (for instance, in the case of byte-pair encoding) there might not be a clean
mapping from individual tokens to indices.
"""
raise NotImplementedError
|
python
|
def tokens_to_indices(self,
tokens: List[Token],
vocabulary: Vocabulary,
index_name: str) -> Dict[str, List[TokenType]]:
"""
Takes a list of tokens and converts them to one or more sets of indices.
This could be just an ID for each token from the vocabulary.
Or it could split each token into characters and return one ID per character.
Or (for instance, in the case of byte-pair encoding) there might not be a clean
mapping from individual tokens to indices.
"""
raise NotImplementedError
|
[
"def",
"tokens_to_indices",
"(",
"self",
",",
"tokens",
":",
"List",
"[",
"Token",
"]",
",",
"vocabulary",
":",
"Vocabulary",
",",
"index_name",
":",
"str",
")",
"->",
"Dict",
"[",
"str",
",",
"List",
"[",
"TokenType",
"]",
"]",
":",
"raise",
"NotImplementedError"
] |
Takes a list of tokens and converts them to one or more sets of indices.
This could be just an ID for each token from the vocabulary.
Or it could split each token into characters and return one ID per character.
Or (for instance, in the case of byte-pair encoding) there might not be a clean
mapping from individual tokens to indices.
|
[
"Takes",
"a",
"list",
"of",
"tokens",
"and",
"converts",
"them",
"to",
"one",
"or",
"more",
"sets",
"of",
"indices",
".",
"This",
"could",
"be",
"just",
"an",
"ID",
"for",
"each",
"token",
"from",
"the",
"vocabulary",
".",
"Or",
"it",
"could",
"split",
"each",
"token",
"into",
"characters",
"and",
"return",
"one",
"ID",
"per",
"character",
".",
"Or",
"(",
"for",
"instance",
"in",
"the",
"case",
"of",
"byte",
"-",
"pair",
"encoding",
")",
"there",
"might",
"not",
"be",
"a",
"clean",
"mapping",
"from",
"individual",
"tokens",
"to",
"indices",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/data/token_indexers/token_indexer.py#L33-L44
|
train
|
allenai/allennlp
|
allennlp/data/token_indexers/token_indexer.py
|
TokenIndexer.pad_token_sequence
|
def pad_token_sequence(self,
tokens: Dict[str, List[TokenType]],
desired_num_tokens: Dict[str, int],
padding_lengths: Dict[str, int]) -> Dict[str, List[TokenType]]:
"""
This method pads a list of tokens to ``desired_num_tokens`` and returns a padded copy of the
input tokens. If the input token list is longer than ``desired_num_tokens`` then it will be
truncated.
``padding_lengths`` is used to provide supplemental padding parameters which are needed
in some cases. For example, it contains the widths to pad characters to when doing
character-level padding.
"""
raise NotImplementedError
|
python
|
def pad_token_sequence(self,
tokens: Dict[str, List[TokenType]],
desired_num_tokens: Dict[str, int],
padding_lengths: Dict[str, int]) -> Dict[str, List[TokenType]]:
"""
This method pads a list of tokens to ``desired_num_tokens`` and returns a padded copy of the
input tokens. If the input token list is longer than ``desired_num_tokens`` then it will be
truncated.
``padding_lengths`` is used to provide supplemental padding parameters which are needed
in some cases. For example, it contains the widths to pad characters to when doing
character-level padding.
"""
raise NotImplementedError
|
[
"def",
"pad_token_sequence",
"(",
"self",
",",
"tokens",
":",
"Dict",
"[",
"str",
",",
"List",
"[",
"TokenType",
"]",
"]",
",",
"desired_num_tokens",
":",
"Dict",
"[",
"str",
",",
"int",
"]",
",",
"padding_lengths",
":",
"Dict",
"[",
"str",
",",
"int",
"]",
")",
"->",
"Dict",
"[",
"str",
",",
"List",
"[",
"TokenType",
"]",
"]",
":",
"raise",
"NotImplementedError"
] |
This method pads a list of tokens to ``desired_num_tokens`` and returns a padded copy of the
input tokens. If the input token list is longer than ``desired_num_tokens`` then it will be
truncated.
``padding_lengths`` is used to provide supplemental padding parameters which are needed
in some cases. For example, it contains the widths to pad characters to when doing
character-level padding.
|
[
"This",
"method",
"pads",
"a",
"list",
"of",
"tokens",
"to",
"desired_num_tokens",
"and",
"returns",
"a",
"padded",
"copy",
"of",
"the",
"input",
"tokens",
".",
"If",
"the",
"input",
"token",
"list",
"is",
"longer",
"than",
"desired_num_tokens",
"then",
"it",
"will",
"be",
"truncated",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/data/token_indexers/token_indexer.py#L62-L75
|
train
|
allenai/allennlp
|
allennlp/data/dataset_readers/coreference_resolution/conll.py
|
canonicalize_clusters
|
def canonicalize_clusters(clusters: DefaultDict[int, List[Tuple[int, int]]]) -> List[List[Tuple[int, int]]]:
"""
The CONLL 2012 data includes 2 annotated spans which are identical,
but have different ids. This checks all clusters for spans which are
identical, and if it finds any, merges the clusters containing the
identical spans.
"""
merged_clusters: List[Set[Tuple[int, int]]] = []
for cluster in clusters.values():
cluster_with_overlapping_mention = None
for mention in cluster:
# Look at clusters we have already processed to
# see if they contain a mention in the current
# cluster for comparison.
for cluster2 in merged_clusters:
if mention in cluster2:
# first cluster in merged clusters
# which contains this mention.
cluster_with_overlapping_mention = cluster2
break
# Already encountered overlap - no need to keep looking.
if cluster_with_overlapping_mention is not None:
break
if cluster_with_overlapping_mention is not None:
# Merge cluster we are currently processing into
# the cluster in the processed list.
cluster_with_overlapping_mention.update(cluster)
else:
merged_clusters.append(set(cluster))
return [list(c) for c in merged_clusters]
|
python
|
def canonicalize_clusters(clusters: DefaultDict[int, List[Tuple[int, int]]]) -> List[List[Tuple[int, int]]]:
"""
The CONLL 2012 data includes 2 annotated spans which are identical,
but have different ids. This checks all clusters for spans which are
identical, and if it finds any, merges the clusters containing the
identical spans.
"""
merged_clusters: List[Set[Tuple[int, int]]] = []
for cluster in clusters.values():
cluster_with_overlapping_mention = None
for mention in cluster:
# Look at clusters we have already processed to
# see if they contain a mention in the current
# cluster for comparison.
for cluster2 in merged_clusters:
if mention in cluster2:
# first cluster in merged clusters
# which contains this mention.
cluster_with_overlapping_mention = cluster2
break
# Already encountered overlap - no need to keep looking.
if cluster_with_overlapping_mention is not None:
break
if cluster_with_overlapping_mention is not None:
# Merge cluster we are currently processing into
# the cluster in the processed list.
cluster_with_overlapping_mention.update(cluster)
else:
merged_clusters.append(set(cluster))
return [list(c) for c in merged_clusters]
|
[
"def",
"canonicalize_clusters",
"(",
"clusters",
":",
"DefaultDict",
"[",
"int",
",",
"List",
"[",
"Tuple",
"[",
"int",
",",
"int",
"]",
"]",
"]",
")",
"->",
"List",
"[",
"List",
"[",
"Tuple",
"[",
"int",
",",
"int",
"]",
"]",
"]",
":",
"merged_clusters",
":",
"List",
"[",
"Set",
"[",
"Tuple",
"[",
"int",
",",
"int",
"]",
"]",
"]",
"=",
"[",
"]",
"for",
"cluster",
"in",
"clusters",
".",
"values",
"(",
")",
":",
"cluster_with_overlapping_mention",
"=",
"None",
"for",
"mention",
"in",
"cluster",
":",
"# Look at clusters we have already processed to",
"# see if they contain a mention in the current",
"# cluster for comparison.",
"for",
"cluster2",
"in",
"merged_clusters",
":",
"if",
"mention",
"in",
"cluster2",
":",
"# first cluster in merged clusters",
"# which contains this mention.",
"cluster_with_overlapping_mention",
"=",
"cluster2",
"break",
"# Already encountered overlap - no need to keep looking.",
"if",
"cluster_with_overlapping_mention",
"is",
"not",
"None",
":",
"break",
"if",
"cluster_with_overlapping_mention",
"is",
"not",
"None",
":",
"# Merge cluster we are currently processing into",
"# the cluster in the processed list.",
"cluster_with_overlapping_mention",
".",
"update",
"(",
"cluster",
")",
"else",
":",
"merged_clusters",
".",
"append",
"(",
"set",
"(",
"cluster",
")",
")",
"return",
"[",
"list",
"(",
"c",
")",
"for",
"c",
"in",
"merged_clusters",
"]"
] |
The CONLL 2012 data includes 2 annotated spans which are identical,
but have different ids. This checks all clusters for spans which are
identical, and if it finds any, merges the clusters containing the
identical spans.
|
[
"The",
"CONLL",
"2012",
"data",
"includes",
"2",
"annotated",
"spans",
"which",
"are",
"identical",
"but",
"have",
"different",
"ids",
".",
"This",
"checks",
"all",
"clusters",
"for",
"spans",
"which",
"are",
"identical",
"and",
"if",
"it",
"finds",
"any",
"merges",
"the",
"clusters",
"containing",
"the",
"identical",
"spans",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/data/dataset_readers/coreference_resolution/conll.py#L18-L47
|
train
|
allenai/allennlp
|
allennlp/predictors/open_information_extraction.py
|
join_mwp
|
def join_mwp(tags: List[str]) -> List[str]:
"""
Join multi-word predicates to a single
predicate ('V') token.
"""
ret = []
verb_flag = False
for tag in tags:
if "V" in tag:
# Create a continuous 'V' BIO span
prefix, _ = tag.split("-")
if verb_flag:
# Continue a verb label across the different predicate parts
prefix = 'I'
ret.append(f"{prefix}-V")
verb_flag = True
else:
ret.append(tag)
verb_flag = False
return ret
|
python
|
def join_mwp(tags: List[str]) -> List[str]:
"""
Join multi-word predicates to a single
predicate ('V') token.
"""
ret = []
verb_flag = False
for tag in tags:
if "V" in tag:
# Create a continuous 'V' BIO span
prefix, _ = tag.split("-")
if verb_flag:
# Continue a verb label across the different predicate parts
prefix = 'I'
ret.append(f"{prefix}-V")
verb_flag = True
else:
ret.append(tag)
verb_flag = False
return ret
|
[
"def",
"join_mwp",
"(",
"tags",
":",
"List",
"[",
"str",
"]",
")",
"->",
"List",
"[",
"str",
"]",
":",
"ret",
"=",
"[",
"]",
"verb_flag",
"=",
"False",
"for",
"tag",
"in",
"tags",
":",
"if",
"\"V\"",
"in",
"tag",
":",
"# Create a continuous 'V' BIO span",
"prefix",
",",
"_",
"=",
"tag",
".",
"split",
"(",
"\"-\"",
")",
"if",
"verb_flag",
":",
"# Continue a verb label across the different predicate parts",
"prefix",
"=",
"'I'",
"ret",
".",
"append",
"(",
"f\"{prefix}-V\"",
")",
"verb_flag",
"=",
"True",
"else",
":",
"ret",
".",
"append",
"(",
"tag",
")",
"verb_flag",
"=",
"False",
"return",
"ret"
] |
Join multi-word predicates to a single
predicate ('V') token.
|
[
"Join",
"multi",
"-",
"word",
"predicates",
"to",
"a",
"single",
"predicate",
"(",
"V",
")",
"token",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/predictors/open_information_extraction.py#L13-L33
|
train
|
allenai/allennlp
|
allennlp/predictors/open_information_extraction.py
|
make_oie_string
|
def make_oie_string(tokens: List[Token], tags: List[str]) -> str:
"""
Converts a list of model outputs (i.e., a list of lists of bio tags, each
pertaining to a single word), returns an inline bracket representation of
the prediction.
"""
frame = []
chunk = []
words = [token.text for token in tokens]
for (token, tag) in zip(words, tags):
if tag.startswith("I-"):
chunk.append(token)
else:
if chunk:
frame.append("[" + " ".join(chunk) + "]")
chunk = []
if tag.startswith("B-"):
chunk.append(tag[2:] + ": " + token)
elif tag == "O":
frame.append(token)
if chunk:
frame.append("[" + " ".join(chunk) + "]")
return " ".join(frame)
|
python
|
def make_oie_string(tokens: List[Token], tags: List[str]) -> str:
"""
Converts a list of model outputs (i.e., a list of lists of bio tags, each
pertaining to a single word), returns an inline bracket representation of
the prediction.
"""
frame = []
chunk = []
words = [token.text for token in tokens]
for (token, tag) in zip(words, tags):
if tag.startswith("I-"):
chunk.append(token)
else:
if chunk:
frame.append("[" + " ".join(chunk) + "]")
chunk = []
if tag.startswith("B-"):
chunk.append(tag[2:] + ": " + token)
elif tag == "O":
frame.append(token)
if chunk:
frame.append("[" + " ".join(chunk) + "]")
return " ".join(frame)
|
[
"def",
"make_oie_string",
"(",
"tokens",
":",
"List",
"[",
"Token",
"]",
",",
"tags",
":",
"List",
"[",
"str",
"]",
")",
"->",
"str",
":",
"frame",
"=",
"[",
"]",
"chunk",
"=",
"[",
"]",
"words",
"=",
"[",
"token",
".",
"text",
"for",
"token",
"in",
"tokens",
"]",
"for",
"(",
"token",
",",
"tag",
")",
"in",
"zip",
"(",
"words",
",",
"tags",
")",
":",
"if",
"tag",
".",
"startswith",
"(",
"\"I-\"",
")",
":",
"chunk",
".",
"append",
"(",
"token",
")",
"else",
":",
"if",
"chunk",
":",
"frame",
".",
"append",
"(",
"\"[\"",
"+",
"\" \"",
".",
"join",
"(",
"chunk",
")",
"+",
"\"]\"",
")",
"chunk",
"=",
"[",
"]",
"if",
"tag",
".",
"startswith",
"(",
"\"B-\"",
")",
":",
"chunk",
".",
"append",
"(",
"tag",
"[",
"2",
":",
"]",
"+",
"\": \"",
"+",
"token",
")",
"elif",
"tag",
"==",
"\"O\"",
":",
"frame",
".",
"append",
"(",
"token",
")",
"if",
"chunk",
":",
"frame",
".",
"append",
"(",
"\"[\"",
"+",
"\" \"",
".",
"join",
"(",
"chunk",
")",
"+",
"\"]\"",
")",
"return",
"\" \"",
".",
"join",
"(",
"frame",
")"
] |
Converts a list of model outputs (i.e., a list of lists of bio tags, each
pertaining to a single word), returns an inline bracket representation of
the prediction.
|
[
"Converts",
"a",
"list",
"of",
"model",
"outputs",
"(",
"i",
".",
"e",
".",
"a",
"list",
"of",
"lists",
"of",
"bio",
"tags",
"each",
"pertaining",
"to",
"a",
"single",
"word",
")",
"returns",
"an",
"inline",
"bracket",
"representation",
"of",
"the",
"prediction",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/predictors/open_information_extraction.py#L35-L61
|
train
|
allenai/allennlp
|
allennlp/predictors/open_information_extraction.py
|
get_predicate_indices
|
def get_predicate_indices(tags: List[str]) -> List[int]:
"""
Return the word indices of a predicate in BIO tags.
"""
return [ind for ind, tag in enumerate(tags) if 'V' in tag]
|
python
|
def get_predicate_indices(tags: List[str]) -> List[int]:
"""
Return the word indices of a predicate in BIO tags.
"""
return [ind for ind, tag in enumerate(tags) if 'V' in tag]
|
[
"def",
"get_predicate_indices",
"(",
"tags",
":",
"List",
"[",
"str",
"]",
")",
"->",
"List",
"[",
"int",
"]",
":",
"return",
"[",
"ind",
"for",
"ind",
",",
"tag",
"in",
"enumerate",
"(",
"tags",
")",
"if",
"'V'",
"in",
"tag",
"]"
] |
Return the word indices of a predicate in BIO tags.
|
[
"Return",
"the",
"word",
"indices",
"of",
"a",
"predicate",
"in",
"BIO",
"tags",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/predictors/open_information_extraction.py#L63-L67
|
train
|
allenai/allennlp
|
allennlp/predictors/open_information_extraction.py
|
get_predicate_text
|
def get_predicate_text(sent_tokens: List[Token], tags: List[str]) -> str:
"""
Get the predicate in this prediction.
"""
return " ".join([sent_tokens[pred_id].text
for pred_id in get_predicate_indices(tags)])
|
python
|
def get_predicate_text(sent_tokens: List[Token], tags: List[str]) -> str:
"""
Get the predicate in this prediction.
"""
return " ".join([sent_tokens[pred_id].text
for pred_id in get_predicate_indices(tags)])
|
[
"def",
"get_predicate_text",
"(",
"sent_tokens",
":",
"List",
"[",
"Token",
"]",
",",
"tags",
":",
"List",
"[",
"str",
"]",
")",
"->",
"str",
":",
"return",
"\" \"",
".",
"join",
"(",
"[",
"sent_tokens",
"[",
"pred_id",
"]",
".",
"text",
"for",
"pred_id",
"in",
"get_predicate_indices",
"(",
"tags",
")",
"]",
")"
] |
Get the predicate in this prediction.
|
[
"Get",
"the",
"predicate",
"in",
"this",
"prediction",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/predictors/open_information_extraction.py#L69-L74
|
train
|
allenai/allennlp
|
allennlp/predictors/open_information_extraction.py
|
predicates_overlap
|
def predicates_overlap(tags1: List[str], tags2: List[str]) -> bool:
"""
Tests whether the predicate in BIO tags1 overlap
with those of tags2.
"""
# Get predicate word indices from both predictions
pred_ind1 = get_predicate_indices(tags1)
pred_ind2 = get_predicate_indices(tags2)
# Return if pred_ind1 pred_ind2 overlap
return any(set.intersection(set(pred_ind1), set(pred_ind2)))
|
python
|
def predicates_overlap(tags1: List[str], tags2: List[str]) -> bool:
"""
Tests whether the predicate in BIO tags1 overlap
with those of tags2.
"""
# Get predicate word indices from both predictions
pred_ind1 = get_predicate_indices(tags1)
pred_ind2 = get_predicate_indices(tags2)
# Return if pred_ind1 pred_ind2 overlap
return any(set.intersection(set(pred_ind1), set(pred_ind2)))
|
[
"def",
"predicates_overlap",
"(",
"tags1",
":",
"List",
"[",
"str",
"]",
",",
"tags2",
":",
"List",
"[",
"str",
"]",
")",
"->",
"bool",
":",
"# Get predicate word indices from both predictions",
"pred_ind1",
"=",
"get_predicate_indices",
"(",
"tags1",
")",
"pred_ind2",
"=",
"get_predicate_indices",
"(",
"tags2",
")",
"# Return if pred_ind1 pred_ind2 overlap",
"return",
"any",
"(",
"set",
".",
"intersection",
"(",
"set",
"(",
"pred_ind1",
")",
",",
"set",
"(",
"pred_ind2",
")",
")",
")"
] |
Tests whether the predicate in BIO tags1 overlap
with those of tags2.
|
[
"Tests",
"whether",
"the",
"predicate",
"in",
"BIO",
"tags1",
"overlap",
"with",
"those",
"of",
"tags2",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/predictors/open_information_extraction.py#L76-L86
|
train
|
allenai/allennlp
|
allennlp/predictors/open_information_extraction.py
|
get_coherent_next_tag
|
def get_coherent_next_tag(prev_label: str, cur_label: str) -> str:
"""
Generate a coherent tag, given previous tag and current label.
"""
if cur_label == "O":
# Don't need to add prefix to an "O" label
return "O"
if prev_label == cur_label:
return f"I-{cur_label}"
else:
return f"B-{cur_label}"
|
python
|
def get_coherent_next_tag(prev_label: str, cur_label: str) -> str:
"""
Generate a coherent tag, given previous tag and current label.
"""
if cur_label == "O":
# Don't need to add prefix to an "O" label
return "O"
if prev_label == cur_label:
return f"I-{cur_label}"
else:
return f"B-{cur_label}"
|
[
"def",
"get_coherent_next_tag",
"(",
"prev_label",
":",
"str",
",",
"cur_label",
":",
"str",
")",
"->",
"str",
":",
"if",
"cur_label",
"==",
"\"O\"",
":",
"# Don't need to add prefix to an \"O\" label",
"return",
"\"O\"",
"if",
"prev_label",
"==",
"cur_label",
":",
"return",
"f\"I-{cur_label}\"",
"else",
":",
"return",
"f\"B-{cur_label}\""
] |
Generate a coherent tag, given previous tag and current label.
|
[
"Generate",
"a",
"coherent",
"tag",
"given",
"previous",
"tag",
"and",
"current",
"label",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/predictors/open_information_extraction.py#L88-L99
|
train
|
allenai/allennlp
|
allennlp/predictors/open_information_extraction.py
|
merge_overlapping_predictions
|
def merge_overlapping_predictions(tags1: List[str], tags2: List[str]) -> List[str]:
"""
Merge two predictions into one. Assumes the predicate in tags1 overlap with
the predicate of tags2.
"""
ret_sequence = []
prev_label = "O"
# Build a coherent sequence out of two
# spans which predicates' overlap
for tag1, tag2 in zip(tags1, tags2):
label1 = tag1.split("-")[-1]
label2 = tag2.split("-")[-1]
if (label1 == "V") or (label2 == "V"):
# Construct maximal predicate length -
# add predicate tag if any of the sequence predict it
cur_label = "V"
# Else - prefer an argument over 'O' label
elif label1 != "O":
cur_label = label1
else:
cur_label = label2
# Append cur tag to the returned sequence
cur_tag = get_coherent_next_tag(prev_label, cur_label)
prev_label = cur_label
ret_sequence.append(cur_tag)
return ret_sequence
|
python
|
def merge_overlapping_predictions(tags1: List[str], tags2: List[str]) -> List[str]:
"""
Merge two predictions into one. Assumes the predicate in tags1 overlap with
the predicate of tags2.
"""
ret_sequence = []
prev_label = "O"
# Build a coherent sequence out of two
# spans which predicates' overlap
for tag1, tag2 in zip(tags1, tags2):
label1 = tag1.split("-")[-1]
label2 = tag2.split("-")[-1]
if (label1 == "V") or (label2 == "V"):
# Construct maximal predicate length -
# add predicate tag if any of the sequence predict it
cur_label = "V"
# Else - prefer an argument over 'O' label
elif label1 != "O":
cur_label = label1
else:
cur_label = label2
# Append cur tag to the returned sequence
cur_tag = get_coherent_next_tag(prev_label, cur_label)
prev_label = cur_label
ret_sequence.append(cur_tag)
return ret_sequence
|
[
"def",
"merge_overlapping_predictions",
"(",
"tags1",
":",
"List",
"[",
"str",
"]",
",",
"tags2",
":",
"List",
"[",
"str",
"]",
")",
"->",
"List",
"[",
"str",
"]",
":",
"ret_sequence",
"=",
"[",
"]",
"prev_label",
"=",
"\"O\"",
"# Build a coherent sequence out of two",
"# spans which predicates' overlap",
"for",
"tag1",
",",
"tag2",
"in",
"zip",
"(",
"tags1",
",",
"tags2",
")",
":",
"label1",
"=",
"tag1",
".",
"split",
"(",
"\"-\"",
")",
"[",
"-",
"1",
"]",
"label2",
"=",
"tag2",
".",
"split",
"(",
"\"-\"",
")",
"[",
"-",
"1",
"]",
"if",
"(",
"label1",
"==",
"\"V\"",
")",
"or",
"(",
"label2",
"==",
"\"V\"",
")",
":",
"# Construct maximal predicate length -",
"# add predicate tag if any of the sequence predict it",
"cur_label",
"=",
"\"V\"",
"# Else - prefer an argument over 'O' label",
"elif",
"label1",
"!=",
"\"O\"",
":",
"cur_label",
"=",
"label1",
"else",
":",
"cur_label",
"=",
"label2",
"# Append cur tag to the returned sequence",
"cur_tag",
"=",
"get_coherent_next_tag",
"(",
"prev_label",
",",
"cur_label",
")",
"prev_label",
"=",
"cur_label",
"ret_sequence",
".",
"append",
"(",
"cur_tag",
")",
"return",
"ret_sequence"
] |
Merge two predictions into one. Assumes the predicate in tags1 overlap with
the predicate of tags2.
|
[
"Merge",
"two",
"predictions",
"into",
"one",
".",
"Assumes",
"the",
"predicate",
"in",
"tags1",
"overlap",
"with",
"the",
"predicate",
"of",
"tags2",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/predictors/open_information_extraction.py#L101-L130
|
train
|
allenai/allennlp
|
allennlp/predictors/open_information_extraction.py
|
consolidate_predictions
|
def consolidate_predictions(outputs: List[List[str]], sent_tokens: List[Token]) -> Dict[str, List[str]]:
"""
Identify that certain predicates are part of a multiword predicate
(e.g., "decided to run") in which case, we don't need to return
the embedded predicate ("run").
"""
pred_dict: Dict[str, List[str]] = {}
merged_outputs = [join_mwp(output) for output in outputs]
predicate_texts = [get_predicate_text(sent_tokens, tags)
for tags in merged_outputs]
for pred1_text, tags1 in zip(predicate_texts, merged_outputs):
# A flag indicating whether to add tags1 to predictions
add_to_prediction = True
# Check if this predicate overlaps another predicate
for pred2_text, tags2 in pred_dict.items():
if predicates_overlap(tags1, tags2):
# tags1 overlaps tags2
pred_dict[pred2_text] = merge_overlapping_predictions(tags1, tags2)
add_to_prediction = False
# This predicate doesn't overlap - add as a new predicate
if add_to_prediction:
pred_dict[pred1_text] = tags1
return pred_dict
|
python
|
def consolidate_predictions(outputs: List[List[str]], sent_tokens: List[Token]) -> Dict[str, List[str]]:
"""
Identify that certain predicates are part of a multiword predicate
(e.g., "decided to run") in which case, we don't need to return
the embedded predicate ("run").
"""
pred_dict: Dict[str, List[str]] = {}
merged_outputs = [join_mwp(output) for output in outputs]
predicate_texts = [get_predicate_text(sent_tokens, tags)
for tags in merged_outputs]
for pred1_text, tags1 in zip(predicate_texts, merged_outputs):
# A flag indicating whether to add tags1 to predictions
add_to_prediction = True
# Check if this predicate overlaps another predicate
for pred2_text, tags2 in pred_dict.items():
if predicates_overlap(tags1, tags2):
# tags1 overlaps tags2
pred_dict[pred2_text] = merge_overlapping_predictions(tags1, tags2)
add_to_prediction = False
# This predicate doesn't overlap - add as a new predicate
if add_to_prediction:
pred_dict[pred1_text] = tags1
return pred_dict
|
[
"def",
"consolidate_predictions",
"(",
"outputs",
":",
"List",
"[",
"List",
"[",
"str",
"]",
"]",
",",
"sent_tokens",
":",
"List",
"[",
"Token",
"]",
")",
"->",
"Dict",
"[",
"str",
",",
"List",
"[",
"str",
"]",
"]",
":",
"pred_dict",
":",
"Dict",
"[",
"str",
",",
"List",
"[",
"str",
"]",
"]",
"=",
"{",
"}",
"merged_outputs",
"=",
"[",
"join_mwp",
"(",
"output",
")",
"for",
"output",
"in",
"outputs",
"]",
"predicate_texts",
"=",
"[",
"get_predicate_text",
"(",
"sent_tokens",
",",
"tags",
")",
"for",
"tags",
"in",
"merged_outputs",
"]",
"for",
"pred1_text",
",",
"tags1",
"in",
"zip",
"(",
"predicate_texts",
",",
"merged_outputs",
")",
":",
"# A flag indicating whether to add tags1 to predictions",
"add_to_prediction",
"=",
"True",
"# Check if this predicate overlaps another predicate",
"for",
"pred2_text",
",",
"tags2",
"in",
"pred_dict",
".",
"items",
"(",
")",
":",
"if",
"predicates_overlap",
"(",
"tags1",
",",
"tags2",
")",
":",
"# tags1 overlaps tags2",
"pred_dict",
"[",
"pred2_text",
"]",
"=",
"merge_overlapping_predictions",
"(",
"tags1",
",",
"tags2",
")",
"add_to_prediction",
"=",
"False",
"# This predicate doesn't overlap - add as a new predicate",
"if",
"add_to_prediction",
":",
"pred_dict",
"[",
"pred1_text",
"]",
"=",
"tags1",
"return",
"pred_dict"
] |
Identify that certain predicates are part of a multiword predicate
(e.g., "decided to run") in which case, we don't need to return
the embedded predicate ("run").
|
[
"Identify",
"that",
"certain",
"predicates",
"are",
"part",
"of",
"a",
"multiword",
"predicate",
"(",
"e",
".",
"g",
".",
"decided",
"to",
"run",
")",
"in",
"which",
"case",
"we",
"don",
"t",
"need",
"to",
"return",
"the",
"embedded",
"predicate",
"(",
"run",
")",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/predictors/open_information_extraction.py#L132-L158
|
train
|
allenai/allennlp
|
allennlp/predictors/open_information_extraction.py
|
sanitize_label
|
def sanitize_label(label: str) -> str:
"""
Sanitize a BIO label - this deals with OIE
labels sometimes having some noise, as parentheses.
"""
if "-" in label:
prefix, suffix = label.split("-")
suffix = suffix.split("(")[-1]
return f"{prefix}-{suffix}"
else:
return label
|
python
|
def sanitize_label(label: str) -> str:
"""
Sanitize a BIO label - this deals with OIE
labels sometimes having some noise, as parentheses.
"""
if "-" in label:
prefix, suffix = label.split("-")
suffix = suffix.split("(")[-1]
return f"{prefix}-{suffix}"
else:
return label
|
[
"def",
"sanitize_label",
"(",
"label",
":",
"str",
")",
"->",
"str",
":",
"if",
"\"-\"",
"in",
"label",
":",
"prefix",
",",
"suffix",
"=",
"label",
".",
"split",
"(",
"\"-\"",
")",
"suffix",
"=",
"suffix",
".",
"split",
"(",
"\"(\"",
")",
"[",
"-",
"1",
"]",
"return",
"f\"{prefix}-{suffix}\"",
"else",
":",
"return",
"label"
] |
Sanitize a BIO label - this deals with OIE
labels sometimes having some noise, as parentheses.
|
[
"Sanitize",
"a",
"BIO",
"label",
"-",
"this",
"deals",
"with",
"OIE",
"labels",
"sometimes",
"having",
"some",
"noise",
"as",
"parentheses",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/predictors/open_information_extraction.py#L161-L171
|
train
|
allenai/allennlp
|
allennlp/modules/elmo.py
|
batch_to_ids
|
def batch_to_ids(batch: List[List[str]]) -> torch.Tensor:
"""
Converts a batch of tokenized sentences to a tensor representing the sentences with encoded characters
(len(batch), max sentence length, max word length).
Parameters
----------
batch : ``List[List[str]]``, required
A list of tokenized sentences.
Returns
-------
A tensor of padded character ids.
"""
instances = []
indexer = ELMoTokenCharactersIndexer()
for sentence in batch:
tokens = [Token(token) for token in sentence]
field = TextField(tokens,
{'character_ids': indexer})
instance = Instance({"elmo": field})
instances.append(instance)
dataset = Batch(instances)
vocab = Vocabulary()
dataset.index_instances(vocab)
return dataset.as_tensor_dict()['elmo']['character_ids']
|
python
|
def batch_to_ids(batch: List[List[str]]) -> torch.Tensor:
"""
Converts a batch of tokenized sentences to a tensor representing the sentences with encoded characters
(len(batch), max sentence length, max word length).
Parameters
----------
batch : ``List[List[str]]``, required
A list of tokenized sentences.
Returns
-------
A tensor of padded character ids.
"""
instances = []
indexer = ELMoTokenCharactersIndexer()
for sentence in batch:
tokens = [Token(token) for token in sentence]
field = TextField(tokens,
{'character_ids': indexer})
instance = Instance({"elmo": field})
instances.append(instance)
dataset = Batch(instances)
vocab = Vocabulary()
dataset.index_instances(vocab)
return dataset.as_tensor_dict()['elmo']['character_ids']
|
[
"def",
"batch_to_ids",
"(",
"batch",
":",
"List",
"[",
"List",
"[",
"str",
"]",
"]",
")",
"->",
"torch",
".",
"Tensor",
":",
"instances",
"=",
"[",
"]",
"indexer",
"=",
"ELMoTokenCharactersIndexer",
"(",
")",
"for",
"sentence",
"in",
"batch",
":",
"tokens",
"=",
"[",
"Token",
"(",
"token",
")",
"for",
"token",
"in",
"sentence",
"]",
"field",
"=",
"TextField",
"(",
"tokens",
",",
"{",
"'character_ids'",
":",
"indexer",
"}",
")",
"instance",
"=",
"Instance",
"(",
"{",
"\"elmo\"",
":",
"field",
"}",
")",
"instances",
".",
"append",
"(",
"instance",
")",
"dataset",
"=",
"Batch",
"(",
"instances",
")",
"vocab",
"=",
"Vocabulary",
"(",
")",
"dataset",
".",
"index_instances",
"(",
"vocab",
")",
"return",
"dataset",
".",
"as_tensor_dict",
"(",
")",
"[",
"'elmo'",
"]",
"[",
"'character_ids'",
"]"
] |
Converts a batch of tokenized sentences to a tensor representing the sentences with encoded characters
(len(batch), max sentence length, max word length).
Parameters
----------
batch : ``List[List[str]]``, required
A list of tokenized sentences.
Returns
-------
A tensor of padded character ids.
|
[
"Converts",
"a",
"batch",
"of",
"tokenized",
"sentences",
"to",
"a",
"tensor",
"representing",
"the",
"sentences",
"with",
"encoded",
"characters",
"(",
"len",
"(",
"batch",
")",
"max",
"sentence",
"length",
"max",
"word",
"length",
")",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/modules/elmo.py#L230-L256
|
train
|
allenai/allennlp
|
allennlp/modules/elmo.py
|
Elmo.forward
|
def forward(self, # pylint: disable=arguments-differ
inputs: torch.Tensor,
word_inputs: torch.Tensor = None) -> Dict[str, Union[torch.Tensor, List[torch.Tensor]]]:
"""
Parameters
----------
inputs: ``torch.Tensor``, required.
Shape ``(batch_size, timesteps, 50)`` of character ids representing the current batch.
word_inputs : ``torch.Tensor``, required.
If you passed a cached vocab, you can in addition pass a tensor of shape
``(batch_size, timesteps)``, which represent word ids which have been pre-cached.
Returns
-------
Dict with keys:
``'elmo_representations'``: ``List[torch.Tensor]``
A ``num_output_representations`` list of ELMo representations for the input sequence.
Each representation is shape ``(batch_size, timesteps, embedding_dim)``
``'mask'``: ``torch.Tensor``
Shape ``(batch_size, timesteps)`` long tensor with sequence mask.
"""
# reshape the input if needed
original_shape = inputs.size()
if len(original_shape) > 3:
timesteps, num_characters = original_shape[-2:]
reshaped_inputs = inputs.view(-1, timesteps, num_characters)
else:
reshaped_inputs = inputs
if word_inputs is not None:
original_word_size = word_inputs.size()
if self._has_cached_vocab and len(original_word_size) > 2:
reshaped_word_inputs = word_inputs.view(-1, original_word_size[-1])
elif not self._has_cached_vocab:
logger.warning("Word inputs were passed to ELMo but it does not have a cached vocab.")
reshaped_word_inputs = None
else:
reshaped_word_inputs = word_inputs
else:
reshaped_word_inputs = word_inputs
# run the biLM
bilm_output = self._elmo_lstm(reshaped_inputs, reshaped_word_inputs)
layer_activations = bilm_output['activations']
mask_with_bos_eos = bilm_output['mask']
# compute the elmo representations
representations = []
for i in range(len(self._scalar_mixes)):
scalar_mix = getattr(self, 'scalar_mix_{}'.format(i))
representation_with_bos_eos = scalar_mix(layer_activations, mask_with_bos_eos)
if self._keep_sentence_boundaries:
processed_representation = representation_with_bos_eos
processed_mask = mask_with_bos_eos
else:
representation_without_bos_eos, mask_without_bos_eos = remove_sentence_boundaries(
representation_with_bos_eos, mask_with_bos_eos)
processed_representation = representation_without_bos_eos
processed_mask = mask_without_bos_eos
representations.append(self._dropout(processed_representation))
# reshape if necessary
if word_inputs is not None and len(original_word_size) > 2:
mask = processed_mask.view(original_word_size)
elmo_representations = [representation.view(original_word_size + (-1, ))
for representation in representations]
elif len(original_shape) > 3:
mask = processed_mask.view(original_shape[:-1])
elmo_representations = [representation.view(original_shape[:-1] + (-1, ))
for representation in representations]
else:
mask = processed_mask
elmo_representations = representations
return {'elmo_representations': elmo_representations, 'mask': mask}
|
python
|
def forward(self, # pylint: disable=arguments-differ
inputs: torch.Tensor,
word_inputs: torch.Tensor = None) -> Dict[str, Union[torch.Tensor, List[torch.Tensor]]]:
"""
Parameters
----------
inputs: ``torch.Tensor``, required.
Shape ``(batch_size, timesteps, 50)`` of character ids representing the current batch.
word_inputs : ``torch.Tensor``, required.
If you passed a cached vocab, you can in addition pass a tensor of shape
``(batch_size, timesteps)``, which represent word ids which have been pre-cached.
Returns
-------
Dict with keys:
``'elmo_representations'``: ``List[torch.Tensor]``
A ``num_output_representations`` list of ELMo representations for the input sequence.
Each representation is shape ``(batch_size, timesteps, embedding_dim)``
``'mask'``: ``torch.Tensor``
Shape ``(batch_size, timesteps)`` long tensor with sequence mask.
"""
# reshape the input if needed
original_shape = inputs.size()
if len(original_shape) > 3:
timesteps, num_characters = original_shape[-2:]
reshaped_inputs = inputs.view(-1, timesteps, num_characters)
else:
reshaped_inputs = inputs
if word_inputs is not None:
original_word_size = word_inputs.size()
if self._has_cached_vocab and len(original_word_size) > 2:
reshaped_word_inputs = word_inputs.view(-1, original_word_size[-1])
elif not self._has_cached_vocab:
logger.warning("Word inputs were passed to ELMo but it does not have a cached vocab.")
reshaped_word_inputs = None
else:
reshaped_word_inputs = word_inputs
else:
reshaped_word_inputs = word_inputs
# run the biLM
bilm_output = self._elmo_lstm(reshaped_inputs, reshaped_word_inputs)
layer_activations = bilm_output['activations']
mask_with_bos_eos = bilm_output['mask']
# compute the elmo representations
representations = []
for i in range(len(self._scalar_mixes)):
scalar_mix = getattr(self, 'scalar_mix_{}'.format(i))
representation_with_bos_eos = scalar_mix(layer_activations, mask_with_bos_eos)
if self._keep_sentence_boundaries:
processed_representation = representation_with_bos_eos
processed_mask = mask_with_bos_eos
else:
representation_without_bos_eos, mask_without_bos_eos = remove_sentence_boundaries(
representation_with_bos_eos, mask_with_bos_eos)
processed_representation = representation_without_bos_eos
processed_mask = mask_without_bos_eos
representations.append(self._dropout(processed_representation))
# reshape if necessary
if word_inputs is not None and len(original_word_size) > 2:
mask = processed_mask.view(original_word_size)
elmo_representations = [representation.view(original_word_size + (-1, ))
for representation in representations]
elif len(original_shape) > 3:
mask = processed_mask.view(original_shape[:-1])
elmo_representations = [representation.view(original_shape[:-1] + (-1, ))
for representation in representations]
else:
mask = processed_mask
elmo_representations = representations
return {'elmo_representations': elmo_representations, 'mask': mask}
|
[
"def",
"forward",
"(",
"self",
",",
"# pylint: disable=arguments-differ",
"inputs",
":",
"torch",
".",
"Tensor",
",",
"word_inputs",
":",
"torch",
".",
"Tensor",
"=",
"None",
")",
"->",
"Dict",
"[",
"str",
",",
"Union",
"[",
"torch",
".",
"Tensor",
",",
"List",
"[",
"torch",
".",
"Tensor",
"]",
"]",
"]",
":",
"# reshape the input if needed",
"original_shape",
"=",
"inputs",
".",
"size",
"(",
")",
"if",
"len",
"(",
"original_shape",
")",
">",
"3",
":",
"timesteps",
",",
"num_characters",
"=",
"original_shape",
"[",
"-",
"2",
":",
"]",
"reshaped_inputs",
"=",
"inputs",
".",
"view",
"(",
"-",
"1",
",",
"timesteps",
",",
"num_characters",
")",
"else",
":",
"reshaped_inputs",
"=",
"inputs",
"if",
"word_inputs",
"is",
"not",
"None",
":",
"original_word_size",
"=",
"word_inputs",
".",
"size",
"(",
")",
"if",
"self",
".",
"_has_cached_vocab",
"and",
"len",
"(",
"original_word_size",
")",
">",
"2",
":",
"reshaped_word_inputs",
"=",
"word_inputs",
".",
"view",
"(",
"-",
"1",
",",
"original_word_size",
"[",
"-",
"1",
"]",
")",
"elif",
"not",
"self",
".",
"_has_cached_vocab",
":",
"logger",
".",
"warning",
"(",
"\"Word inputs were passed to ELMo but it does not have a cached vocab.\"",
")",
"reshaped_word_inputs",
"=",
"None",
"else",
":",
"reshaped_word_inputs",
"=",
"word_inputs",
"else",
":",
"reshaped_word_inputs",
"=",
"word_inputs",
"# run the biLM",
"bilm_output",
"=",
"self",
".",
"_elmo_lstm",
"(",
"reshaped_inputs",
",",
"reshaped_word_inputs",
")",
"layer_activations",
"=",
"bilm_output",
"[",
"'activations'",
"]",
"mask_with_bos_eos",
"=",
"bilm_output",
"[",
"'mask'",
"]",
"# compute the elmo representations",
"representations",
"=",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"self",
".",
"_scalar_mixes",
")",
")",
":",
"scalar_mix",
"=",
"getattr",
"(",
"self",
",",
"'scalar_mix_{}'",
".",
"format",
"(",
"i",
")",
")",
"representation_with_bos_eos",
"=",
"scalar_mix",
"(",
"layer_activations",
",",
"mask_with_bos_eos",
")",
"if",
"self",
".",
"_keep_sentence_boundaries",
":",
"processed_representation",
"=",
"representation_with_bos_eos",
"processed_mask",
"=",
"mask_with_bos_eos",
"else",
":",
"representation_without_bos_eos",
",",
"mask_without_bos_eos",
"=",
"remove_sentence_boundaries",
"(",
"representation_with_bos_eos",
",",
"mask_with_bos_eos",
")",
"processed_representation",
"=",
"representation_without_bos_eos",
"processed_mask",
"=",
"mask_without_bos_eos",
"representations",
".",
"append",
"(",
"self",
".",
"_dropout",
"(",
"processed_representation",
")",
")",
"# reshape if necessary",
"if",
"word_inputs",
"is",
"not",
"None",
"and",
"len",
"(",
"original_word_size",
")",
">",
"2",
":",
"mask",
"=",
"processed_mask",
".",
"view",
"(",
"original_word_size",
")",
"elmo_representations",
"=",
"[",
"representation",
".",
"view",
"(",
"original_word_size",
"+",
"(",
"-",
"1",
",",
")",
")",
"for",
"representation",
"in",
"representations",
"]",
"elif",
"len",
"(",
"original_shape",
")",
">",
"3",
":",
"mask",
"=",
"processed_mask",
".",
"view",
"(",
"original_shape",
"[",
":",
"-",
"1",
"]",
")",
"elmo_representations",
"=",
"[",
"representation",
".",
"view",
"(",
"original_shape",
"[",
":",
"-",
"1",
"]",
"+",
"(",
"-",
"1",
",",
")",
")",
"for",
"representation",
"in",
"representations",
"]",
"else",
":",
"mask",
"=",
"processed_mask",
"elmo_representations",
"=",
"representations",
"return",
"{",
"'elmo_representations'",
":",
"elmo_representations",
",",
"'mask'",
":",
"mask",
"}"
] |
Parameters
----------
inputs: ``torch.Tensor``, required.
Shape ``(batch_size, timesteps, 50)`` of character ids representing the current batch.
word_inputs : ``torch.Tensor``, required.
If you passed a cached vocab, you can in addition pass a tensor of shape
``(batch_size, timesteps)``, which represent word ids which have been pre-cached.
Returns
-------
Dict with keys:
``'elmo_representations'``: ``List[torch.Tensor]``
A ``num_output_representations`` list of ELMo representations for the input sequence.
Each representation is shape ``(batch_size, timesteps, embedding_dim)``
``'mask'``: ``torch.Tensor``
Shape ``(batch_size, timesteps)`` long tensor with sequence mask.
|
[
"Parameters",
"----------",
"inputs",
":",
"torch",
".",
"Tensor",
"required",
".",
"Shape",
"(",
"batch_size",
"timesteps",
"50",
")",
"of",
"character",
"ids",
"representing",
"the",
"current",
"batch",
".",
"word_inputs",
":",
"torch",
".",
"Tensor",
"required",
".",
"If",
"you",
"passed",
"a",
"cached",
"vocab",
"you",
"can",
"in",
"addition",
"pass",
"a",
"tensor",
"of",
"shape",
"(",
"batch_size",
"timesteps",
")",
"which",
"represent",
"word",
"ids",
"which",
"have",
"been",
"pre",
"-",
"cached",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/modules/elmo.py#L127-L201
|
train
|
allenai/allennlp
|
allennlp/modules/elmo.py
|
_ElmoCharacterEncoder.forward
|
def forward(self, inputs: torch.Tensor) -> Dict[str, torch.Tensor]: # pylint: disable=arguments-differ
"""
Compute context insensitive token embeddings for ELMo representations.
Parameters
----------
inputs: ``torch.Tensor``
Shape ``(batch_size, sequence_length, 50)`` of character ids representing the
current batch.
Returns
-------
Dict with keys:
``'token_embedding'``: ``torch.Tensor``
Shape ``(batch_size, sequence_length + 2, embedding_dim)`` tensor with context
insensitive token representations.
``'mask'``: ``torch.Tensor``
Shape ``(batch_size, sequence_length + 2)`` long tensor with sequence mask.
"""
# Add BOS/EOS
mask = ((inputs > 0).long().sum(dim=-1) > 0).long()
character_ids_with_bos_eos, mask_with_bos_eos = add_sentence_boundary_token_ids(
inputs,
mask,
self._beginning_of_sentence_characters,
self._end_of_sentence_characters
)
# the character id embedding
max_chars_per_token = self._options['char_cnn']['max_characters_per_token']
# (batch_size * sequence_length, max_chars_per_token, embed_dim)
character_embedding = torch.nn.functional.embedding(
character_ids_with_bos_eos.view(-1, max_chars_per_token),
self._char_embedding_weights
)
# run convolutions
cnn_options = self._options['char_cnn']
if cnn_options['activation'] == 'tanh':
activation = torch.tanh
elif cnn_options['activation'] == 'relu':
activation = torch.nn.functional.relu
else:
raise ConfigurationError("Unknown activation")
# (batch_size * sequence_length, embed_dim, max_chars_per_token)
character_embedding = torch.transpose(character_embedding, 1, 2)
convs = []
for i in range(len(self._convolutions)):
conv = getattr(self, 'char_conv_{}'.format(i))
convolved = conv(character_embedding)
# (batch_size * sequence_length, n_filters for this width)
convolved, _ = torch.max(convolved, dim=-1)
convolved = activation(convolved)
convs.append(convolved)
# (batch_size * sequence_length, n_filters)
token_embedding = torch.cat(convs, dim=-1)
# apply the highway layers (batch_size * sequence_length, n_filters)
token_embedding = self._highways(token_embedding)
# final projection (batch_size * sequence_length, embedding_dim)
token_embedding = self._projection(token_embedding)
# reshape to (batch_size, sequence_length, embedding_dim)
batch_size, sequence_length, _ = character_ids_with_bos_eos.size()
return {
'mask': mask_with_bos_eos,
'token_embedding': token_embedding.view(batch_size, sequence_length, -1)
}
|
python
|
def forward(self, inputs: torch.Tensor) -> Dict[str, torch.Tensor]: # pylint: disable=arguments-differ
"""
Compute context insensitive token embeddings for ELMo representations.
Parameters
----------
inputs: ``torch.Tensor``
Shape ``(batch_size, sequence_length, 50)`` of character ids representing the
current batch.
Returns
-------
Dict with keys:
``'token_embedding'``: ``torch.Tensor``
Shape ``(batch_size, sequence_length + 2, embedding_dim)`` tensor with context
insensitive token representations.
``'mask'``: ``torch.Tensor``
Shape ``(batch_size, sequence_length + 2)`` long tensor with sequence mask.
"""
# Add BOS/EOS
mask = ((inputs > 0).long().sum(dim=-1) > 0).long()
character_ids_with_bos_eos, mask_with_bos_eos = add_sentence_boundary_token_ids(
inputs,
mask,
self._beginning_of_sentence_characters,
self._end_of_sentence_characters
)
# the character id embedding
max_chars_per_token = self._options['char_cnn']['max_characters_per_token']
# (batch_size * sequence_length, max_chars_per_token, embed_dim)
character_embedding = torch.nn.functional.embedding(
character_ids_with_bos_eos.view(-1, max_chars_per_token),
self._char_embedding_weights
)
# run convolutions
cnn_options = self._options['char_cnn']
if cnn_options['activation'] == 'tanh':
activation = torch.tanh
elif cnn_options['activation'] == 'relu':
activation = torch.nn.functional.relu
else:
raise ConfigurationError("Unknown activation")
# (batch_size * sequence_length, embed_dim, max_chars_per_token)
character_embedding = torch.transpose(character_embedding, 1, 2)
convs = []
for i in range(len(self._convolutions)):
conv = getattr(self, 'char_conv_{}'.format(i))
convolved = conv(character_embedding)
# (batch_size * sequence_length, n_filters for this width)
convolved, _ = torch.max(convolved, dim=-1)
convolved = activation(convolved)
convs.append(convolved)
# (batch_size * sequence_length, n_filters)
token_embedding = torch.cat(convs, dim=-1)
# apply the highway layers (batch_size * sequence_length, n_filters)
token_embedding = self._highways(token_embedding)
# final projection (batch_size * sequence_length, embedding_dim)
token_embedding = self._projection(token_embedding)
# reshape to (batch_size, sequence_length, embedding_dim)
batch_size, sequence_length, _ = character_ids_with_bos_eos.size()
return {
'mask': mask_with_bos_eos,
'token_embedding': token_embedding.view(batch_size, sequence_length, -1)
}
|
[
"def",
"forward",
"(",
"self",
",",
"inputs",
":",
"torch",
".",
"Tensor",
")",
"->",
"Dict",
"[",
"str",
",",
"torch",
".",
"Tensor",
"]",
":",
"# pylint: disable=arguments-differ",
"# Add BOS/EOS",
"mask",
"=",
"(",
"(",
"inputs",
">",
"0",
")",
".",
"long",
"(",
")",
".",
"sum",
"(",
"dim",
"=",
"-",
"1",
")",
">",
"0",
")",
".",
"long",
"(",
")",
"character_ids_with_bos_eos",
",",
"mask_with_bos_eos",
"=",
"add_sentence_boundary_token_ids",
"(",
"inputs",
",",
"mask",
",",
"self",
".",
"_beginning_of_sentence_characters",
",",
"self",
".",
"_end_of_sentence_characters",
")",
"# the character id embedding",
"max_chars_per_token",
"=",
"self",
".",
"_options",
"[",
"'char_cnn'",
"]",
"[",
"'max_characters_per_token'",
"]",
"# (batch_size * sequence_length, max_chars_per_token, embed_dim)",
"character_embedding",
"=",
"torch",
".",
"nn",
".",
"functional",
".",
"embedding",
"(",
"character_ids_with_bos_eos",
".",
"view",
"(",
"-",
"1",
",",
"max_chars_per_token",
")",
",",
"self",
".",
"_char_embedding_weights",
")",
"# run convolutions",
"cnn_options",
"=",
"self",
".",
"_options",
"[",
"'char_cnn'",
"]",
"if",
"cnn_options",
"[",
"'activation'",
"]",
"==",
"'tanh'",
":",
"activation",
"=",
"torch",
".",
"tanh",
"elif",
"cnn_options",
"[",
"'activation'",
"]",
"==",
"'relu'",
":",
"activation",
"=",
"torch",
".",
"nn",
".",
"functional",
".",
"relu",
"else",
":",
"raise",
"ConfigurationError",
"(",
"\"Unknown activation\"",
")",
"# (batch_size * sequence_length, embed_dim, max_chars_per_token)",
"character_embedding",
"=",
"torch",
".",
"transpose",
"(",
"character_embedding",
",",
"1",
",",
"2",
")",
"convs",
"=",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"self",
".",
"_convolutions",
")",
")",
":",
"conv",
"=",
"getattr",
"(",
"self",
",",
"'char_conv_{}'",
".",
"format",
"(",
"i",
")",
")",
"convolved",
"=",
"conv",
"(",
"character_embedding",
")",
"# (batch_size * sequence_length, n_filters for this width)",
"convolved",
",",
"_",
"=",
"torch",
".",
"max",
"(",
"convolved",
",",
"dim",
"=",
"-",
"1",
")",
"convolved",
"=",
"activation",
"(",
"convolved",
")",
"convs",
".",
"append",
"(",
"convolved",
")",
"# (batch_size * sequence_length, n_filters)",
"token_embedding",
"=",
"torch",
".",
"cat",
"(",
"convs",
",",
"dim",
"=",
"-",
"1",
")",
"# apply the highway layers (batch_size * sequence_length, n_filters)",
"token_embedding",
"=",
"self",
".",
"_highways",
"(",
"token_embedding",
")",
"# final projection (batch_size * sequence_length, embedding_dim)",
"token_embedding",
"=",
"self",
".",
"_projection",
"(",
"token_embedding",
")",
"# reshape to (batch_size, sequence_length, embedding_dim)",
"batch_size",
",",
"sequence_length",
",",
"_",
"=",
"character_ids_with_bos_eos",
".",
"size",
"(",
")",
"return",
"{",
"'mask'",
":",
"mask_with_bos_eos",
",",
"'token_embedding'",
":",
"token_embedding",
".",
"view",
"(",
"batch_size",
",",
"sequence_length",
",",
"-",
"1",
")",
"}"
] |
Compute context insensitive token embeddings for ELMo representations.
Parameters
----------
inputs: ``torch.Tensor``
Shape ``(batch_size, sequence_length, 50)`` of character ids representing the
current batch.
Returns
-------
Dict with keys:
``'token_embedding'``: ``torch.Tensor``
Shape ``(batch_size, sequence_length + 2, embedding_dim)`` tensor with context
insensitive token representations.
``'mask'``: ``torch.Tensor``
Shape ``(batch_size, sequence_length + 2)`` long tensor with sequence mask.
|
[
"Compute",
"context",
"insensitive",
"token",
"embeddings",
"for",
"ELMo",
"representations",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/modules/elmo.py#L324-L395
|
train
|
allenai/allennlp
|
allennlp/modules/elmo.py
|
_ElmoBiLm.forward
|
def forward(self, # pylint: disable=arguments-differ
inputs: torch.Tensor,
word_inputs: torch.Tensor = None) -> Dict[str, Union[torch.Tensor, List[torch.Tensor]]]:
"""
Parameters
----------
inputs: ``torch.Tensor``, required.
Shape ``(batch_size, timesteps, 50)`` of character ids representing the current batch.
word_inputs : ``torch.Tensor``, required.
If you passed a cached vocab, you can in addition pass a tensor of shape ``(batch_size, timesteps)``,
which represent word ids which have been pre-cached.
Returns
-------
Dict with keys:
``'activations'``: ``List[torch.Tensor]``
A list of activations at each layer of the network, each of shape
``(batch_size, timesteps + 2, embedding_dim)``
``'mask'``: ``torch.Tensor``
Shape ``(batch_size, timesteps + 2)`` long tensor with sequence mask.
Note that the output tensors all include additional special begin and end of sequence
markers.
"""
if self._word_embedding is not None and word_inputs is not None:
try:
mask_without_bos_eos = (word_inputs > 0).long()
# The character cnn part is cached - just look it up.
embedded_inputs = self._word_embedding(word_inputs) # type: ignore
# shape (batch_size, timesteps + 2, embedding_dim)
type_representation, mask = add_sentence_boundary_token_ids(
embedded_inputs,
mask_without_bos_eos,
self._bos_embedding,
self._eos_embedding
)
except RuntimeError:
# Back off to running the character convolutions,
# as we might not have the words in the cache.
token_embedding = self._token_embedder(inputs)
mask = token_embedding['mask']
type_representation = token_embedding['token_embedding']
else:
token_embedding = self._token_embedder(inputs)
mask = token_embedding['mask']
type_representation = token_embedding['token_embedding']
lstm_outputs = self._elmo_lstm(type_representation, mask)
# Prepare the output. The first layer is duplicated.
# Because of minor differences in how masking is applied depending
# on whether the char cnn layers are cached, we'll be defensive and
# multiply by the mask here. It's not strictly necessary, as the
# mask passed on is correct, but the values in the padded areas
# of the char cnn representations can change.
output_tensors = [
torch.cat([type_representation, type_representation], dim=-1) * mask.float().unsqueeze(-1)
]
for layer_activations in torch.chunk(lstm_outputs, lstm_outputs.size(0), dim=0):
output_tensors.append(layer_activations.squeeze(0))
return {
'activations': output_tensors,
'mask': mask,
}
|
python
|
def forward(self, # pylint: disable=arguments-differ
inputs: torch.Tensor,
word_inputs: torch.Tensor = None) -> Dict[str, Union[torch.Tensor, List[torch.Tensor]]]:
"""
Parameters
----------
inputs: ``torch.Tensor``, required.
Shape ``(batch_size, timesteps, 50)`` of character ids representing the current batch.
word_inputs : ``torch.Tensor``, required.
If you passed a cached vocab, you can in addition pass a tensor of shape ``(batch_size, timesteps)``,
which represent word ids which have been pre-cached.
Returns
-------
Dict with keys:
``'activations'``: ``List[torch.Tensor]``
A list of activations at each layer of the network, each of shape
``(batch_size, timesteps + 2, embedding_dim)``
``'mask'``: ``torch.Tensor``
Shape ``(batch_size, timesteps + 2)`` long tensor with sequence mask.
Note that the output tensors all include additional special begin and end of sequence
markers.
"""
if self._word_embedding is not None and word_inputs is not None:
try:
mask_without_bos_eos = (word_inputs > 0).long()
# The character cnn part is cached - just look it up.
embedded_inputs = self._word_embedding(word_inputs) # type: ignore
# shape (batch_size, timesteps + 2, embedding_dim)
type_representation, mask = add_sentence_boundary_token_ids(
embedded_inputs,
mask_without_bos_eos,
self._bos_embedding,
self._eos_embedding
)
except RuntimeError:
# Back off to running the character convolutions,
# as we might not have the words in the cache.
token_embedding = self._token_embedder(inputs)
mask = token_embedding['mask']
type_representation = token_embedding['token_embedding']
else:
token_embedding = self._token_embedder(inputs)
mask = token_embedding['mask']
type_representation = token_embedding['token_embedding']
lstm_outputs = self._elmo_lstm(type_representation, mask)
# Prepare the output. The first layer is duplicated.
# Because of minor differences in how masking is applied depending
# on whether the char cnn layers are cached, we'll be defensive and
# multiply by the mask here. It's not strictly necessary, as the
# mask passed on is correct, but the values in the padded areas
# of the char cnn representations can change.
output_tensors = [
torch.cat([type_representation, type_representation], dim=-1) * mask.float().unsqueeze(-1)
]
for layer_activations in torch.chunk(lstm_outputs, lstm_outputs.size(0), dim=0):
output_tensors.append(layer_activations.squeeze(0))
return {
'activations': output_tensors,
'mask': mask,
}
|
[
"def",
"forward",
"(",
"self",
",",
"# pylint: disable=arguments-differ",
"inputs",
":",
"torch",
".",
"Tensor",
",",
"word_inputs",
":",
"torch",
".",
"Tensor",
"=",
"None",
")",
"->",
"Dict",
"[",
"str",
",",
"Union",
"[",
"torch",
".",
"Tensor",
",",
"List",
"[",
"torch",
".",
"Tensor",
"]",
"]",
"]",
":",
"if",
"self",
".",
"_word_embedding",
"is",
"not",
"None",
"and",
"word_inputs",
"is",
"not",
"None",
":",
"try",
":",
"mask_without_bos_eos",
"=",
"(",
"word_inputs",
">",
"0",
")",
".",
"long",
"(",
")",
"# The character cnn part is cached - just look it up.",
"embedded_inputs",
"=",
"self",
".",
"_word_embedding",
"(",
"word_inputs",
")",
"# type: ignore",
"# shape (batch_size, timesteps + 2, embedding_dim)",
"type_representation",
",",
"mask",
"=",
"add_sentence_boundary_token_ids",
"(",
"embedded_inputs",
",",
"mask_without_bos_eos",
",",
"self",
".",
"_bos_embedding",
",",
"self",
".",
"_eos_embedding",
")",
"except",
"RuntimeError",
":",
"# Back off to running the character convolutions,",
"# as we might not have the words in the cache.",
"token_embedding",
"=",
"self",
".",
"_token_embedder",
"(",
"inputs",
")",
"mask",
"=",
"token_embedding",
"[",
"'mask'",
"]",
"type_representation",
"=",
"token_embedding",
"[",
"'token_embedding'",
"]",
"else",
":",
"token_embedding",
"=",
"self",
".",
"_token_embedder",
"(",
"inputs",
")",
"mask",
"=",
"token_embedding",
"[",
"'mask'",
"]",
"type_representation",
"=",
"token_embedding",
"[",
"'token_embedding'",
"]",
"lstm_outputs",
"=",
"self",
".",
"_elmo_lstm",
"(",
"type_representation",
",",
"mask",
")",
"# Prepare the output. The first layer is duplicated.",
"# Because of minor differences in how masking is applied depending",
"# on whether the char cnn layers are cached, we'll be defensive and",
"# multiply by the mask here. It's not strictly necessary, as the",
"# mask passed on is correct, but the values in the padded areas",
"# of the char cnn representations can change.",
"output_tensors",
"=",
"[",
"torch",
".",
"cat",
"(",
"[",
"type_representation",
",",
"type_representation",
"]",
",",
"dim",
"=",
"-",
"1",
")",
"*",
"mask",
".",
"float",
"(",
")",
".",
"unsqueeze",
"(",
"-",
"1",
")",
"]",
"for",
"layer_activations",
"in",
"torch",
".",
"chunk",
"(",
"lstm_outputs",
",",
"lstm_outputs",
".",
"size",
"(",
"0",
")",
",",
"dim",
"=",
"0",
")",
":",
"output_tensors",
".",
"append",
"(",
"layer_activations",
".",
"squeeze",
"(",
"0",
")",
")",
"return",
"{",
"'activations'",
":",
"output_tensors",
",",
"'mask'",
":",
"mask",
",",
"}"
] |
Parameters
----------
inputs: ``torch.Tensor``, required.
Shape ``(batch_size, timesteps, 50)`` of character ids representing the current batch.
word_inputs : ``torch.Tensor``, required.
If you passed a cached vocab, you can in addition pass a tensor of shape ``(batch_size, timesteps)``,
which represent word ids which have been pre-cached.
Returns
-------
Dict with keys:
``'activations'``: ``List[torch.Tensor]``
A list of activations at each layer of the network, each of shape
``(batch_size, timesteps + 2, embedding_dim)``
``'mask'``: ``torch.Tensor``
Shape ``(batch_size, timesteps + 2)`` long tensor with sequence mask.
Note that the output tensors all include additional special begin and end of sequence
markers.
|
[
"Parameters",
"----------",
"inputs",
":",
"torch",
".",
"Tensor",
"required",
".",
"Shape",
"(",
"batch_size",
"timesteps",
"50",
")",
"of",
"character",
"ids",
"representing",
"the",
"current",
"batch",
".",
"word_inputs",
":",
"torch",
".",
"Tensor",
"required",
".",
"If",
"you",
"passed",
"a",
"cached",
"vocab",
"you",
"can",
"in",
"addition",
"pass",
"a",
"tensor",
"of",
"shape",
"(",
"batch_size",
"timesteps",
")",
"which",
"represent",
"word",
"ids",
"which",
"have",
"been",
"pre",
"-",
"cached",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/modules/elmo.py#L561-L625
|
train
|
allenai/allennlp
|
allennlp/modules/elmo.py
|
_ElmoBiLm.create_cached_cnn_embeddings
|
def create_cached_cnn_embeddings(self, tokens: List[str]) -> None:
"""
Given a list of tokens, this method precomputes word representations
by running just the character convolutions and highway layers of elmo,
essentially creating uncontextual word vectors. On subsequent forward passes,
the word ids are looked up from an embedding, rather than being computed on
the fly via the CNN encoder.
This function sets 3 attributes:
_word_embedding : ``torch.Tensor``
The word embedding for each word in the tokens passed to this method.
_bos_embedding : ``torch.Tensor``
The embedding for the BOS token.
_eos_embedding : ``torch.Tensor``
The embedding for the EOS token.
Parameters
----------
tokens : ``List[str]``, required.
A list of tokens to precompute character convolutions for.
"""
tokens = [ELMoCharacterMapper.bos_token, ELMoCharacterMapper.eos_token] + tokens
timesteps = 32
batch_size = 32
chunked_tokens = lazy_groups_of(iter(tokens), timesteps)
all_embeddings = []
device = get_device_of(next(self.parameters()))
for batch in lazy_groups_of(chunked_tokens, batch_size):
# Shape (batch_size, timesteps, 50)
batched_tensor = batch_to_ids(batch)
# NOTE: This device check is for when a user calls this method having
# already placed the model on a device. If this is called in the
# constructor, it will probably happen on the CPU. This isn't too bad,
# because it's only a few convolutions and will likely be very fast.
if device >= 0:
batched_tensor = batched_tensor.cuda(device)
output = self._token_embedder(batched_tensor)
token_embedding = output["token_embedding"]
mask = output["mask"]
token_embedding, _ = remove_sentence_boundaries(token_embedding, mask)
all_embeddings.append(token_embedding.view(-1, token_embedding.size(-1)))
full_embedding = torch.cat(all_embeddings, 0)
# We might have some trailing embeddings from padding in the batch, so
# we clip the embedding and lookup to the right size.
full_embedding = full_embedding[:len(tokens), :]
embedding = full_embedding[2:len(tokens), :]
vocab_size, embedding_dim = list(embedding.size())
from allennlp.modules.token_embedders import Embedding # type: ignore
self._bos_embedding = full_embedding[0, :]
self._eos_embedding = full_embedding[1, :]
self._word_embedding = Embedding(vocab_size, # type: ignore
embedding_dim,
weight=embedding.data,
trainable=self._requires_grad,
padding_index=0)
|
python
|
def create_cached_cnn_embeddings(self, tokens: List[str]) -> None:
"""
Given a list of tokens, this method precomputes word representations
by running just the character convolutions and highway layers of elmo,
essentially creating uncontextual word vectors. On subsequent forward passes,
the word ids are looked up from an embedding, rather than being computed on
the fly via the CNN encoder.
This function sets 3 attributes:
_word_embedding : ``torch.Tensor``
The word embedding for each word in the tokens passed to this method.
_bos_embedding : ``torch.Tensor``
The embedding for the BOS token.
_eos_embedding : ``torch.Tensor``
The embedding for the EOS token.
Parameters
----------
tokens : ``List[str]``, required.
A list of tokens to precompute character convolutions for.
"""
tokens = [ELMoCharacterMapper.bos_token, ELMoCharacterMapper.eos_token] + tokens
timesteps = 32
batch_size = 32
chunked_tokens = lazy_groups_of(iter(tokens), timesteps)
all_embeddings = []
device = get_device_of(next(self.parameters()))
for batch in lazy_groups_of(chunked_tokens, batch_size):
# Shape (batch_size, timesteps, 50)
batched_tensor = batch_to_ids(batch)
# NOTE: This device check is for when a user calls this method having
# already placed the model on a device. If this is called in the
# constructor, it will probably happen on the CPU. This isn't too bad,
# because it's only a few convolutions and will likely be very fast.
if device >= 0:
batched_tensor = batched_tensor.cuda(device)
output = self._token_embedder(batched_tensor)
token_embedding = output["token_embedding"]
mask = output["mask"]
token_embedding, _ = remove_sentence_boundaries(token_embedding, mask)
all_embeddings.append(token_embedding.view(-1, token_embedding.size(-1)))
full_embedding = torch.cat(all_embeddings, 0)
# We might have some trailing embeddings from padding in the batch, so
# we clip the embedding and lookup to the right size.
full_embedding = full_embedding[:len(tokens), :]
embedding = full_embedding[2:len(tokens), :]
vocab_size, embedding_dim = list(embedding.size())
from allennlp.modules.token_embedders import Embedding # type: ignore
self._bos_embedding = full_embedding[0, :]
self._eos_embedding = full_embedding[1, :]
self._word_embedding = Embedding(vocab_size, # type: ignore
embedding_dim,
weight=embedding.data,
trainable=self._requires_grad,
padding_index=0)
|
[
"def",
"create_cached_cnn_embeddings",
"(",
"self",
",",
"tokens",
":",
"List",
"[",
"str",
"]",
")",
"->",
"None",
":",
"tokens",
"=",
"[",
"ELMoCharacterMapper",
".",
"bos_token",
",",
"ELMoCharacterMapper",
".",
"eos_token",
"]",
"+",
"tokens",
"timesteps",
"=",
"32",
"batch_size",
"=",
"32",
"chunked_tokens",
"=",
"lazy_groups_of",
"(",
"iter",
"(",
"tokens",
")",
",",
"timesteps",
")",
"all_embeddings",
"=",
"[",
"]",
"device",
"=",
"get_device_of",
"(",
"next",
"(",
"self",
".",
"parameters",
"(",
")",
")",
")",
"for",
"batch",
"in",
"lazy_groups_of",
"(",
"chunked_tokens",
",",
"batch_size",
")",
":",
"# Shape (batch_size, timesteps, 50)",
"batched_tensor",
"=",
"batch_to_ids",
"(",
"batch",
")",
"# NOTE: This device check is for when a user calls this method having",
"# already placed the model on a device. If this is called in the",
"# constructor, it will probably happen on the CPU. This isn't too bad,",
"# because it's only a few convolutions and will likely be very fast.",
"if",
"device",
">=",
"0",
":",
"batched_tensor",
"=",
"batched_tensor",
".",
"cuda",
"(",
"device",
")",
"output",
"=",
"self",
".",
"_token_embedder",
"(",
"batched_tensor",
")",
"token_embedding",
"=",
"output",
"[",
"\"token_embedding\"",
"]",
"mask",
"=",
"output",
"[",
"\"mask\"",
"]",
"token_embedding",
",",
"_",
"=",
"remove_sentence_boundaries",
"(",
"token_embedding",
",",
"mask",
")",
"all_embeddings",
".",
"append",
"(",
"token_embedding",
".",
"view",
"(",
"-",
"1",
",",
"token_embedding",
".",
"size",
"(",
"-",
"1",
")",
")",
")",
"full_embedding",
"=",
"torch",
".",
"cat",
"(",
"all_embeddings",
",",
"0",
")",
"# We might have some trailing embeddings from padding in the batch, so",
"# we clip the embedding and lookup to the right size.",
"full_embedding",
"=",
"full_embedding",
"[",
":",
"len",
"(",
"tokens",
")",
",",
":",
"]",
"embedding",
"=",
"full_embedding",
"[",
"2",
":",
"len",
"(",
"tokens",
")",
",",
":",
"]",
"vocab_size",
",",
"embedding_dim",
"=",
"list",
"(",
"embedding",
".",
"size",
"(",
")",
")",
"from",
"allennlp",
".",
"modules",
".",
"token_embedders",
"import",
"Embedding",
"# type: ignore",
"self",
".",
"_bos_embedding",
"=",
"full_embedding",
"[",
"0",
",",
":",
"]",
"self",
".",
"_eos_embedding",
"=",
"full_embedding",
"[",
"1",
",",
":",
"]",
"self",
".",
"_word_embedding",
"=",
"Embedding",
"(",
"vocab_size",
",",
"# type: ignore",
"embedding_dim",
",",
"weight",
"=",
"embedding",
".",
"data",
",",
"trainable",
"=",
"self",
".",
"_requires_grad",
",",
"padding_index",
"=",
"0",
")"
] |
Given a list of tokens, this method precomputes word representations
by running just the character convolutions and highway layers of elmo,
essentially creating uncontextual word vectors. On subsequent forward passes,
the word ids are looked up from an embedding, rather than being computed on
the fly via the CNN encoder.
This function sets 3 attributes:
_word_embedding : ``torch.Tensor``
The word embedding for each word in the tokens passed to this method.
_bos_embedding : ``torch.Tensor``
The embedding for the BOS token.
_eos_embedding : ``torch.Tensor``
The embedding for the EOS token.
Parameters
----------
tokens : ``List[str]``, required.
A list of tokens to precompute character convolutions for.
|
[
"Given",
"a",
"list",
"of",
"tokens",
"this",
"method",
"precomputes",
"word",
"representations",
"by",
"running",
"just",
"the",
"character",
"convolutions",
"and",
"highway",
"layers",
"of",
"elmo",
"essentially",
"creating",
"uncontextual",
"word",
"vectors",
".",
"On",
"subsequent",
"forward",
"passes",
"the",
"word",
"ids",
"are",
"looked",
"up",
"from",
"an",
"embedding",
"rather",
"than",
"being",
"computed",
"on",
"the",
"fly",
"via",
"the",
"CNN",
"encoder",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/modules/elmo.py#L627-L685
|
train
|
allenai/allennlp
|
allennlp/data/dataset_readers/reading_comprehension/util.py
|
normalize_text
|
def normalize_text(text: str) -> str:
"""
Performs a normalization that is very similar to that done by the normalization functions in
SQuAD and TriviaQA.
This involves splitting and rejoining the text, and could be a somewhat expensive operation.
"""
return ' '.join([token
for token in text.lower().strip(STRIPPED_CHARACTERS).split()
if token not in IGNORED_TOKENS])
|
python
|
def normalize_text(text: str) -> str:
"""
Performs a normalization that is very similar to that done by the normalization functions in
SQuAD and TriviaQA.
This involves splitting and rejoining the text, and could be a somewhat expensive operation.
"""
return ' '.join([token
for token in text.lower().strip(STRIPPED_CHARACTERS).split()
if token not in IGNORED_TOKENS])
|
[
"def",
"normalize_text",
"(",
"text",
":",
"str",
")",
"->",
"str",
":",
"return",
"' '",
".",
"join",
"(",
"[",
"token",
"for",
"token",
"in",
"text",
".",
"lower",
"(",
")",
".",
"strip",
"(",
"STRIPPED_CHARACTERS",
")",
".",
"split",
"(",
")",
"if",
"token",
"not",
"in",
"IGNORED_TOKENS",
"]",
")"
] |
Performs a normalization that is very similar to that done by the normalization functions in
SQuAD and TriviaQA.
This involves splitting and rejoining the text, and could be a somewhat expensive operation.
|
[
"Performs",
"a",
"normalization",
"that",
"is",
"very",
"similar",
"to",
"that",
"done",
"by",
"the",
"normalization",
"functions",
"in",
"SQuAD",
"and",
"TriviaQA",
"."
] |
648a36f77db7e45784c047176074f98534c76636
|
https://github.com/allenai/allennlp/blob/648a36f77db7e45784c047176074f98534c76636/allennlp/data/dataset_readers/reading_comprehension/util.py#L24-L33
|
train
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.