UNIT-3 Semantic Parsing

Semantic Parsing: Introduction, Semantic Interpretation, Structural Ambiguity,

word sense Disambiguation, Entity and Event Resolution, Predicate Argument
Structure, Meaning Representation, System Paradigms, Resources, Systems and
software for word sense, Resources, Systems and software for predicate
argument structure, Resources, Systems and software for meaning
representation.

1. Semantic Parsing: Introduction

Introduction:

Semantic parsing in Natural Language Processing (NLP) is the process of

converting natural language into a structured, machine-readable representation
of its meaning. This structured representation can be used for tasks like querying
databases, executing commands, or answering questions.

In simpler terms, semantic parsing is about understanding the meaning

behind a sentence in a way that machines can process. It allows machines to make
sense of human language and carry out tasks based on that understanding.

Key Components of Semantic Parsing:

 Entities: These are the nouns or objects in the sentence. For example,
"apple", "John", "car".

 Predicates: These represent the actions or states of the entities, often in

the form of verbs. For example, "eats", "is", "drives".

 Relations: This capture how entities are connected or related. For example,
"in", "on", "with".

 Quantifiers: These specify the quantity of entities involved, such as "all",

"some", "every".

Example 1: Simple Sentence

Sentence: "John eats an apple."

 Entities: John (person), apple (object).

 Predicate: eats (action).

 Logical Form: eats(John, apple)

 This logical form means "John is eating an apple".

Example 2: Complex Sentence

Sentence: "John gave Mary the book."

 Entities: John (person), Mary (person), book (object).

 Predicate: gave (action).

 Logical Form: gave(John, Mary, book)

 This logical form means "John gave the book to Mary".

Example 3: Sentence with Quantifiers

Sentence: "Every student passed the exam."

 Entities: student, exam.

 Predicate: passed (action).

 Quantifier: Every.

 Logical Form: ∀x(student(x)→passed(x,exam))

 This means "For every student, if x is a student, then x passed the exam."

Example 4: Mapping to SQL Queries

Semantic parsing is widely used to convert natural language questions into

database queries.

 Input: "Find all employees who work in the Sales department."

 Output: SELECT * FROM employees WHERE department = 'Sales';

 Input: "How many customers are from New York?"

 Output:SELECT COUNT(*) FROM customers WHERE city = 'New York';

Example 5:Mapping to Executable Code

Semantic parsing can also generate executable code from natural language
instructions.

 Input: "Print the numbers from 1 to 10."

 Output (Python):

for i in range(1, 11):

print(i)

 Input: "Sort the list in ascending order."

 Output (Python):

sorted_list = sorted(original_list)
Challenges in Semantic Parsing:

 Ambiguity: Words may have multiple meanings depending on context. For

example, "bank" can mean a financial institution or the side of a river.

 Complex Sentence Structures: Sentences may have nested clauses,

indirect speech, or other complicated structures that are difficult for
machines to interpret.

 World Knowledge: Understanding the world context and non-explicit

knowledge (like knowing who is a student or what an exam is) can be crucial
for accurate parsing.

Applications of Semantic Parsing:

 Question Answering Systems: Semantic parsing helps systems like Google

Search or chatbots to understand the user's query and provide relevant
answers.

 Machine Translation: Understanding the meaning of sentences in one

language and converting them accurately into another.

 Information Extraction: Extracting structured data from text, such as

named entities, relationships, and facts.

 Voice Assistants: Understanding spoken commands or questions and

executing tasks.

2. Semantic Interpretation
Semantic interpretation in Natural Language Processing (NLP) refers to the
process of understanding the meaning of text or speech in a way that captures
the intent, context, and relationships between words and phrases. It goes beyond
syntactic analysis (which focuses on grammar and structure) to derive the deeper
meaning of language. This is crucial for tasks like machine translation, sentiment
analysis, question answering, and more.

Semantic interpretation involves assigning meaning to linguistic expressions. It

bridges the gap between syntax (sentence structure) and semantics (meaning).
This process often relies on:

 Compositionality: The meaning of a sentence is derived from the meanings

of its parts and how they are combined.

 Lexical semantics: The meaning of individual words and how they

contribute to the overall meaning.
For example, in the sentence "The cat sat on the mat," semantic interpretation
assigns roles like "cat" (agent) and "mat" (location) to the predicate "sat."

Example of Semantic Interpretation in NLP:

Sentence: "The cat chased the mouse in the garden."

1. Syntactic Analysis:

o Subject: "The cat"

o Verb: "chased"

o Object: "the mouse"

o Prepositional Phrase: "in the garden"

2. Semantic Interpretation:

o Entities:

 "The cat" → Animal (Agent)

 "The mouse" → Animal (Patient)

 "The garden" → Location

o Relationships:

 "chased" → Action (performed by the cat on the mouse)

 "in the garden" → Location where the action took place

o Coreference: None in this sentence.

o Semantic Roles:

 Agent: "The cat"

 Patient: "The mouse"

 Location: "The garden"

3. Meaning:

o A cat performed the action of chasing a mouse, and this event

occurred in a garden.
3. Structural Ambiguity
Structural ambiguity occurs when a sentence or phrase has more than one
possible interpretation due to its syntactic structure. This ambiguity arises
because the same sequence of words can be parsed into multiple syntactic
structures, leading to different meanings. Resolving structural ambiguity is a key
challenge in semantic parsing, as the correct interpretation depends on context
and world knowledge.

For example:

 "I saw the man with the telescope."

o Interpretation 1: I used a telescope to see the man.

o Interpretation 2: I saw the man who had a telescope.

Resolving structural ambiguity is crucial for accurate semantic parsing, as the

chosen structure directly affects the meaning.

Types of Structural Ambiguity

1. Attachment Ambiguity:

