Semantic Parsing and Meaning Representations › Abstract Meaning Representation

Abstract Meaning Representation, or AMR, is a sentence-level semantic graph formalism. Banarescu et al. (2013) presented its influential sembanking framework, building on earlier AMR and PENMAN work. AMR represents the meaning of a sentence as a rooted, directed graph. Nodes are concepts. Edges are relations. The graph can share nodes, which lets it represent reentrancy and control. AMR was designed to be simple enough for rapid human annotation and abstract enough to be stable across paraphrases. It has since become a standard target for graph-based semantic parsing and a useful representation for summarization, information extraction, machine translation, and semantic similarity.

A constituency tree represents how words group into phrases. An AMR graph represents who did what to whom, and how the participants relate. The difference is easiest to see with control verbs. In "The boy wants to go", the boy is the subject of "wants" and also the understood subject of "go". A constituency analysis can mark this with a co-indexed empty category. An AMR graph simply reuses the same node, which makes the shared participant explicit and easy to query.

For example, "The boy wants to go" becomes something like:

(w / want-01
   :ARG0 (b / boy)
   :ARG1 (g / go-02
            :ARG0 b))

The variable w is an instance of the PropBank frame want-01. Its :ARG0 is the wanter, the boy b. Its :ARG1 is the thing wanted, an instance g of go-02. The goer is also b, so the graph reuses the same node. That reuse is reentrancy: the boy is both the wanter and the understood goer. The go-02 node describes what he wants; it does not assert that he actually goes.

Reentrancy is a structural property of the graph. Drawing the nodes and role edges shows that one boy node serves as both the wanter and the goer.

AMR uses several kinds of labels:

• Concepts: boy, go-02, want-01, city, person.
• Frame roles: :ARG0, :ARG1, :ARG2, and so on, with meanings defined by PropBank frames.
• General relations: :mod, :time, :location, :topic, :poss, :part-of.
• Inverse roles: :ARG0-of and :location-of reverse the direction of the corresponding role in the written graph.
• Constants: literal strings, numbers, and symbolic values such as - for polarity. Names and dates usually use structured name and date-entity subgraphs containing literal values.

The PropBank frames deserve a note. Each roleset defines a predicate sense and its associated argument roles. want-01 is the frame for the desire sense, not for the sense of "want" that means "lack". The numbered roles are not thematic roles in the abstract; they are frame-specific. This makes AMR precise but also makes it dependent on the frame lexicon. Annotators and parsers must select the intended frame.

AMR is "abstract" because it deliberately drops some surface distinctions. It does not represent word order. It usually does not represent articles. It does not encode quantifier scope in the way first-order logic does. The base annotation framework specifies target graphs without prescribing a syntax-to-semantics derivation from English. The base annotation conventions omit some truth-conditional distinctions discussed here. Formal interpretations have nevertheless been proposed: Bos (2016) gives a translation into first-order logic and discusses scope extensions.

AMR is usually written in PENMAN notation. The format is a parenthesized graph with variables, concepts, and role edges. The earlier example is valid PENMAN. For the concept-labeled AMR graphs used here, each structural opening parenthesis introduces a variable, a slash, and a concept. Each role is written as a colon followed by a label, and each role can point to a node or a constant.

PENMAN is compact and readable, but it is not a programming language. It is a linearization of a graph. The same graph can be written in multiple ways by reordering edges or using inverse roles. For example, (w / want-01 :ARG0 (b / boy)) and (b / boy :ARG0-of (w / want-01)) describe the same labeled relation. They choose different roots, so they also differ in the focus convention of AMR; matching a single edge is weaker than matching a complete rooted AMR. That flexibility is useful for annotation, but it complicates parsing and evaluation. A parser that generates PENMAN strings must produce valid parentheses, valid variable references, and consistent reentrancy.

AMR parsing maps a sentence to an AMR graph. Early systems used graph-based or transition-based methods. Sequence-to-sequence approaches encode the sentence and decode a graph serialization, including PENMAN strings; pretrained encoder-decoder models have also been used for this task. Graph-aware decoding can use the partially constructed graph to guide subsequent expansion, as in Cai and Lam (2020). A sequence-to-sequence model can produce valid graphs, but unconstrained generation does not guarantee validity. Grammar constraints and graph checks can help enforce that requirement.

Evaluation is usually done with Smatch, introduced by Cai and Knight in 2013. Smatch compares instance, attribute, and relation triples under a mapping between predicted and reference node variables. Its objective maximizes matching triples and computes precision, recall, and F1 from that overlap. Common implementations search with hill climbing and restarts, so the returned alignment need not attain the global maximum. Variable names themselves do not matter. What matters is the graph structure and the labels.

The variable-alignment step is necessary because two graphs can be structurally identical but use different variable names. Smatch computes F1 using the selected alignment, rather than comparing variable spellings directly.

Smatch is useful, but it has limitations. It can reward graphs that are structurally similar but semantically wrong. It does not directly evaluate truth conditions or executability. It is also sensitive to annotation choices. Two annotators may produce different graphs for the same sentence. Choices about implicit relations, light verbs, and named entities can change those graphs. AMR is a semantic representation language. These limitations are not fatal. They mean Smatch should be read as a measure of graph overlap, not as a measure of understanding.

AMR keeps a great deal of predicate-argument structure. It captures who did what, to whom, with what, where, and when. Reentrancy represents control and shared participants, and the graph can include named entities and quantities. Research applications include summarization, information extraction, machine translation, and semantic similarity. Annotation effort depends on the annotators, genre, tools, and agreement protocol. In the original AMR study, annotators using AMR Editor took 7-10 minutes to create a sentence annotation and 1-3 minutes to postedit one. Four experts annotated 100 newswire and 80 web sentences, then formed a consensus through discussion; average expert-versus-consensus Smatch was 0.83 for newswire and 0.79 for web text. These are study-specific measurements, not a general comparison with full logical-form annotation.

AMR drops other distinctions:

• It does not encode quantifier scope in a general way.
• It does not preserve surface word order.
• It often normalizes morphology and light verbs.
• Its base conventions omit distinctions such as general quantifier scope; additional formal interpretation and extensions are needed for those distinctions.

These are not bugs. They are design choices intended to make the representation more abstract and stable across paraphrases. Base AMR does not retain general quantifier scope. Using an AMR graph as a database query also requires an additional query interpretation or translation.

For tasks that need scope, such as reasoning about several quantifiers, AMR is a poor fit. For tasks that need predicate-argument structure, such as event extraction or summarization, it is a strong fit.