Global grammar values (#1888)

Author: DeNeutoy

allennlp/data/dataset_readers/dataset_utils/text2sql_utils.py

@@ -155,7 +155,8 @@ def read_dataset_schema(schema_path: str) -> Dict[str, List[TableColumn]]:
     mapping table names to their columns and respective types.
     This handles columns in an arbitrary order and also allows
     either ``{Table, Field}`` or ``{Table, Field} Name`` as headers,
-    because both appear in the data.
+    because both appear in the data. It also uppercases table and
+    column names if they are not already uppercase.
 
     Parameters
     ----------
@@ -178,7 +179,7 @@ def read_dataset_schema(schema_path: str) -> Dict[str, List[TableColumn]]:
             table = data.get("Table Name", None) or data.get("Table")
             column = data.get("Field Name", None) or data.get("Field")
             is_primary_key = data.get("Primary Key") == "y"
-            schema[table].append(TableColumn(column, data["Type"], is_primary_key))
+            schema[table.upper()].append(TableColumn(column.upper(), data["Type"], is_primary_key))
 
     return {**schema}
 

allennlp/semparse/contexts/text2sql_table_context.py

@@ -92,6 +92,18 @@
                                   '">="', '"<="', '">"', '"<"', '"AND"', '"OR"', '"LIKE"']
 GRAMMAR_DICTIONARY["unaryop"] = ['"+"', '"-"', '"not"', '"NOT"']
 