o Occurs when it is unclear how to attach a phrase (e.g., prepositional

phrase or modifier) to the rest of the sentence.

o Example:

 Sentence: "I saw the man with the telescope."

 Interpretations:

1. I saw the man who had the telescope.

2. I saw the man using the telescope.

2. Coordination Ambiguity:

o Occurs when it is unclear how words or phrases are grouped in a

coordinated structure.

o Example:

 Sentence: "Old men and women were invited."

 Interpretations:

1. Old men and women (of any age) were invited.

2. Old men and old women were invited.

 3. Scope Ambiguity:

o Occurs when the scope of quantifiers, negations, or modifiers is

unclear.

o Example:

 Sentence: "Every student likes some professor."

 Interpretations:

1. Every student likes some (possibly different)

professor.

2. Every student likes the same professor.

4. Gapping Ambiguity:

o Occurs when words are omitted in a coordinated structure, leading

to multiple interpretations.

o Example:

 Sentence: "John likes pizza, and Mary, pasta."

 Interpretations:

1. John likes pizza, and Mary likes pasta.

2. John likes pizza, and Mary likes pizza and pasta.

Example of Structural Ambiguity in Semantic Parsing

Sentence: "I shot an elephant in my pajamas."

1. Interpretation 1:

o Parsing: The prepositional phrase "in my pajamas" modifies "I."

o Meaning: I was wearing pajamas when I shot the elephant.

o Syntax Tree:

S
├── NP: I
└── VP
├── V: shot
├── NP: an elephant
└── PP: in my pajamas
2. Interpretation 2:

o Parsing: The prepositional phrase "in my pajamas" modifies "an

elephant."

o Meaning: The elephant was wearing my pajamas when I shot it.

 o Syntax Tree:

S
├── NP: I
└── VP
├── V: shot
└── NP
├── Det: an
├── N: elephant
└── PP: in my pajamas
Resolving Structural Ambiguity

1. Context:

o Use surrounding sentences or discourse to infer the correct

interpretation.

o Example: If the previous sentence is "I got dressed quickly,"

Interpretation 1 is more likely.

2. World Knowledge:

o Use common sense or domain knowledge to rule out unlikely

interpretations.

o Example: Elephants donÕt wear pajamas, so Interpretation 2 is

unlikely.

3. Statistical Models:

o Use machine learning models trained on large corpora to predict the

most likely parse based on patterns in the data.

o Example: A language model might assign a higher probability to

Interpretation 1.

4. Syntax-Based Rules:

o Apply syntactic rules or constraints to disambiguate structures.

o Example: Prepositional phrases tend to attach to the nearest noun

phrase.
4. Word-Sense Disambiguation (WSD)
Word-sense disambiguation is the task of determining the correct meaning of a
word in context, as many words are polysemous (have multiple meanings).

For example:

 "Bank" can mean a financial institution or the side of a river.

 In the sentence "I went to the bank to deposit money," WSD identifies
"bank" as a financial institution.

WSD is essential for accurate semantic parsing, as the meaning of a sentence

often depends on the correct interpretation of its words.

Word Sense Disambiguation

We understand that words have different meanings based on the context of its
usage in the sentence. If we talk about human languages, then they are ambiguous
too because many words can be interpreted in multiple ways depending upon the
context of their occurrence.

Word sense disambiguation, in natural language processing (NLP), may be defined

as the ability to determine which meaning of word is activated by the use of word
in a particular context. Lexical ambiguity, syntactic or semantic, is one of the very
first problem that any NLP system faces. Part-of-speech (POS) taggers with high
level of accuracy can solve WordÕs syntactic ambiguity. On the other hand, the
problem of resolving semantic ambiguity is called WSD (word sense
disambiguation). Resolving semantic ambiguity is harder than resolving syntactic
ambiguity.

For example, consider the two examples of the distinct sense that exist for the
word “bass” −

 I can hear bass sound.

 He likes to eat grilled bass.

The occurrence of the word bass clearly denotes the distinct meaning. In first
sentence, it means frequency and in second, it means fish. Hence, if it would be
disambiguated by WSD then the correct meaning to the above sentences can be
assigned as follows −

 I can hear bass/frequency sound.

 He likes to eat grilled bass/fish.

Evaluation of WSD

The evaluation of WSD requires the following two inputs −

A Dictionary

The very first input for evaluation of WSD is dictionary, which is used to specify
the senses to be disambiguated.

Test Corpus

Another input required by WSD is the high-annotated test corpus that has the
target or correct-senses. The test corpora can be of two types &minsu;

 Lexical sample − This kind of corpora is used in the system, where it is

required to disambiguate a small sample of words.

 All-words − This kind of corpora is used in the system, where it is expected

to disambiguate all the words in a piece of running text.

Approaches and Methods to Word Sense Disambiguation (WSD)

Approaches and methods to WSD are classified according to the source of

knowledge used in word disambiguation.

Let us now see the four conventional methods to WSD −

1. Dictionary-based or Knowledge-based Methods

Dictionary-based methods use predefined lists of words or phrases associated

with specific meanings, categories, or sentiments. These lists act as a reference
for processing text.

Knowledge-based methods use structured knowledge sources, such as ontologies,

taxonomies, or knowledge graphs, to understand and process text. These methods
often incorporate semantic relationships between concepts.

Common Techniques in Dictionary-based or Knowledge-based WSD:

1. Lesk Algorithm:

o A classic knowledge-based method that disambiguates word senses

by comparing the dictionary definitions (glosses) of a target word
and its surrounding words.

o Example: If the word "bank" appears in a sentence, the algorithm

compares the glosses of "bank" (e.g., "financial institution" vs.
"riverbank") with the surrounding words to determine the correct
sense.
 2. Extended Lesk Algorithm:

