Dependency Parsing

Every relation in a dependency tree is a directed link from a head (governor) to a dependent (modifier). The head determines the syntactic category of the phrase, while the dependent provides supplementary information.

• In "the large server," server is the head and large is the adjectival dependent
• The verb is typically the root head of the entire sentence
• This asymmetry directly maps to semantic role labeling, where heads often correspond to predicates and dependents to arguments

Universal Dependencies (UD) is a cross-linguistically consistent annotation framework that standardizes dependency relations across over 100 languages. It defines 37 universal syntactic relations.

• Core relations include nsubj (nominal subject), dobj (direct object), and amod (adjectival modifier)
• UD treebanks provide the training data for modern neural dependency parsers
• For entity salience, UD parses reveal which tokens are syntactically subordinate to a target named entity

Two dominant algorithmic paradigms exist for constructing dependency trees:

Transition-Based Parsers build the tree incrementally using a stack and buffer with actions like SHIFT, LEFT-ARC, and RIGHT-ARC. They operate in linear time O(n) and are suited for real-time applications.

Graph-Based Parsers score all possible arcs globally and select the maximum spanning tree. They achieve higher accuracy on long-range dependencies but incur O(n³) complexity before optimizations like the Eisner algorithm.

A dependency tree is projective if no arcs cross when the sentence is drawn linearly above the text. Non-projective structures occur in languages with free word order, such as Czech or Dutch.

• English parses are predominantly projective, simplifying parsing algorithms
• Non-projective parsing requires specialized techniques like pseudo-projective transformations or the Chu-Liu/Edmonds algorithm
• Crossing dependencies often signal complex syntactic phenomena like extraposition or wh-movement

The Dozat and Manning (2017) biaffine parser architecture remains the dominant neural approach. It uses a deep biaffine attention mechanism to score head-dependent pairs independently.

• A BiLSTM or transformer encoder generates contextualized token representations
• Two separate feedforward networks produce head and dependent representations
• A biaffine classifier scores every possible arc and label simultaneously, achieving state-of-the-art accuracy on UD benchmarks

Dependency parse trees enable quantitative salience scoring by measuring the syntactic distance between an entity mention and the root verb. Entities closer to the root are typically more central to the discourse.

• Dependency depth: the number of arcs between an entity and the root
• Entities in subject position (nsubj) consistently score higher salience than those in oblique or modifier positions
• This metric feeds directly into information gain scoring and AI-generated summarization control

The process of detecting the semantic arguments associated with the predicate or verb of a sentence and classifying them into specific roles like agent, patient, and instrument. While dependency parsing establishes syntactic head-dependent relations, SRL answers 'who did what to whom' by identifying predicate-argument structures. For example, in 'Mary sold the book to John,' SRL labels Mary as the seller (agent), the book as the item sold (theme), and John as the recipient. Modern SRL systems often operate directly on dependency parse trees, using the syntactic arcs as input features for semantic role classifiers.

A rooted, directed, acyclic graph representation of the semantics of a natural language sentence that abstracts away from syntactic structure to capture 'who is doing what to whom'. Unlike dependency trees, AMR graphs collapse function words and focus on conceptual meaning. For instance, 'The dog was chased by the cat' and 'The cat chased the dog' share the same AMR graph despite different syntactic structures. AMR parsing often uses dependency parses as an intermediate step, leveraging syntactic relations to predict semantic graph edges.

The NLP task of finding all expressions in a text that refer to the same real-world entity. This includes linking pronouns ('she', 'it'), definite noun phrases ('the company'), and named entities back to their antecedents. Dependency parsing provides critical syntactic cues for this task—the grammatical role and position of mentions in the dependency tree help algorithms determine which entities are likely coreferents. For example, a pronoun in subject position is more likely to refer to the subject of the previous sentence.

An information extraction subtask that locates and classifies named entities in unstructured text into pre-defined categories such as person names, organizations, locations, and medical codes. Dependency parsing enhances NER by providing syntactic context—entities often correspond to specific dependency subtrees, and the head-dependent relationships help disambiguate entity boundaries. For instance, in 'Apple Inc. announced,' the dependency arc from 'announced' to 'Apple Inc.' confirms it as a single nominal entity acting as the subject.

The task of detecting and classifying semantic relationships between two or more named entities from unstructured text. Common relations include 'works for', 'located in', and 'founded by'. Dependency parsing is fundamental here—the shortest dependency path between two entity mentions often encodes the relationship type. For example, in 'Tim Cook, CEO of Apple,' the dependency path between 'Tim Cook' and 'Apple' traverses the appositive and prepositional relations, directly signaling an employment relationship.

The automated process of selecting a set of terms or short phrases from a document that best describe its subject matter. Algorithms like RAKE and YAKE use syntactic patterns derived from dependency parses to identify candidate phrases. By analyzing head-modifier relations, these systems extract multi-word expressions where the syntactic cohesion indicates semantic unity. For example, a noun compound like 'machine learning algorithm' forms a single dependency subtree and is extracted as one keyphrase rather than three separate words.