[Paper Review] Example-Based Optimization of Surface-Generation Tables

Christer Samuelsson|ArXiv.org|May 29, 1996

Natural Language Processing Techniques3 citations

TL;DR

This paper presents an example-based method to optimize surface-generation tables in natural language generation by inverting a logic grammar to prioritize logical forms over word strings. Using LR-compiling techniques, it enables recursive-descent generation with functor merging, drastically reducing search space and eliminating spurious nondeterminism while preserving completeness, with automatic trade-offs between table size and lookahead complexity based on training examples.

ABSTRACT

A method is given that "inverts" a logic grammar and displays it from the point of view of the logical form, rather than from that of the word string. LR-compiling techniques are used to allow a recursive-descent generation algorithm to perform "functor merging" much in the same way as an LR parser performs prefix merging. This is an improvement on the semantic-head-driven generator that results in a much smaller search space. The amount of semantic lookahead can be varied, and appropriate tradeoff points between table size and resulting nondeterminism can be found automatically. This can be done by removing all spurious nondeterminism for input sufficiently close to the examples of a training corpus, and large portions of it for other input, while preserving completeness.

Motivation & Objective

• To reduce the search space in surface-generation tables for natural language generation by reorganizing grammar from the logical form perspective.
• To eliminate spurious nondeterminism in generation while maintaining completeness.
• To enable automatic trade-offs between table size and semantic lookahead based on training examples.
• To improve efficiency of semantic-head-driven generation through functor merging, emulating LR parsing behavior.
• To provide a scalable, example-driven optimization method for surface realization in NLG systems.

Proposed method

• The method inverts a logic grammar to represent it from the perspective of logical forms rather than word strings.
• It applies LR-compiling techniques to support recursive-descent generation with functor merging, analogous to prefix merging in LR parsing.
• The approach uses semantic lookahead that can be tuned to balance table size and nondeterminism.
• Spurious nondeterminism is removed for inputs close to training examples, and significantly reduced for others.
• The system preserves completeness while minimizing the size of the generation table through example-guided optimization.
• The optimization is automated, allowing dynamic selection of trade-off points between efficiency and expressiveness.

Experimental results

Research questions

• RQ1 How can surface-generation tables be optimized to reduce search space in natural language generation?
• RQ2 Can LR-compiling techniques be adapted to enable efficient functor merging in recursive-descent generation?
• RQ3 To what extent can spurious nondeterminism be eliminated while preserving completeness in generation?
• RQ4 How can the trade-off between table size and semantic lookahead be automatically balanced using training examples?
• RQ5 Can example-based inversion of a logic grammar lead to more efficient and scalable surface realization?

Key findings

• The method reduces the search space significantly by reorganizing the grammar from the logical form perspective, improving generation efficiency.
• Spurious nondeterminism is removed for inputs similar to training examples, leading to more predictable and faster generation.
• Large portions of nondeterminism are eliminated for other inputs, enhancing performance without loss of completeness.
• The system allows automatic identification of optimal trade-offs between table size and lookahead complexity.
• The approach preserves completeness while achieving a much smaller and more efficient generation table.
• The use of LR-compiling techniques enables functor merging in a way that mirrors efficient LR parsing, improving scalability.