+
+
+GLOBAL_DATASET_VALUES: Dict[str, List[str]] = {
+        # These are used to check values are present, or numbers of authors.
+        "scholar": ["0", "1", "2"],
+        # 0 is used for "sea level", 750 is a "major" lake, and 150000 is a "major" city.
+        "geography": ["0", "750", "150000"],
+        # This defines what an "above average" restaurant is.
+        "restaurants": ["2.5"]
+}
+
+
 def update_grammar_with_tables(grammar_dictionary: Dict[str, List[str]],
                                schema: Dict[str, List[TableColumn]]) -> None:
     table_names = sorted([f'"{table}"' for table in
@@ -118,3 +130,10 @@ def update_grammar_with_table_values(grammar_dictionary: Dict[str, List[str]],
             elif column_has_numeric_type(column):
                 productions = sorted([f'"{str(result)}"' for result in results], reverse=True)
                 grammar_dictionary["number"].extend(productions)
+
+
+def update_grammar_with_global_values(grammar_dictionary: Dict[str, List[str]], dataset_name: str):
+
+    values = GLOBAL_DATASET_VALUES.get(dataset_name, [])
+    values_for_grammar = [f'"{str(value)}"' for value in values]
+    grammar_dictionary["value"] = values_for_grammar + grammar_dictionary["value"]

allennlp/semparse/worlds/text2sql_world.py

@@ -1,6 +1,7 @@
 from typing import List, Tuple, Dict
 from copy import deepcopy
 from sqlite3 import Cursor
+import os
 
 from parsimonious import Grammar
 
@@ -11,6 +12,7 @@
 from allennlp.semparse.contexts.text2sql_table_context import GRAMMAR_DICTIONARY
 from allennlp.semparse.contexts.text2sql_table_context import update_grammar_with_table_values
 from allennlp.semparse.contexts.text2sql_table_context import update_grammar_with_tables
+from allennlp.semparse.contexts.text2sql_table_context import update_grammar_with_global_values
 
 class Text2SqlWorld:
     """
@@ -36,6 +38,7 @@ def __init__(self,
                  use_prelinked_entities: bool = True) -> None:
         self.cursor = cursor
         self.schema = read_dataset_schema(schema_path)
+        self.dataset_name = os.path.basename(schema_path).split("-")[0]
         self.use_prelinked_entities = use_prelinked_entities
 
         # NOTE: This base dictionary should not be modified.
@@ -67,24 +70,27 @@ def get_action_sequence_and_all_actions(self,
 
     def _initialize_grammar_dictionary(self, grammar_dictionary: Dict[str, List[str]]) -> Dict[str, List[str]]:
         # Add all the table and column names to the grammar.
-        if self.schema:
-            update_grammar_with_tables(grammar_dictionary, self.schema)
-
-            if self.cursor is not None and not self.use_prelinked_entities:
-                # Now if we have strings in the table, we need to be able to
-                # produce them, so we find all of the strings in the tables here
-                # and create production rules from them. We only do this if
-                # we haven't pre-linked entities, because if we have, we don't
-                # need to be able to generate the values - just the placeholder
-                # symbols which link to them.
-                grammar_dictionary["number"] = []
-                grammar_dictionary["string"] = []
-
-                update_grammar_with_table_values(grammar_dictionary, self.schema, self.cursor)
-            else:
-                # TODO(Mark): The grammar can be tightened here if we don't need to
-                # produce concrete values.
-                pass
+        update_grammar_with_tables(grammar_dictionary, self.schema)
+
+        if self.cursor is not None and not self.use_prelinked_entities:
+            # Now if we have strings in the table, we need to be able to
+            # produce them, so we find all of the strings in the tables here
+            # and create production rules from them. We only do this if
+            # we haven't pre-linked entities, because if we have, we don't
+            # need to be able to generate the values - just the placeholder
+            # symbols which link to them.
+            grammar_dictionary["number"] = []
+            grammar_dictionary["string"] = []
+
+            update_grammar_with_table_values(grammar_dictionary, self.schema, self.cursor)
+        else:
+            # TODO(Mark): The grammar can be tightened here if we don't need to
+            # produce concrete values.
+            pass
+
+        # Finally, update the grammar with global, non-variable values
+        # found in the dataset, if present.
+        update_grammar_with_global_values(grammar_dictionary, self.dataset_name)
 
         return grammar_dictionary
 

allennlp/tests/data/dataset_readers/semantic_parsing/grammar_based_text2sql_test.py

@@ -24,11 +24,11 @@ def test_reader_can_read_data_with_entity_pre_linking(self):
 
         action_sequence = fields["action_sequence"].field_list
         indices = [x.sequence_index for x in action_sequence]
-        assert indices == [101, 75, 81, 124, 33, 5, 33, 5, 33, 5, 33, 5, 33, 5,
-                           39, 115, 13, 118, 21, 27, 108, 16, 118, 21, 30, 107, 13,
-                           118, 21, 30, 108, 16, 114, 13, 118, 21, 23, 107, 46, 95,
-                           96, 94, 100, 108, 94, 100, 107, 90, 88, 80, 39, 119,
-                           48, 2, 42, 92]
+        assert indices == [101, 75, 81, 125, 33, 5, 33, 5, 33, 5, 33, 5,
+                           33, 5, 39, 115, 13, 119, 21, 27, 108, 16, 119,
+                           21, 30, 107, 13, 119, 21, 30, 108, 16, 114, 13,
+                           119, 21, 23, 107, 46, 95, 96, 94, 100, 108,
+                           94, 100, 107, 90, 88, 80, 39, 120, 48, 2, 42, 92]
 
         action_fields = fields["valid_actions"].field_list
         production_rules = [(x.rule, x.is_global_rule) for x in action_fields]
@@ -146,6 +146,7 @@ def test_reader_can_read_data_with_entity_pre_linking(self):
                                     ('unaryop -> ["not"]', True),
                                     ('value -> ["\'city_name0\'"]', True),
                                     ('value -> ["\'name0\'"]', True),
+                                    ('value -> ["2.5"]', True),
                                     ('value -> ["YEAR(CURDATE())"]', True),
                                     ('value -> [boolean]', True),
                                     ('value -> [col_ref]', True),

allennlp/tests/semparse/worlds/text2sql_world_test.py

@@ -25,6 +25,14 @@ def test_world_modifies_unconstrained_grammar_correctly(self):
                                                      '"RATING"', '"NAME"', '"HOUSE_NUMBER"',
                                                      '"FOOD_TYPE"', '"COUNTY"', '"CITY_NAME"']
 
+    def test_world_modifies_grammar_with_global_values_for_dataset(self):
+        world = Text2SqlWorld(self.schema)
+        grammar_dictionary = world.base_grammar_dictionary
+        # Should have added 2.5 because it is a global value
+        # for the restaurants dataset.
+        assert grammar_dictionary["value"] == ['"2.5"', 'parenval', '"YEAR(CURDATE())"',
+                                               'number', 'boolean', 'function', 'col_ref', 'string']
+
     def test_grammar_from_world_can_parse_statements(self):
         world = Text2SqlWorld(self.schema)
         sql = ['SELECT', 'COUNT', '(', '*', ')', 'FROM', 'LOCATION', ',',