o An improvement over the basic Lesk algorithm that considers

additional information, such as example sentences, related words,
and semantic relationships from resources like WordNet.

3. Semantic Similarity Measures:

o These methods compute the semantic similarity between the target

word's senses and the context using measures like:

 Path-based similarity: Measures the distance between

concepts in a semantic network.

 Information Content (IC): Uses the frequency of concepts in

a corpus to determine their specificity.

 Cosine similarity: Compares vector representations of glosses

or contexts.

4. WordNet-based Methods:

o WordNet is a widely used lexical database for English that organizes

words into sets of synonyms (synsets) and provides semantic
relationships.

o Methods using WordNet often exploit hypernymy (is-a

relationships), hyponymy, and other semantic links to disambiguate
word senses.

2. Supervised Methods

For disambiguation, machine learning methods make use of sense-annotated

corpora to train. These methods assume that the context can provide enough
evidence on its own to disambiguate the sense. In these methods, the words
knowledge and reasoning are deemed unnecessary. The context is represented as
a set of “features” of the words. It includes the information about the
surrounding words also. Support vector machine and memory-based learning are
the most successful supervised learning approaches to WSD. These methods rely
on substantial amount of manually sense-tagged corpora, which is very expensive
to create.

3. Semi-supervised Methods

Due to the lack of training corpus, most of the word sense disambiguation
algorithms use semi-supervised learning methods. It is because semi-supervised
methods use both labelled as well as unlabeled data. These methods require very
small amount of annotated text and large amount of plain unannotated text. The
technique that is used by semisupervised methods is bootstrapping from seed
data.
4. Unsupervised Methods

These methods assume that similar senses occur in similar context. That is why
the senses can be induced from text by clustering word occurrences by using
some measure of similarity of the context. This task is called word sense
induction or discrimination. Unsupervised methods have great potential to
overcome the knowledge acquisition bottleneck due to non-dependency on manual
efforts.

Applications of Word Sense Disambiguation (WSD)

Word sense disambiguation (WSD) is applied in almost every application of

language technology.

Let us now see the scope of WSD −

Machine Translation

Machine translation or MT is the most obvious application of WSD. In MT, Lexical

choice for the words that have distinct translations for different senses, is done
by WSD. The senses in MT are represented as words in the target language. Most
of the machine translation systems do not use explicit WSD module.

Information Retrieval (IR)

Information retrieval (IR) may be defined as a software program that deals with
the organization, storage, retrieval and evaluation of information from document
repositories particularly textual information. The system basically assists users
in finding the information they required but it does not explicitly return the
answers of the questions. WSD is used to resolve the ambiguities of the queries
provided to IR system. As like MT, current IR systems do not explicitly use WSD
module and they rely on the concept that user would type enough context in the
query to only retrieve relevant documents.

Text Mining and Information Extraction (IE)

In most of the applications, WSD is necessary to do accurate analysis of text.

For example, WSD helps intelligent gathering system to do flagging of the
correct words. For example, medical intelligent system might need flagging of
“illegal drugs” rather than “medical drugs”

Lexicography

WSD and lexicography can work together in loop because modern lexicography is
corpus based. With lexicography, WSD provides rough empirical sense groupings
as well as statistically significant contextual indicators of sense.
5. Entity and Event Resolution
Entity and event resolution are critical subtasks in semantic parsing that involve
identifying and disambiguating entities (e.g., people, organizations, locations) and
events (e.g., actions, occurrences) in text and mapping them to their
corresponding representations in a knowledge base or structured schema.

Entity Resolution

Entity resolution, also known as entity linking or named entity disambiguation,

involves identifying mentions of entities in text and linking them to their unique
identifiers in a knowledge base (e.g., Wikipedia, Wikidata, or a domain-specific
ontology).

Key Steps in Entity Resolution:

1. Named Entity Recognition (NER):

o Identify spans of text that refer to entities (e.g., "Barack Obama"

as a person, "New York" as a location).

o This is typically done using sequence labeling models like CRF,

BiLSTM, or transformer-based models (e.g., BERT).

2. Candidate Generation:

o For each entity mention, generate a list of possible candidates from

the knowledge base.

o Example: The mention "Paris" could refer to "Paris, France" or "Paris

Hilton."

3. Disambiguation:

o Use context to select the most appropriate candidate.

o Techniques include:

 Contextual Similarity: Compare the context of the mention

with the descriptions of candidate entities.

 Popularity-based Heuristics: Prefer more commonly

referenced entities (e.g., "Paris, France" is more likely than
"Paris Hilton" in most contexts).

 Graph-based Methods: Use relationships between entities in

the knowledge base to resolve ambiguities.
 4. Linking:

o Map the disambiguated entity to its unique identifier in the

knowledge base

Challenges in Entity Resolution:

 Ambiguity: Many entity mentions are ambiguous (e.g., "Apple" could refer
to the company or the fruit).

 Out-of-Knowledge-Base Entities: Some entities may not exist in the

knowledge base, especially in specialized domains.

 Contextual Variability: The same entity may be referred to in different

ways (e.g., "Barack Obama," "Obama," "the former president").

Event Resolution

Event resolution involves identifying and disambiguating events mentioned in text

and mapping them to structured representations. Events are typically actions or
occurrences involving participants (entities), time, and location.

Key Steps in Event Resolution:

1. Event Detection:

