Dependency Parsing vs. Constituency Parsing

The Story That Makes Parsing Click

Before diving into each approach, it helps to understand why parsing matters in the first place. Most NLP pipelines — from chatbots to search engines to machine translation — need to know not just what words appear, but how those words are grammatically connected. A word bag knows that "dog bites man" and "man bites dog" contain the same words. A parser knows they mean opposite things.

Part I — Dependency Parsing

Dependency Parsing represents a sentence as a directed graph where every word (except one) has exactly one head (a word it depends on), connected by a labeled arc that names the grammatical relationship. The one word with no head is the root — usually the main verb.

Anatomy of a Dependency Tree

Take the sentence: "The quick brown fox jumps over the lazy dog." Below is its dependency structure broken into key components.

                      jumps  [ROOT]
                     /      \
                  fox        over
                 /|\           \
               The quick      dog
                   |          / \
                 brown      the  lazy
    

Universal Dependency Labels — The Most Important Ones

Dependency Parsing Algorithms

Under the hood, dependency parsers use one of two main algorithmic families. Understanding them helps you choose the right tool and interpret speed vs. accuracy tradeoffs.

Dependency Parsing with spaCy — Full Code Walkthrough

Step 1 — Installation and Basic Parse

# Install spaCy and download a model
# pip install spacy
# python -m spacy download en_core_web_sm

import spacy

# Load the small English model (use en_core_web_trf for best accuracy)
nlp = spacy.load("en_core_web_sm")

# Parse a sentence
doc = nlp("The quick brown fox jumps over the lazy dog.")

# Inspect each token's dependency information
print(f"{'Token':12} {'Dep':10} {'Head':12} {'Head POS'}")
print("-" * 45)
for token in doc:
    print(f"{token.text:12} {token.dep_:10} {token.head.text:12} {token.head.pos_}")

Step 2 — Extracting Subject-Verb-Object Triples

def extract_svo(doc):
    """Extract (subject, verb, object) triples from a spaCy doc."""
    triples = []
    for token in doc:
        # Find the main verb (root)
        if token.dep_ == "ROOT" and token.pos_ == "VERB":
            subject = None
            obj      = None
            for child in token.children:
                if child.dep_ in ("nsubj", "nsubjpass"):
                    subject = child.text
                if child.dep_ in ("dobj", "obj"):
                    obj = child.text
            triples.append({
                "verb":    token.text,
                "subject": subject,
                "object":  obj,
            })
    return triples

sentences = [
    "Alice ate the pizza quickly.",
    "The company announced record profits.",
    "Scientists discovered a new exoplanet.",
]

for sent in sentences:
    doc = nlp(sent)
    triples = extract_svo(doc)
    for t in triples:
        print(f"  SUBJ={t['subject']:12} VERB={t['verb']:12} OBJ={t['object']}")

Step 3 — Visualizing the Parse Tree

from spacy import displacy

# Render in a Jupyter notebook (inline SVG)
doc = nlp("Alice quickly sent Bob the urgent report.")
displacy.render(doc, style="dep", jupyter=True)

# Or serve as a local web page
displacy.serve(doc, style="dep", port=5001)

# Or get the raw SVG string
svg = displacy.render(doc, style="dep", page=False)
with open("dep_tree.svg", "w") as f:
    f.write(svg)
print("SVG saved to dep_tree.svg")

Step 4 — Advanced: Navigating Subtrees and Ancestors

doc = nlp("The elderly professor published a groundbreaking paper on quantum computing.")

for token in doc:
    if token.dep_ == "ROOT":
        verb = token
        break

# Full subtree of the root (entire sentence as dependency structure)
print("Root verb:", verb.text)
print("Subtree:  ", [t.text for t in verb.subtree()])

# Direct children classified by function
print("\nDirect children:")
for child in verb.children:
    print(f"  {child.text:15} dep={child.dep_:10} subtree={[t.text for t in child.subtree()]}")

# Token ancestors (path back to root)
target = doc[9]  # "quantum"
print(f"\nAncestors of '{target.text}':", [t.text for t in target.ancestors()])

Real-World Applications of Dependency Parsing

Part II — Constituency Parsing

Constituency Parsing (also called phrase-structure parsing) takes a different perspective. Instead of mapping word-to-word relationships, it groups words into nested phrases (constituents), building a hierarchical tree rooted at the sentence level.

Core Phrase Types in Constituency Grammar

A Full Constituency Tree — Visualized

Sentence: "The quick brown fox jumps over the lazy dog."

                              S
               ┌──────────────┴──────────────────┐
              NP                                 VP
      ┌───┬───┬───┐                     ┌────────┴──────────┐
     DT  JJ  JJ  NN                   VBZ                  PP
     │   │   │   │                     │              ┌─────┴─────┐
    The quick brown fox              jumps            IN          NP
                                                      │       ┌───┴──┐
                                                     over    DT     JJ    NN
                                                             │      │      │
                                                            the    lazy   dog
    

Context-Free Grammars — The Formal Foundation

Constituency parsing is rooted in Context-Free Grammars (CFGs). A CFG defines a set of rewrite rules that expand non-terminal symbols (NP, VP…) into sequences of other symbols.

Constituency Parsing in Python — NLTK & Stanza

Method 1 — NLTK with a Pre-defined Grammar

import nltk
from nltk import CFG, ChartParser

# Download NLTK tokenizer data (once)
nltk.download("punkt", quiet=True)

