Sanskrit Dependency Parsing

1. Introduction

Sanskrit is a classical language with a rich inflectional morphology and a relatively free word order. Because grammatical relations are primarily expressed through case endings rather than fixed positions, traditional phrasestructure parsing techniques often struggle with Sanskrit text. Dependency parsingwhere the syntactic structure is represented as a set of binary headdependent relationsoffers a natural fit for languages like Sanskrit. This page provides an overview of the challenges, major research efforts, and practical tools for building and using Sanskrit dependency parsers.

2. Why Dependency Parsing?

• Morphological richness: A single Sanskrit word can encode tense, voice, person, number, gender, and case. Dependency models can directly exploit these morphological tags.
• Free word order: Subjectobjectverb (SOV) is the canonical order, but words can appear in many permutations without changing the meaning. Dependency graphs capture relations irrespective of linear position.
• Semantic transparency: Headdependent structures align well with the traditional Sanskrit syntactic concepts of karaka (semantic roles) and samasa (compound formation).

3. Core Linguistic Concepts

Understanding Sanskrit grammar helps in designing a parser.

3.1 Karakas

The eight karaka roleskarta (agent), karma (patient), karana (instrument), sampradna (beneficiary), apdna (source), adhikra (location), sambandha (relation), and vibhakti (oblique)are essentially dependency labels. Modern parsers commonly map these to universal dependencies such as nsubj, obj, iobj, etc.

3.2 Compounds (Samsa)

Sanskrit compounds can be up to several words long, with internal dependencies that are not obvious from surface order. A good parser must identify the head of the compound and attach modifiers appropriately.

3.3 Sandhi

Phonological coalescence (sandhi) merges word boundaries, creating challenges for tokenisation. Most pipelines first run a sandhi splitter before syntactic analysis.

4. Major Research Projects

4.1 The Sanskrit Dependency Treebank (SanskritDT)

The SanskritDT is a manually annotated corpus of around 3,000 sentences drawn from classical texts (the Vedas, Upanishads, and epic literature). It follows the Universal Dependencies (UD) scheme, providing POS tags, morphological features, and headdependent relations.

4.2 Classical Sanskrit Dependency Parser (CSDP)

CSDP, released by the International Institute of Classical Studies, uses a transitionbased parser built on the spaCy framework. Training on SanskritDT yields an F1 score of ~89% for labeled attachment, which is competitive with parsers for other highly inflected languages.

4.3 Neural Approaches

Recent work applies transformerbased models (e.g., BERTSanskrit, mBERT) as contextual encoders, feeding their representations to a biaffine graphbased parser. Experiments reported in ACL 2023 achieve >92% LAS on heldout test sets.

5. Building a Sanskrit Dependency Parser

5.1 Data Preparation

1. Tokenisation & Sandhi Splitting Use tools like SFST or the sandhi-splitter library to obtain word boundaries.
2. Morphological Tagging Apply Vka or shallow parser models that output case, gender, number, etc.
3. Conversion to CoNLLU The UD format is the defacto standard; each token line contains ID, FORM, LEMMA, UPOS, XPOS, FEATS, HEAD, DEPREL, DEPS, MISC.

5.2 Model Choices

• TransitionBased Parsers (e.g., MaltParser, spaCy) Fast, easier to train on modest data.
• GraphBased Parsers (e.g., Biaffine parser) More accurate for longrange dependencies, especially for compounds.
• EndtoEnd Neural Models Combine a multilingual BERT encoder with a parser head; requires GPU for training.

5.3 Training Pipeline (Python example)

import spacyfrom spacy.tokens import Docfrom sacremoses import MosesTokenizer# 1. Load a Sanskrit BERT model (e.g., indicnlp/bert-base-sanskrit)import transformersbert = transformers.AutoModel.from_pretrained('indicnlp/bert-base-sanskrit')tokenizer = transformers.AutoTokenizer.from_pretrained('indicnlp/bert-base-sanskrit')# 2. Build a spaCy pipelinenlp = spacy.blank("sa")  # 'sa' is the ISO code for Sanskrit# custom component: BERT embeddingsdef bert_vectors(doc):    inputs = tokenizer([t.text for t in doc], return_tensors='pt', padding=True)    with torch.no_grad():        embeddings = bert(**inputs).last_hidden_state    for token, vec in zip(doc, embeddings[0]):        token._.set('bert_vec', vec)    return docspacy.Token.set_extension('bert_vec', default=None)nlp.add_pipe(bert_vectors, name="bert_vectors", first=True)# 3. Add a dependency parser (trained on SanskritDT)parser = spacy.load("path/to/sanskrit_parser")nlp.add_pipe(parser)# 4. Parse a sentencedoc = nlp("  ")for token in doc:    print(token.text, token.dep_, token.head.text, token.morph)

5.4 Evaluation

Standard metrics are Unlabeled Attachment Score (UAS) and Labeled Attachment Score (LAS). For Sanskrit, it is also useful to report accuracy on specific karaka roles, because some relations (e.g., obl vs. advmod) are harder to distinguish.

6. Applications

• Digital Humanities Automatic syntactic analysis enables searching for particular grammatical constructions across large corpora.
• Machine Translation Dependency structures improve alignment quality when translating Sanskrit to modern languages.
• Question Answering Semantic role labeling derived from dependencies helps extract answers to queries about mythological narratives.
• Linguistic Research Quantitative studies of wordorder variation, case usage, and compound formation rely on parsed data.

7. Future Directions

While existing parsers achieve respectable scores, several avenues remain open:

1. LowResource Learning Leveraging crosslingual transfer from Hindi or other IndoAryan languages can further boost performance on limited Sanskrit data.
2. Joint SandhiParsing Models Integrating sandhi splitting directly into the parser could reduce error propagation.
3. Semantic Parsing Moving from syntactic dependencies to predicateargument structures (AMRlike representations) would enable deeper understanding.
4. Explainability Providing linguistically informed visualizations (e.g., karaka tables) helps scholars trust and interpret parser output.

8. Getting Started

If you want to experiment with Sanskrit dependency parsing, follow these steps:

1. Clone the SanskritDT repository and explore the CoNLLU files.
2. Install a parser such as spacyudpipe or the stanza Sanskrit model.
3. Run a quick test:

pip install stanzapython -m stanza.install saimport stanzanlp = stanza.Pipeline('sa')doc = nlp("    ")doc.sentences[0].print_dependencies()

This will output a tree with heads and dependency labels compatible with the UD schema.