Grammar induction from a python executor (#2281)

* Got a simple LF executor working where all you need is to specify functions

* Grammar induction for simple cases now works

* Got logical_form_to_action_sequence working for simple cases

* Got action_sequence_to_logical_form working for simple cases

* Fix (most?) NLVR and WikiTables tests

* Renamed Executor to DomainLanguage

* Fix world test

* Add some documentation, fix pylint

* mypy

* Added docstrings, fixed docs

* Improve documentation, simplify some logic

* Removed the old type_declaration code entirely, better handled constants

* mypy

* PR feedback

* mypy...

* Actually fix mypy...

Author: matt-gardner

allennlp/semparse/__init__.py

@@ -29,5 +29,7 @@
 # dependency issues.  If you want to import semparse stuff from the data code, just use a more
 # complete path, like `from allennlp.semparse.worlds import WikiTablesWorld`.
 from allennlp.data.tokenizers import Token as _
-from allennlp.semparse.worlds.world import ParsingError, World
+from allennlp.semparse.domain_languages.domain_language import (DomainLanguage, ParsingError,
+                                                                ExecutionError, predicate)
+from allennlp.semparse.worlds.world import World
 from allennlp.semparse.action_space_walker import ActionSpaceWalker

allennlp/semparse/domain_languages/__init__.py

@@ -0,0 +1,2 @@
+from allennlp.semparse.domain_languages.domain_language import (DomainLanguage, ParsingError,
+                                                                ExecutionError, predicate)

allennlp/semparse/domain_languages/domain_language.py

@@ -1,7 +1,7 @@
 from typing import List
 
 from allennlp.common.util import JsonDict
-from allennlp.semparse.worlds.nlvr_object import Object
+from allennlp.semparse.executors.nlvr_object import Object
 
 
 class Box:

allennlp/semparse/worlds/nlvr_box.py renamed to allennlp/semparse/executors/nlvr_box.py

@@ -4,9 +4,9 @@
 import logging
 
 from allennlp.semparse import util as semparse_util
-from allennlp.semparse.worlds.world import ExecutionError
-from allennlp.semparse.worlds.nlvr_object import Object
-from allennlp.semparse.worlds.nlvr_box import Box
+from allennlp.semparse.domain_languages.domain_language import ExecutionError
+from allennlp.semparse.executors.nlvr_object import Object
+from allennlp.semparse.executors.nlvr_box import Box
 
 
 logger = logging.getLogger(__name__)  # pylint: disable=invalid-name
@@ -115,7 +115,7 @@ def execute(self, logical_form: str) -> bool:
         expression_as_list = semparse_util.lisp_to_nested_expression(logical_form)
         # Expression list has an additional level of
         # nesting at the top.
-        result = self._handle_expression(expression_as_list[0])
+        result = self._handle_expression(expression_as_list)
         return result
 
     def _handle_expression(self, expression_list) -> bool:

allennlp/semparse/executors/nlvr_executor.py

@@ -3,7 +3,7 @@
 import logging
 
 from allennlp.semparse import util as semparse_util
-from allennlp.semparse.worlds.world import ExecutionError
+from allennlp.semparse.domain_languages.domain_language import ExecutionError
 from allennlp.semparse.contexts.table_question_knowledge_graph import MONTH_NUMBERS
 from allennlp.semparse.contexts import TableQuestionContext
 from allennlp.tools import wikitables_evaluator as evaluator
@@ -90,14 +90,7 @@ def execute(self, logical_form: str) -> Any:
             logical_form = f"({logical_form})"
         logical_form = logical_form.replace(",", " ")
         expression_as_list = semparse_util.lisp_to_nested_expression(logical_form)
-        # Expression list has an additional level of
-        # nesting at the top. For example, if the
-        # logical form is
-        # "(select all_rows fb:row.row.league)",
-        # the expression list will be
-        # [['select', 'all_rows', 'fb:row.row.league']].
-        # Removing the top most level of nesting.
-        result = self._handle_expression(expression_as_list[0])
+        result = self._handle_expression(expression_as_list)
         return result
 
     def evaluate_logical_form(self, logical_form: str, target_list: List[str]) -> bool:

allennlp/semparse/worlds/nlvr_object.py renamed to allennlp/semparse/executors/nlvr_object.py

@@ -170,5 +170,5 @@ def substitute_any_type(self, basic_types: Set[BasicType]) -> List[Type]:
     name_mapper.map_name_with_signature(name=num_string, signature=NUM_TYPE, alias=num_string)
 
 
-COMMON_NAME_MAPPING = name_mapper.common_name_mapping
-COMMON_TYPE_SIGNATURE = name_mapper.common_type_signature
+COMMON_NAME_MAPPING = name_mapper.name_mapping
+COMMON_TYPE_SIGNATURE = name_mapper.type_signatures

allennlp/semparse/executors/wikitables_variable_free_executor.py

@@ -491,9 +491,9 @@ class NameMapper:
     Parameters
     ----------
     language_has_lambda : ``bool`` (optional, default=False)
-        If your language has lambda functions, the word "lambda" needs to be in the common name
-        mapping, mapped to the alias "\". NLTK understands this symbol, and it doesn't need a type
-        signature for it. Setting this flag to True adds the mapping to `common_name_mapping`.
+        If your language has lambda functions, the word "lambda" needs to be in the name mapping,
+        mapped to the alias "\". NLTK understands this symbol, and it doesn't need a type signature
+        for it. Setting this flag to True adds the mapping to `name_mapping`.
     alias_prefix : ``str`` (optional, default="F")
         The one letter prefix used for all aliases. You do not need to specify it if you have only
         instance of this class for you language. If not, you can specify a different prefix for each
@@ -502,10 +502,10 @@ class NameMapper:
     def __init__(self,
                  language_has_lambda: bool = False,
                  alias_prefix: str = "F") -> None:
-        self.common_name_mapping: Dict[str, str] = {}
+        self.name_mapping: Dict[str, str] = {}
         if language_has_lambda:
-            self.common_name_mapping["lambda"] = "\\"
-        self.common_type_signature: Dict[str, Type] = {}
+            self.name_mapping["lambda"] = "\\"
+        self.type_signatures: Dict[str, Type] = {}
         assert len(alias_prefix) == 1 and alias_prefix.isalpha(), (f"Invalid alias prefix: {alias_prefix}"
                                                                    "Needs to be a single upper case character.")
         self._alias_prefix = alias_prefix.upper()
@@ -515,26 +515,26 @@ def map_name_with_signature(self,
                                 name: str,
                                 signature: Type,
                                 alias: str = None) -> None:
-        if name in self.common_name_mapping:
-            alias = self.common_name_mapping[name]
-            old_signature = self.common_type_signature[alias]
+        if name in self.name_mapping:
+            alias = self.name_mapping[name]
+            old_signature = self.type_signatures[alias]
             if old_signature != signature:
                 raise RuntimeError(f"{name} already added with signature {old_signature}. "
                                    f"Cannot add it again with {signature}!")
         else:
             alias = alias or f"{self._alias_prefix}{self._name_counter}"
             self._name_counter += 1
-            self.common_name_mapping[name] = alias
-            self.common_type_signature[alias] = signature
+            self.name_mapping[name] = alias
+            self.type_signatures[alias] = signature
 
     def get_alias(self, name: str) -> str:
-        if name not in self.common_name_mapping:
+        if name not in self.name_mapping:
             raise RuntimeError(f"Unmapped name: {name}")
-        return self.common_name_mapping[name]
+        return self.name_mapping[name]
 
     def get_signature(self, name: str) -> Type:
         alias = self.get_alias(name)
-        return self.common_type_signature[alias]
+        return self.type_signatures[alias]
 
 
 def substitute_any_type(type_: Type, basic_types: Set[BasicType]) -> List[Type]:

allennlp/semparse/type_declarations/nlvr_type_declaration.py

@@ -244,5 +244,5 @@ def substitute_any_type(self, basic_types: Set[BasicType]) -> List[Type]:
 name_mapper.map_name_with_signature("avg", UNARY_NUM_OP_TYPE)
 name_mapper.map_name_with_signature("-", BINARY_NUM_OP_TYPE)  # subtraction
 
-COMMON_NAME_MAPPING = name_mapper.common_name_mapping
-COMMON_TYPE_SIGNATURE = name_mapper.common_type_signature
+COMMON_NAME_MAPPING = name_mapper.name_mapping
+COMMON_TYPE_SIGNATURE = name_mapper.type_signatures

allennlp/semparse/type_declarations/type_declaration.py

@@ -142,13 +142,13 @@
 # <n,<n,<n,d>>>
 generic_name_mapper.map_name_with_signature("date", DATE_FUNCTION_TYPE)
 
-COMMON_NAME_MAPPING = generic_name_mapper.common_name_mapping
-COMMON_TYPE_SIGNATURE = generic_name_mapper.common_type_signature
-STRING_COLUMN_NAME_MAPPING = string_column_name_mapper.common_name_mapping
-STRING_COLUMN_TYPE_SIGNATURE = string_column_name_mapper.common_type_signature
-NUMBER_COLUMN_NAME_MAPPING = number_column_name_mapper.common_name_mapping
-NUMBER_COLUMN_TYPE_SIGNATURE = number_column_name_mapper.common_type_signature
-DATE_COLUMN_NAME_MAPPING = date_column_name_mapper.common_name_mapping
-DATE_COLUMN_TYPE_SIGNATURE = date_column_name_mapper.common_type_signature
-COMPARABLE_COLUMN_NAME_MAPPING = comparable_column_name_mapper.common_name_mapping
-COMPARABLE_COLUMN_TYPE_SIGNATURE = comparable_column_name_mapper.common_type_signature
+COMMON_NAME_MAPPING = generic_name_mapper.name_mapping
+COMMON_TYPE_SIGNATURE = generic_name_mapper.type_signatures
+STRING_COLUMN_NAME_MAPPING = string_column_name_mapper.name_mapping
+STRING_COLUMN_TYPE_SIGNATURE = string_column_name_mapper.type_signatures
+NUMBER_COLUMN_NAME_MAPPING = number_column_name_mapper.name_mapping
+NUMBER_COLUMN_TYPE_SIGNATURE = number_column_name_mapper.type_signatures
+DATE_COLUMN_NAME_MAPPING = date_column_name_mapper.name_mapping
+DATE_COLUMN_TYPE_SIGNATURE = date_column_name_mapper.type_signatures
+COMPARABLE_COLUMN_NAME_MAPPING = comparable_column_name_mapper.name_mapping
+COMPARABLE_COLUMN_TYPE_SIGNATURE = comparable_column_name_mapper.type_signatures

allennlp/semparse/type_declarations/wikitables_lambda_dcs.py

@@ -20,4 +20,4 @@ def lisp_to_nested_expression(lisp_string: str) -> List:
         while token[-1] == ')':
             current_expression = stack.pop()
             token = token[:-1]
-    return current_expression
+    return current_expression[0]

allennlp/semparse/type_declarations/wikitables_variable_free.py

@@ -10,7 +10,7 @@
 
 from allennlp.common.util import JsonDict
 from allennlp.semparse.type_declarations import nlvr_type_declaration as types
-from allennlp.semparse.worlds.nlvr_box import Box
+from allennlp.semparse.executors.nlvr_box import Box
 from allennlp.semparse.worlds.world import World
 from allennlp.semparse.executors import NlvrExecutor
 

allennlp/semparse/util.py

@@ -27,9 +27,9 @@ def __init__(self,
 
         self._syntax = syntax
         self.types = QuarelTypeDeclaration(syntax)
-        super(QuarelWorld, self).__init__(
-                global_type_signatures=self.types.name_mapper.common_type_signature,
-                global_name_mapping=self.types.name_mapper.common_name_mapping)
+        super().__init__(
+                global_type_signatures=self.types.name_mapper.type_signatures,
+                global_name_mapping=self.types.name_mapper.name_mapping)
         self.table_graph = table_graph
 
         # Keep map and counter for each entity type encountered (first letter in entity string)
@@ -69,8 +69,8 @@ def _entity_index(self, entity) -> int:
     @overrides
     def _map_name(self, name: str, keep_mapping: bool = False) -> str:
         translated_name = name
-        if name in self.types.name_mapper.common_name_mapping:
-            translated_name = self.types.name_mapper.common_name_mapping[name]
+        if name in self.types.name_mapper.name_mapping:
+            translated_name = self.types.name_mapper.name_mapping[name]
         elif name in self.local_name_mapping:
             translated_name = self.local_name_mapping[name]
         elif name.startswith("a:"):

allennlp/semparse/worlds/nlvr_world.py

@@ -7,57 +7,13 @@
 from nltk.sem.logic import ApplicationExpression, Expression, LambdaExpression, BasicType, Type
 
 from allennlp.semparse.type_declarations import type_declaration as types
+from allennlp.semparse.domain_languages.domain_language import ParsingError
+from allennlp.semparse.domain_languages.domain_language import nltk_tree_to_logical_form
 from allennlp.semparse import util as semparse_util
 
 logger = logging.getLogger(__name__)  # pylint: disable=invalid-name
 
 
-class ParsingError(Exception):
-    """
-    This exception gets raised when there is a parsing error during logical form processing.  This
-    might happen because you're not handling the full set of possible logical forms, for instance,
-    and having this error provides a consistent way to catch those errors and log how frequently
-    this occurs.
-    """
-    def __init__(self, message):
-        super(ParsingError, self).__init__()
-        self.message = message
-
-    def __str__(self):
-        return repr(self.message)
-
-
-class ExecutionError(Exception):
-    """
-    This exception gets raised when you're trying to execute a logical form that your executor does
-    not understand. This may be because your logical form contains a function with an invalid name
-    or a set of arguments whose types do not match those that the function expects.
-    """
-    def __init__(self, message):
-        super(ExecutionError, self).__init__()
-        self.message = message
-
-    def __str__(self):
-        return repr(self.message)
-
-
-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.
-    """
-    # 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) + ')'
-
-
 class World:
     """
     Base class for defining a world in a new domain. This class defines a method to translate a