# Define a simple Context-Free Grammar
grammar = CFG.fromstring("""
  S   -> NP VP
  VP  -> VBZ PP | VBZ NP | VBD NP
  PP  -> IN NP
  NP  -> DT JJ JJ NN | DT JJ NN | DT NN | NNP
  DT  -> 'the' | 'a' | 'The'
  JJ  -> 'quick' | 'brown' | 'lazy' | 'old'
  NN  -> 'fox' | 'dog' | 'man'
  NNP -> 'Alice' | 'Bob'
  VBZ -> 'jumps' | 'runs'
  VBD -> 'saw'
  IN  -> 'over' | 'with'
""")

parser = ChartParser(grammar)
tokens = ["The", "quick", "brown", "fox", "jumps", "over", "the", "lazy", "dog"]

for tree in parser.parse(tokens):
    tree.pretty_print()
    print("Tree string:", str(tree))

Method 2 — Stanza (Neural Berkeley Parser)

import stanza

# Download English models (first time only)
# stanza.download("en")

# Initialize with constituency parse component
nlp = stanza.Pipeline(
    lang="en",
    processors="tokenize,pos,constituency",
    use_gpu=False
)

text = "Alice quickly sent Bob the urgent report on AI safety."
doc = nlp(text)

for sentence in doc.sentences:
    print("Constituency Tree:")
    print(sentence.constituency)
    print()
    # Access tree nodes programmatically
    tree = sentence.constituency
    print("Root label:     ", tree.label)
    print("Root children:  ", [child.label for child in tree.children])

Method 3 — Extracting All Noun Phrases (Chunking / Constituency)

def extract_constituents(tree, target_label):
    """Recursively extract all phrases of a given type from a Stanza tree."""
    results = []
    if tree.label == target_label and tree.is_leaf() is False:
        results.append(" ".join(tree.leaf_labels()))
    for child in tree.children:
        results.extend(extract_constituents(child, target_label))
    return results

# Parse a sentence and extract all NPs and VPs
doc = nlp("The brilliant young researcher published a groundbreaking paper on quantum entanglement.")
tree = doc.sentences[0].constituency

noun_phrases = extract_constituents(tree, "NP")
verb_phrases  = extract_constituents(tree, "VP")

print("Noun Phrases:")
for np in noun_phrases:
    print(f"  NP: {np}")

print("\nVerb Phrases:")
for vp in verb_phrases:
    print(f"  VP: {vp}")

Constituency Parsing with Transformers — Berkeley Neural Parser

Modern state-of-the-art constituency parsers use transformer encoders (BERT, RoBERTa) to produce rich contextualized embeddings, then apply a chart-based decoder. The Berkeley Neural Parser (benepar) integrates directly into spaCy.

# Installation
# pip install benepar
# python -c "import benepar; benepar.download('benepar_en3')"

import spacy
import benepar

# Add benepar to a spaCy pipeline
nlp = spacy.load("en_core_web_md")
if spacy.util.is_package("benepar_en3"):
    nlp.add_pipe("benepar", config={"model": "benepar_en3"})

text = "The old man saw the woman with the telescope."
doc = nlp(text)

for sent in doc.sents:
    print("Parse string:", sent._.parse_string)
    print("Labels:      ", list(sent._.labels))
    print()
    # Access spans for each constituent
    for span in sent._.constituents:
        if span._.labels:
            print(f"  {str(span._.labels):20} → '{span.text}'")

Head-to-Head — Dependency vs. Constituency Parsing

Both paradigms model sentence structure, but they emphasize different aspects. The choice depends on your downstream task.

Evaluation Metrics for Parsers

Dependency Parsing — Labeled & Unlabeled Attachment Score

Constituency Parsing — Labeled Bracketing F1

End-to-End Pipeline — Combining Both Parsers

Real NLP systems often combine dependency and constituency information. Below is a production-grade pipeline that extracts rich structural features from text.

import spacy
import stanza
from collections import defaultdict

# ── 1. Dependency parsing with spaCy ─────────────────────────
dep_nlp = spacy.load("en_core_web_sm")

# ── 2. Constituency parsing with Stanza ──────────────────────
con_nlp = stanza.Pipeline(
    lang="en",
    processors="tokenize,pos,constituency",
    use_gpu=False,
    verbose=False
)

def full_parse_report(text):
    """Run both parsers and print a combined structural report."""
    print(f"\n{'='*60}")
    print(f"TEXT: {text}")
    print('='*60)

    # ── Dependency features ──────────────────────────────────────
    dep_doc = dep_nlp(text)
    relations = defaultdict(list)
    for token in dep_doc:
        relations[token.dep_].append(token.text)

    print("\n[DEPENDENCY]")
    print(f"  Root:    {[t.text for t in dep_doc if t.dep_ == 'ROOT']}")
    print(f"  Subjects:{relations.get('nsubj', [])}")
    print(f"  Objects: {relations.get('dobj', relations.get('obj', []))}")
    print(f"  Modifiers:{relations.get('amod', [])}")

    # ── Constituency features ────────────────────────────────────
    con_doc = con_nlp(text)
    print("\n[CONSTITUENCY]")
    for sent in con_doc.sentences:
        tree = sent.constituency
        nps = _get_phrases(tree, "NP")
        vps = _get_phrases(tree, "VP")
        print(f"  Noun Phrases:  {nps}")
        print(f"  Verb Phrases:  {vps}")

def _get_phrases(tree, label):
    results = []
    if tree.label == label and len(tree.children) > 0:
        results.append(" ".join(tree.leaf_labels()))
    for c in tree.children:
        results.extend(_get_phrases(c, label))
    return results

# Run on sample sentences
full_parse_report("The brilliant scientist discovered a new vaccine.")
full_parse_report("The city council approved the new budget yesterday.")

Common Pitfalls and How to Avoid Them

Quick Reference — Cheat Sheet