o Identify spans of text that describe events (e.g., "elected

president," "signed a treaty").

o This can be done using sequence labeling or classification models.

2. Event Type Classification:

o Classify the detected event into a predefined type or category (e.g.,

"election," "signing").

o This often involves using ontologies like FrameNet, ACE (Automatic

Content Extraction), or domain-specific schemas.

3. Argument Role Labeling:

o Identify the participants (entities) and their roles in the event (e.g.,
"Barack Obama" as the agent in "elected president").

o This is similar to semantic role labeling (SRL).

4. Temporal and Spatial Resolution:

o Resolve temporal expressions (e.g., "last year") and spatial

expressions (e.g., "in Paris") associated with the event.
 5. Disambiguation and Linking:

o Map the event to a unique representation in a knowledge base or

event ontology.

o Example: Linking "Barack Obama was elected president in 2008" to

a specific event node in a knowledge graph.

Challenges in Event Resolution:

 Complexity of Events: Events can involve multiple participants, temporal

and spatial information, and nested structures.

 Ambiguity in Event Descriptions: The same event can be described in

different ways (e.g., "elected president" vs. "won the election").

 Lack of Comprehensive Event Ontologies: Many domains lack detailed

event schemas or knowledge bases.

Applications of Entity and Event Resolution in Semantic Parsing

1. Question Answering:

2. Knowledge Graph Construction:

3. Information Extraction:

4. Machine Translation:

5. Dialogue Systems:
6. Predicate-Argument Structure
Predicate-argument structure represents the relationships between a
predicate (a verb or action) and its arguments (the participants in the action). For
example:

The predicate-argument structure is a fundamental concept in semantic

parsing that represents the relationships between predicates (typically verbs or
event triggers) and their associated arguments (e.g., subjects, objects,
modifiers). This structure is crucial for understanding the meaning of sentences
and converting natural language into formal representations, such as logical
forms, SQL queries, or knowledge graph triples.

Key Concepts

1. Predicate:

o A predicate is the main verb or event trigger in a sentence that

expresses an action, state, or relationship.

o Example: In the sentence "John eats an apple," the predicate is

"eats."

2. Arguments:

o Arguments are the participants or entities involved in the action or

event described by the predicate.

o They typically include:

 Agent: The doer of the action (e.g., "John" in "John eats an

apple").

 Patient: The receiver of the action (e.g., "an apple" in "John

eats an apple").

 Instrument: The means by which the action is performed (e.g.,

"with a knife" in "John cut the bread with a knife").

 Location: The place where the action occurs (e.g., "in the
kitchen" in "John eats an apple in the kitchen").

 Time: The time when the action occurs (e.g., "yesterday" in

"John ate an apple yesterday").

3. Semantic Roles:

o Semantic roles (or thematic roles) describe the function of each

argument in relation to the predicate.

o Common roles include Agent, Patient, Theme, Beneficiary,

Instrument, Location, and Time.
Predicate-Argument Structure in Semantic Parsing

Semantic parsing involves mapping natural language sentences to structured

representations, and the predicate-argument structure is a key intermediate
step in this process. The goal is to identify the predicate, its arguments, and their
semantic roles.

Example:

 Sentence: "John gave Mary a book in the library."

 Predicate: "gave"

 Arguments:

o Agent: "John"

o Recipient: "Mary"

o Theme: "a book"

o Location: "in the library"

Structured Representation:

give(Agent: John, Recipient: Mary, Theme: a book, Location: library)

Approaches to Extracting Predicate-Argument Structures

1. Rule-based Methods:

2. Statistical and Machine Learning Methods:

3. Pre-trained Language Models:

4. End-to-End Semantic Parsing:

7. Meaning Representation

Meaning representation is a structured and formal way of capturing the semantics

(meaning) of natural language text. In semantic parsing, the goal is to convert
natural language into a meaning representation that can be used for downstream
tasks such as question answering, machine translation, knowledge base querying,
or dialogue systems. These representations are typically machine-readable and
can take various forms, depending on the application.

Types of Meaning Representations

1. Logical Forms:

o Logical forms represent the meaning of a sentence using formal

logic, such as first-order logic or lambda calculus.

o Example:

 Sentence: "Every student likes a teacher."

 Logical Form: ∀x (student(x) → ∃y (teacher(y) ∧ likes(x, y)))

2. SQL Queries:

o Used for querying relational databases.

o Example:

 Sentence: "Find all students who scored above 90."

 SQL Query: SELECT * FROM students WHERE score > 90;

3. Abstract Meaning Representation (AMR):

o AMR is a graph-based representation that captures the core

semantics of a sentence.

o Example:

 Sentence: "The boy wants to go."

 AMR: (w / want-01 :arg0 (b / boy) :arg1 (g / go-01 :arg0 b))

4. Knowledge Graph Triples:

o Represents meaning as subject-predicate-object triples.

o Example:

 Sentence: "John works at Google."

 Triple: (John, works_at, Google)

 5. Frame Representations:

o Based on FrameNet, which defines frames (contexts) and their

associated semantic roles.

o Example:

 Sentence: "John bought a book from Mary."

 Frame: Commerce_buy with roles Buyer: John, Goods:

book, Seller: Mary.

6. Programmatic Representations:

o Used for tasks like code generation or robotic command

understanding.

o Example:

 Sentence: "Move the box to the table."

 Program: move(box, table)

Key Components of Meaning Representation

1. Entities:

o Represent objects, people, or concepts (e.g., "John," "Google,"

"book").

2. Predicates:

o Represent actions, states, or relationships (e.g., "works_at," "buy").

3. Arguments:

o Represent the participants or modifiers associated with predicates

(e.g., "John" as the subject, "Google" as the object).

4. Modifiers:

o Represent additional information such as time, location, or manner

(e.g., "yesterday," "in the park").

5. Quantifiers and Logical Operators:

o Represent scope, negation, or logical relationships (e.g., "every,"

"some," "not").
8.System Paradigms
Researchers from linguistics community have examined meaning
representations at different levels of granularity and generality exploring the
space of numerous languages. Many of the experimental conditions do not have
hand annotated data.
It is important to get a perspective on the various primary dimensions on
which the problem of semantic interpretation has been tackled.
The approaches of semantic interpretation generally fall into the following three
categories:
1.System architecture.
2.Scope
3. Coverage
1. System Architectures
 Knowledge based:
 In Natural Language Processing (NLP), semantic parsing is the task of
converting natural language into a machine-readable representation, often in
the form of structured queries or logical forms.
 Knowledge-based systems play a crucial role in semantic parsing by
leveraging structured knowledge sources (e.g., ontologies, knowledge graphs,
or databases) to improve the accuracy and interpretability of the parsing
process.
 These systems use a predefined set of rules or a knowledge base to obtain
a solution to a new problem. They often employ logical reasoning and pattern
matching to map Natural Language expressions to formal representations.
Example Workflow
1. Input: "What is the capital of France?"
2. Preprocessing: Tokenization, POS tagging, NER identifies "France" as a location.
3. Entity Linking: Maps "France" to the entity France in the KB.
4. Semantic Parsing: Generates the logical form capital(France).
5. Query Execution: Executes the query against the KB and retrieves Paris.
6. Response Generation: Produces the output "The capital of France is Paris."
 Unsupervised:
 It involves designing systems that can understand and map natural language
to structured representations (e.g., logical forms, SQL queries, or other
formal representations) without relying on labeled training data.
 These systems tend to require minimal human intervention to be functional
by using existing resources that can be bootstrapped for a particular
application or problem domain.
 These systems learn to map language to meaning without explicit labelled
data.
 They use statistical patterns or word knowledge.
 Supervised:
 A supervised system architecture for semantic parsing typically relies on
labelled data, where input utterances are paired with their corresponding
structured representations.
 These systems learn from labelled data, where input sentences are paired
with corresponding formal representations.
 These systems involve the manual annotation of some phenomena that appear
in a sufficient quantity of data so that machine learning algorithms can be
applied. Feature functions are created to allow each problem instance to be
projected into a space of features.
The key components and architecture of a supervised semantic parsing
system:
1. Input Representation:
Natural Language Utterance: The input is a natural language sentence
or phrase (e.g., "What is the capital of France?").
Preprocessing: Tokenization, lemmatization, and other NLP
preprocessing steps may be applied to the input.
2. Encoder:
The encoder maps the input utterance into a continuous vector
representation
3. Decoder:
The decoder generates the structured output (e.g., SQL query, logical
form) from the encoded representation.
4. Attention Mechanism
Attention mechanisms help the decoder focus on relevant parts of the
input utterance while generating the output.
5. Training Objective
The system is trained using supervised learning with a labeled dataset
of (utterance, structured representation) pairs.
6. Output Representation
The output is a structured representation, such as:
o SQL queries for database interactions.
o Lambda calculus or logical forms for reasoning tasks.
o Abstract Syntax Trees (ASTs) for program synthesis.
 The output is often post-processed to ensure validity (e.g., checking SQL
syntax).
 Example Architecture: Seq2Seq with Transformers
1. Input: "What is the capital of France?"
2. Encoder: A pre-trained Transformer (e.g., BERT) encodes the input into
contextualized embeddings.
3. Decoder: A Transformer decoder generates the output token-by-
token, e.g., SELECT capital FROM countries WHERE name = "France".
4. Training: The model is trained on a dataset of (question, SQL query)
pairs using cross-entropy loss.
5. Output: The predicted SQL query is executed on a database to retrieve
the answer.
 Semi-Supervised:
 These systems combine aspects of above two learning using both labelled
and unlabelled data. So manual annotation is usually very expensive and
does not yield enough data to completely capture a phenomenon.
 In such instances, researches can automatically expand the data set on
which their models are trained either by employing machine-generated
output directly or by bootstrapping off an existing model by having
humans correct its output.
2. Scope:
 Domain Dependent:
 The domain-dependent scope defines the boundaries and constraints
of the language and the types of queries or commands that the
semantic parser is designed to handle.
 These systems are specific to certain domains, such as air travel
reservations or simulated football coaching.
 some key aspects of domain-dependent scope in semantic parsing.
o Vocabulary and Terminology
o Ontology and Knowledge Base
o Intent and Entity Recognition
o Grammar and Syntax Rules
o Query Complexity
o Training Data
o Evaluation Metrics
o Adaptability and Generalization
 Domain Independent:
 The concept of domain-independent scope in semantic parsing refers
to the ability of a model or system to generalize across different
domains (e.g., healthcare, finance, travel) without requiring domain-
specific training data or customization.
 These systems are general enough that the techniques can be
applicable to multiple domains without little or no change.
 Example:
A domain-independent semantic parser might convert the following
natural language queries into structured representations:
 Travel Domain: "Find flights from New York to London on
December 25th" → SQL query or API call.
 Healthcare Domain: "What are the symptoms of diabetes?" →
Query to a medical knowledge base.
 Finance Domain: "Show me my spending last month" → Query to a
banking database.
3.Coverage
 Shallow:
 Shallow coverage in semantic parsing refers to the limited ability of
a system to accurately interpret and represent the meaning of natural
language expressions.
 These systems tend to produce an intermediate representation that
can then be converted to one that a machine can base its action on.
 Deep:
 These systems usually create a terminal representation that is
directly consumed by a machine or application.
 Achieving deep coverage in semantic parsing means ensuring that the
system can handle a wide variety of linguistic expressions, including
complex and ambiguous ones, across different domains and contexts.
Resources, Systems and software for predicate argument
structure
Predicate-Argument Structure is a linguistic concept that describes the
relationship between a predicate (typically a verb) and its
associated arguments (the entities or participants involved in the action or state
described by the predicate)
1. Predicate:
o The main verb or action word in a sentence that expresses an action,
event, or state.
o Example: In the sentence "John eats an apple," the predicate is
"eats."
2. Arguments:
o The participants or entities involved in the action or state described
by the predicate.
o Arguments are typically noun phrases or pronouns.
o Example: In "John eats an apple," the arguments are "John" (the
doer of the action) and "an apple" (the object being eaten).
3. Roles:
o Arguments are assigned specific semantic roles that describe their
relationship to the predicate.
o Common roles include:
 Agent: The doer of the action (e.g., "John" in "John eats an
apple").
 Patient/Theme: The entity affected by the action (e.g., "an
apple" in "John eats an apple").
 Instrument: The tool or means used to perform the action
(e.g., "a knife" in "John cut the bread with a knife").
 Beneficiary: The entity for whom the action is performed
(e.g., "Mary" in "John baked a cake for Mary").
 Location: The place where the action occurs (e.g., "the park"
in "John ran in the park").
Example of Predicate-Argument Structure
Consider the sentence:
 "Mary gave a book to John in the library."
 Predicate: "gave"
 Arguments and their roles:
o Agent: "Mary" (the giver)
o Theme: "a book" (the object given)
o Recipient: "John" (the receiver)
 o Location: "the library" (the place where the action occurred)

 Shallow semantic parsing or semantic role labelling is the process of

identifying the various arguments of predicates in a sentence.

 There has been a debate over what constitutes the set of arguments and
what the granularity of such argument label should be for various
predicates.
Resources
A corpus (plural: corpora) refers to a large and structured collection of
texts or speech data that is used for linguistic analysis, training machine
learning models, and developing NLP applications
We have two important corpora that are semantically tagged. One is
FrameNet and the other is PropBank.
These resources have transformed from rule-based approaches to more
data-oriented approaches. These approaches focus on transforming linguistic
insights into features.
o FrameNet
o PropBank
o Other Resources
 FrameNet is based on the theory of frame semantics where a given
predicate invokes a semantic frame initiating some or all of the possible
semantic roles belonging to that frame.
 PropBank is based on DowtyÕs prototype theory and uses a more linguistically
neutral view. Each predicate has a set of core arguments that are predicate
dependent and all predicates share a set of noncore or adjunctive arguments.
FrameNet
FrameNet contains frame-specific semantic annotation of a number of
predicates in English.
FrameNet is based on the theory of Frame Semantics, which posits that the
meaning of a word (especially verbs, nouns, and adjectives) can only be fully
understood in the context of a semantic frame. A semantic frame is a conceptual
structure that describes a situation, event, or relationship, along with the
participants (called frame elements) and their roles.
 The process of FrameNet annotation consists of identifying specific semantic
frames and creating a set of frame-specific roles called frame elements.
 A set of predicates that instantiate the semantic frame irrespective of their
grammatical category are identified and a variety of sentences are labelled
for those predicates.
 The labelling process identifies the following:
o The frame that an instance of the predicate lemma invokes
o The semantic arguments for that instance
o Tagging them with one of the predetermined sets of frame elements
for that frame.
Key Components of FrameNet
1. Frame:
o A conceptual structure representing a situation, event, or
relationship.
o Example: The "Commerce_buy" frame describes a commercial
transaction involving a buyer, seller, goods, and money.
2. Lexical Units (LUs):
o Words or phrases that evoke a specific frame.
o Example: The verb "buy" evokes the "Commerce_buy" frame.
3. Frame Elements (FEs):
o The semantic roles or participants in a frame.
o Example: In the "Commerce_buy" frame, the frame elements are:
 Buyer: The person purchasing the goods.
 Seller: The person selling the goods.
 Goods: The item being purchased.
 Money: The currency exchanged.
4. Annotations:
o Real-world sentences annotated with frame elements to show how
words evoke frames.
o Example: In the sentence "John bought a book from Mary for $10,"
the annotations would identify:
 "John" as the Buyer,
 "a book" as the Goods,
 "Mary" as the Seller,
 "$10" as the Money.
5. Frame Relations:
o Relationships between frames, such as inheritance, causation, or
perspective.
o Example: The "Commerce_buy" frame inherits from the more
general "Commerce" frame.
How FrameNet is Used in Semantic Parsing
1. Frame Identification:
o Identify the frame evoked by a word or phrase in a sentence.
o Example: For the sentence "John sold a car to Mary," the verb "sold"
evokes the "Commerce_sell" frame.
 2. Argument Role Labeling:
o Map the constituents of a sentence to their corresponding frame
elements.
o Example: In "John sold a car to Mary," the roles are:
 "John" → Seller,
 "a car" → Goods,
 "Mary" → Buyer.
3. Meaning Representation:
o Use the identified frames and their elements to construct a
structured representation of the sentence's meaning.
o Example: The sentence "John sold a car to Mary" could be
represented as:
Commerce_sell(Seller: John, Goods: car, Buyer: Mary)
4. Integration with Other NLP Tasks:
o FrameNet annotations can be used to improve tasks like:
 Question Answering: Understanding the roles in a question
and matching them to a knowledge base.
 Information Extraction: Extracting structured information
from text.
 Machine Translation: Preserving semantic roles during
translation.
PropBank

PropBank is a corpus of text (originally based on the Penn Treebank) where

verbs (predicates) are annotated with their semantic roles. Each verb is
associated with a set of rolesets, which define the possible arguments it can take
and their semantic roles (e.g., Agent, Patient, Instrument).
These roles are numbered (Arg0, Arg1, Arg2, etc.) and mapped to specific
semantic meanings depending on the verb.
Key Features of PropBank
1. Rolesets:
o Each verb in PropBank has one or more rolesets, which define the
possible arguments it can take.
o Example: The verb "give" has a roleset that defines:
 Arg0: Giver (Agent)
 Arg1: Thing given (Theme)
 Arg2: Recipient (Beneficiary)
2. Numbered Arguments:
o Arguments are labeled as Arg0, Arg1, Arg2, etc., where the
numbering corresponds to specific semantic roles for each verb.
 o Example: In "John gave Mary a book":
 Arg0: John (Giver)
 Arg1: a book (Thing given)
 Arg2: Mary (Recipient)
3. Modifiers:
o PropBank also annotates modifiers like temporal (when), locative
(where), and manner (how) information.
o Example: In "John gave Mary a book in the library," "in the library"
would be labeled as a locative modifier.
4. Verb-Specific Roles:
o The semantic roles (Arg0, Arg1, etc.) are specific to each verb.
o For example:
 For "break," Arg0 might be the breaker, and Arg1 might be
the thing broken.
 For "run," Arg0 might be the runner, and there might be no
Arg1.
Example of PropBank Annotation
Consider the sentence:
 "John gave Mary a book in the library."
The PropBank annotation might look like this:
 Predicate: gave
 Roleset: give.01
o Arg0: John (Giver)
o Arg1: a book (Thing given)
o Arg2: Mary (Recipient)
o AM-LOC: in the library (Location modifier)
The meaning of core arguments has to be interpreted in connection with a
predicate.
 Let us look at an example from PropBankcorpus along with its syntax tree.

An important distinction between FrameNet and Propbank is as follows:

 In FrameNet we have lexical units which are words paired with their
meanings or the frames that they invoke.
 In Propbank each lemma has a list of different framesets that represent
all the senses for which there is a different argument structure.
Other Resources
Other resources have been developed to aid further research in predicate-
argument recognition.
 NomBank was inspired by PropBank.
 In the process of identifying and tagging the arguments of nouns,
the NOMLEX(NOMinalization LEXicon) dictionary was expanded to
cover about 6,000 entries.
 The frames from PropBank were used to generate the frame files
for NomBank.
 Another resource that ties PropBank frames with more predicate-
independent thematic roles and also provides a richer
representation associated with Levin classes is VerbNet.
Systems

 Syntactic Representations

 Classification Paradigms

 Overcoming the Independence Assumptions

 Feature Performance

 Feature Salience

 Feature Selection

 Size of Training Data

 Overcoming Parsing Errors

 Noun Arguments

 Multilingual Issues

 Robustness across Genre

Software
Following is a list of software packages available for semantic role labeling

 ASSERT(Automatic Statistical Semantic Role Tagger): A semantic role

labeler trained on the English PropBank data.

 C-ASSERT: An extension of ASSERT for the Chinese language

 SwiRL: One more semantic role labeler trained on PropBankdata.

 Shalmaneser(A Shallow Semantic Parser): A toolchain for shallow semantic

parsing based on the FrameNet data.

Resources, Systems and software for meaning representation.

semantic parsing refers to the process of converting natural language into

a formal meaning representation that can be understood by machines.
The meaning representation is a structured, machine-readable format that
captures the semantics (meaning) of the input text. It serves as an intermediate
step for tasks like question answering, dialogue systems, machine translation, and
more.

Key Aspects of Meaning Representation in Semantic Parsing:

1. Structured Representation:

o The output is typically a structured representation, such as:

 Logical forms (e.g., lambda calculus, first-order logic).

 Graph-based representations (e.g., Abstract Meaning

Representation (AMR), Knowledge Graphs).

 Tree structures (e.g., syntax trees, dependency trees with

semantic annotations).

 Frame-based representations (e.g., semantic roles,

predicates, and arguments).

2. Capturing Semantics:

o The representation encodes the meaning of the text, including

entities, relationships, actions, and intents.

o For example, the sentence "Book a flight to Paris" might be

represented as:

Intent: BookFlight

Destination: Paris

3. Formal Language:

o The meaning representation often uses a formal language that can

be executed or queried by a machine. For example:

 SQL for database queries.

 SPARQL for querying knowledge graphs.

 Custom logical forms for specific applications.

 4. Applications:

o Question Answering: Convert a natural language question into a

query (e.g., SQL) to retrieve answers from a database.

o Dialogue Systems: Map user utterances to intents and slots for

task-oriented dialogue.

o Machine Translation: Represent the meaning of a sentence in a

language-independent way before generating the target language.

o Information Extraction: Extract structured information from

unstructured text.

Examples of Meaning Representations:

1. Logical Form:

o Input: "What is the capital of France?"

o Representation:

answer(Capital(France))

2. Abstract Meaning Representation (AMR):

o Input: "The boy wants to go to the park."

o Representation:

(w / want
:arg0 (b / boy)
:arg1 (g / go
:arg0 b
:destination (p / park)))
3. SQL Query:

o Input: "Find all flights to Paris."

o Representation:

SELECT * FROM flights WHERE destination = 'Paris';

4. Frame-Based Representation:

o Input: "John booked a flight to New York."

o Representation:

Event: BookFlight
Agent: John
Destination: New York.
 Now we look at the activity which takes natural language input and transforms
it into an unambiguous representation that a machine can act on.
 This form will be understood by the machines more than human beings.t is
 easier to generate such a form for programming languages as they impose
syntactic and semantic restrictions on the programs where as such
restrictions cannot be imposed on natural language.
 Techniques developed so far work within specific domains and are not
scalable.
 This is called deep semantic parsing as opposed to shallow semantic parsing.

Resources
A number of projects have created representations and resources that
have promoted experimentation in this area. A few of them are as follows:
 ATIS
 Communicator
 GeoQuery
 Robocup:Clang

1. ATIS(Air Travel Information Systems)

The ATIS (Air Travel Information Systems) dataset is a widely used benchmark
in semantic parsing and natural language processing (NLP). It focuses on the
domain of air travel and is designed to help develop and evaluate systems that can
understand and process natural language queries related to flight information,
such as booking flights, checking flight statuses, and finding airport details.

Key Features of the ATIS Dataset:

1. Domain:
o The dataset is centered around air travel, making it a domain-
specific resource for semantic parsing.
2. Queries:
o It contains natural language queries from users, such as:
 "Show me flights from Boston to San Francisco."
 "What is the price of a ticket to New York?"
 "List all flights departing from Chicago after 6 PM."
3. Annotations:
o Each query is annotated with:
 Intents: The goal or action the user wants to perform (e.g.,
"find flight," "check status").
  Slots: Specific pieces of information in the query (e.g.,
"Boston" as the departure city, "San Francisco" as the
destination city).
4. Structured Output:
o The dataset is often used to map natural language queries to
structured representations, such as SQL queries or other formal
meaning representations.
Example of ATIS Data:

 Input (Natural Language Query):

Show me flights from Boston to San Francisco on Monday.
 Intent:
FindFlight
 Slots:
DepartureCity: Boston
ArrivalCity: San Francisco
Date: Monday
 Structured Representation (SQL-like):
SELECT * FROM flights
WHERE departure_city = 'Boston'
AND arrival_city = 'San Francisco'
AND date = 'Monday';
o The Air Travel Information System (ATIS) is one of the first concerted
efforts to build systems which build systems to transform natural language
into applications to make decisions.
o Here a user query in speech is transformed using a restricted vocabulary
about flight information.
o It then formed a representation that was compiled into a SQL query to
extract answers from a database.
o A hierarchical frame representation was used to encode the intermediate
semantic information.
2. Communicator
o ATIS was more focus on user-initiated dialog Communicator involved a
mixed-initiative dialog.
o Humans and machines were able to have a dialog with each other and the
computer was able to present users real time information helping them
negotiate a preferred itinerary.
o Many thousands of dialogs were collected and are available through the
Linguistic Data Consortium.
o A lot of data was collected and annotated with dialog acts by Carnegie-
Mellon university.
3. GeoQuery
o A geographical database called Geobasehas about 800 Prolog facts stored
in a relational databse.
o It has geographic information such as population, neighboring states, major
rivers, and major cities.
o A few queries and their representations are as follows:
o What is the capital of the state with the largest population?
o Answer(C,(capital(S,C),largest(P,(state(S),population(S,P)))).
o What are the major cities in Kansas?
o Answer(C,(major(C),city(C),loc(C,S),equal(S,stated(kansas))))
o The Ge0Query corpus has also been translated into Japanese, Spanish and
Turkish.
4.Robocup:CLang
o RoboCupis an international initiative by the artificial intelligence
community that uses robotic soccer as its domain.
o A special formal language Clang is used to encode the advice from the team
coach.
o The behaviors are expressed as if-then rules.
Example:
o If the ball is in our penalty area, all our players except player 4 should stay
in our half.
o ((bpos(penalty-area our))(do(player-except our 4)(pos(half our))))
Systems

 Depending on the consuming application the meaning representation can be

a SQL query, a Prolog query, or a domain-specific query representation.
 We now look at various ways the problem of mapping the natural language
to meaning representation has been tackled.
o Rule Based
o Supervised

1. Rule Based

 A few semantic parsing systems that performed very well for both

ATIS and Communicator projects were rule-based systems.

 They used an interpreter whose semantic grammar was handcrafted

to be robust to speech recognition errors.

 Syntactic explanation of a sentence is much more complex than the

underlying semantic information.

 Parsing the meaning units in the sentence into semantics proved to

be a better approach.

 In dealing with spontaneous speech the system has to account for

ungrammatical instructions, stutters, filled pauses etc.

 Word order becomes less important which leads to meaning units

scattered in the sentences and not necessarily in the order that

would make sense to a syntactic parser.

 WardÕs system, Phoenix uses a recursive transition network (RTNs)

and a handcrafted grammar to extract a hierarchical frame

structure.

 It reevaluates and adjusts the values of the frames with each new

piece of information obtained.

The system had the following error rates:

 13.2% for spontaneous speech input of which

 4.4% speech recognition word-error rate
 9.3% error for transcript input
2. Supervised
 During the ATIS evaluations some data was hand-tagged for semantic
information.
 Schwartz used that information to create the first end-to-end supervised
statistical learning system for ATIS domain.
They had four components in their system:
 Semantic parse
 Semantic frame
 Discourse
 Backend
This system used a supervised learning approach with quick training augmentation
through a human in-the-loop corrective approach to generate lower quality but
more data for improved supervision.
 This research is now known as natural language interface for databases
(NLIDB).
 Zelleand Mooney tackled the task of retrieving answers from Prolog
database.
 The system tackled the task of retrieving answers from a Prolog database
by converting natural language questions into Prolog queries in the domain
of GeoQuery.
 The CHILL (Constructive Heuristics Induction for Language Learning)
system uses a shift-reduce parser to map the input sentence into parses
expressed as a Prolog program.
 A representation closer to formal logic than SQL is preferred for CHILL
because it can be translated into other equivalent representations.
 It took CHILL175 training queries to match the performance of Geobase.
 KRISP(Kernel based Robust Interpretation for Semantic Parsing) uses
string kernels and SVMs to improve the underlying learning techniques.
 WASP (Word Alignment based Semantic Parsing) takes a radical approach
to semantic parsing by using state-of-the art machine translation
techniques to learn a semantic parser.
Complete meaning representations are then formed by combining these
aligned strings using a synchronous CFG framework.
 SCISSOR is more accurate than WASP and KRISP, which benefits from
SAPTs.
 These systems also have semantic parsers for Spanish, Turkish, and
Japanese with similar accuracies.
Software
The software programs available are as follows:
 WASP
 KRISPER
 CHILL