def __init__(self,
vocab: Vocabulary,
encoder: Seq2SeqEncoder,
entity_encoder: Seq2VecEncoder,
question_embedder: TextFieldEmbedder,
gnn_timesteps: int = 2,
dropout: float = 0.0,
rule_namespace: str = 'rule_labels') -> None:
super().__init__(vocab)
self.vocab = vocab
self._encoder = encoder
if dropout > 0:
self._dropout = torch.nn.Dropout(p=dropout)
else:
self._dropout = lambda x: x
self._rule_namespace = rule_namespace
self._question_embedder = question_embedder
self._entity_encoder = TimeDistributed(entity_encoder)
self._action_padding_index = -1 # the padding value used by IndexField
self._acc_single = Average()
self._acc_multi = Average()
self._num_entity_types = 9
self._embedding_dim = question_embedder.get_output_dim()
self._entity_type_encoder_embedding = Embedding(
self._num_entity_types, self._embedding_dim)
self._linking_params = torch.nn.Linear(16, 1)
torch.nn.init.uniform_(self._linking_params.weight, 0, 1)
self._gnn = GatedGraphConv(self._embedding_dim,
gnn_timesteps,
num_edge_types=3,
dropout=dropout)
self._neighbor_params = torch.nn.Linear(self._embedding_dim,
self._embedding_dim)
def __init__(self,
num_edge_types,
embedding_dim,
encoder_output_dim,
rnn_dropout,
timesteps=2):
super().__init__()
self._ent_initial_proj = torch.nn.Linear(
embedding_dim + encoder_output_dim + 1, embedding_dim)
self.dim = embedding_dim
self._gnn = GatedGraphConv(self.dim,
timesteps,
num_edge_types=num_edge_types,
dropout=rnn_dropout)
self._graph_global_node_init_emb = torch.nn.Parameter(
torch.FloatTensor(1, embedding_dim))
torch.nn.init.xavier_uniform_(self._graph_global_node_init_emb)
self._predict_rel_ff = torch.nn.Linear(self.dim, 1)
def __init__(self,
vocab: Vocabulary,
encoder: Seq2SeqEncoder,
entity_encoder: Seq2VecEncoder,
decoder_beam_search: BeamSearch,
question_embedder: TextFieldEmbedder,
input_attention: Attention,
past_attention: Attention,
max_decoding_steps: int,
action_embedding_dim: int,
gnn: bool = True,
decoder_use_graph_entities: bool = True,
decoder_self_attend: bool = True,
gnn_timesteps: int = 2,
parse_sql_on_decoding: bool = True,
add_action_bias: bool = True,
use_neighbor_similarity_for_linking: bool = True,
dataset_path: str = 'dataset',
training_beam_size: int = None,
decoder_num_layers: int = 1,
dropout: float = 0.0,
rule_namespace: str = 'rule_labels',
scoring_dev_params: dict = None,
debug_parsing: bool = False) -> None:
super().__init__(vocab)
self.vocab = vocab
self._encoder = encoder
self._max_decoding_steps = max_decoding_steps
if dropout > 0:
self._dropout = torch.nn.Dropout(p=dropout)
else:
self._dropout = lambda x: x
self._rule_namespace = rule_namespace
self._question_embedder = question_embedder
self._add_action_bias = add_action_bias
self._scoring_dev_params = scoring_dev_params or {}
self.parse_sql_on_decoding = parse_sql_on_decoding
self._entity_encoder = TimeDistributed(entity_encoder)
self._use_neighbor_similarity_for_linking = use_neighbor_similarity_for_linking
self._self_attend = decoder_self_attend
self._decoder_use_graph_entities = decoder_use_graph_entities
self._action_padding_index = -1 # the padding value used by IndexField
self._exact_match = Average()
self._sql_evaluator_match = Average()
self._action_similarity = Average()
self._acc_single = Average()
self._acc_multi = Average()
self._beam_hit = Average()
self._action_embedding_dim = action_embedding_dim
num_actions = vocab.get_vocab_size(self._rule_namespace)
if self._add_action_bias:
input_action_dim = action_embedding_dim + 1
else:
input_action_dim = action_embedding_dim
self._action_embedder = Embedding(num_embeddings=num_actions,
embedding_dim=input_action_dim)
self._output_action_embedder = Embedding(
num_embeddings=num_actions, embedding_dim=action_embedding_dim)
encoder_output_dim = encoder.get_output_dim()
if gnn:
encoder_output_dim += action_embedding_dim
self._first_action_embedding = torch.nn.Parameter(
torch.FloatTensor(action_embedding_dim))
self._first_attended_utterance = torch.nn.Parameter(
torch.FloatTensor(encoder_output_dim))
self._first_attended_output = torch.nn.Parameter(
torch.FloatTensor(action_embedding_dim))
torch.nn.init.normal_(self._first_action_embedding)
torch.nn.init.normal_(self._first_attended_utterance)
torch.nn.init.normal_(self._first_attended_output)
self._num_entity_types = 9
self._embedding_dim = question_embedder.get_output_dim()
self._entity_type_encoder_embedding = Embedding(
self._num_entity_types, self._embedding_dim)
self._entity_type_decoder_embedding = Embedding(
self._num_entity_types, action_embedding_dim)
self._linking_params = torch.nn.Linear(16, 1)
torch.nn.init.uniform_(self._linking_params.weight, 0, 1)
num_edge_types = 3
self._gnn = GatedGraphConv(self._embedding_dim,
gnn_timesteps,
num_edge_types=num_edge_types,
dropout=dropout)
self._decoder_num_layers = decoder_num_layers
self._beam_search = decoder_beam_search
self._decoder_trainer = MaximumMarginalLikelihood(training_beam_size)
if decoder_self_attend:
self._transition_function = AttendPastSchemaItemsTransitionFunction(
encoder_output_dim=encoder_output_dim,
action_embedding_dim=action_embedding_dim,
input_attention=input_attention,
past_attention=past_attention,
predict_start_type_separately=False,
add_action_bias=self._add_action_bias,
dropout=dropout,
num_layers=self._decoder_num_layers)
else:
self._transition_function = LinkingTransitionFunction(
encoder_output_dim=encoder_output_dim,
action_embedding_dim=action_embedding_dim,
input_attention=input_attention,
predict_start_type_separately=False,
add_action_bias=self._add_action_bias,
dropout=dropout,
num_layers=self._decoder_num_layers)
self._ent2ent_ff = FeedForward(action_embedding_dim, 1,
action_embedding_dim,
Activation.by_name('relu')())
self._neighbor_params = torch.nn.Linear(self._embedding_dim,
self._embedding_dim)
# TODO: Remove hard-coded dirs
self._evaluate_func = partial(
evaluate,
db_dir=os.path.join(dataset_path, 'database'),
table=os.path.join(dataset_path, 'tables.json'),
check_valid=False)
self.debug_parsing = debug_parsing
def __init__(self,
vocab: Vocabulary,
encoder: Seq2SeqEncoder,
entity_encoder: Seq2VecEncoder,
question_embedder: TextFieldEmbedder,
action_embedding_dim: int,
attention: Attention,
gnn_timesteps: int = 2,
dropout: float = 0.0,
rule_namespace: str = 'rule_labels') -> None:
super().__init__(vocab, encoder, entity_encoder, question_embedder,
gnn_timesteps, dropout, rule_namespace)
self.vocab = vocab
self._encoder = encoder
if dropout > 0:
self._dropout = torch.nn.Dropout(p=dropout)
else:
self._dropout = lambda x: x
self._rule_namespace = rule_namespace
self._question_embedder = question_embedder
self._entity_encoder = TimeDistributed(entity_encoder)
self._action_padding_index = -1 # the padding value used by IndexField
self._metric_num_candidates = 10
self._accuracy_metrics = dict()
self._accuracy_metrics['query_accuracy'] = Average()
self._accuracy_metrics['_query_accuracy_single'] = Average()
self._accuracy_metrics['_query_accuracy_multi'] = Average()
self._num_entity_types = 9
self._embedding_dim = question_embedder.get_output_dim()
self._entity_type_encoder_embedding = Embedding(
self._num_entity_types, action_embedding_dim)
self._attention = attention
self._q_att_query = torch.nn.Parameter(
torch.FloatTensor(1,
encoder.get_output_dim() + action_embedding_dim))
torch.nn.init.xavier_uniform_(self._q_att_query)
self._q_att_proj = torch.nn.Linear(encoder.get_output_dim(),
action_embedding_dim)
self._linking_params = torch.nn.Linear(16, 1)
torch.nn.init.uniform_(self._linking_params.weight, 0, 1)
self._gnn = GatedGraphConv(self._embedding_dim,
gnn_timesteps,
num_edge_types=4,
dropout=dropout)
self._graph_global_node_init_emb = torch.nn.Parameter(
torch.FloatTensor(1, self._embedding_dim))
torch.nn.init.xavier_uniform_(self._graph_global_node_init_emb)
initial_embedding_size = action_embedding_dim + encoder.get_output_dim(
)
self._ent_initial_proj = torch.nn.Linear(initial_embedding_size,
self._embedding_dim)
torch.nn.init.xavier_uniform_(self._ent_initial_proj.weight)
self._final_graph_proj = torch.nn.Linear(
action_embedding_dim * 2 + encoder.get_output_dim(),
self._embedding_dim)
torch.nn.init.xavier_uniform_(self._final_graph_proj.weight)
self._neighbor_params = torch.nn.Linear(self._embedding_dim,
self._embedding_dim)
self._score_ff = torch.nn.Linear(self._embedding_dim, 1)
torch.nn.init.xavier_uniform_(self._score_ff.weight)