Datasets:

commul
/

universal_dependencies

Parquet format: Native support with datasets >=4.0.0 (5-10x faster loading)
No Python script: Dataset no longer requires trust_remote_code=True
External helper library: CoNLL-U processing utilities moved to ud-hf-parquet-tools

Data Changes:

MWT bug fix: Token sequences now correctly exclude Multi-Word Token surface forms
MWT field added: New structured mwt field with Multi-Word Token information
Enhanced metadata: Includes num_fused (MWT counts) in statistics

Quick Start

For Users with datasets >=4.0.0

No code changes needed! Parquet files load automatically:

from datasets import load_dataset

# v2.0: Works seamlessly with datasets >=4.0.0
dataset = load_dataset("commul/universal_dependencies", "fr_gsd")
# Automatically uses Parquet format (fast, secure)

For Users with datasets <4.0.0

Option 1: Upgrade datasets (Recommended)

pip install --upgrade "datasets>=4.0.0"

Option 2: Continue using v1.x

# v1.x: Requires trust_remote_code
dataset = load_dataset("commul/universal_dependencies", "fr_gsd", trust_remote_code=True, revision="v1.0")

Breaking Changes

1. Token Sequences Now Exclude MWT Forms

Impact: Token counts and sequences have changed for treebanks with Multi-Word Tokens (MWTs).

What Changed:

v1.x incorrectly included MWT surface forms in token sequences
v2.0 correctly excludes them, matching UD guidelines

Example (French "des" → "de" + "les"):

# v1.x (BUGGY):
{
    "tokens": ["Elle", "des", "de", "les", "pommes", "."],  # WRONG: "des" included
    "lemmas": ["elle", "_", "de", "le", "pomme", "."],
    "upos": ["PRON", "_", "ADP", "DET", "NOUN", "PUNCT"],
}

# v2.0 (CORRECT):
{
    "tokens": ["Elle", "de", "les", "pommes", "."],  # CORRECT: only syntactic words
    "lemmas": ["elle", "de", "le", "pomme", "."],
    "upos": ["PRON", "ADP", "DET", "NOUN", "PUNCT"],
    "mwt": [{"id": "2-3", "form": "des", "misc": ""}],  # MWT info preserved
}

Affected Treebanks (50+):

Languages with common MWTs include:

French (fr_*): du, au, des, aux (~2-5% of tokens)
Italian (it_*): del, della, nel, alla (~1-3%)
Portuguese (pt_*): do, da, no, pelo (~2-4%)
Spanish (es_*): del, al (~0.5-1%)
Arabic (ar_*): various clitics (~1-2%)
German (de_*): zum, vom, am (~0.1-0.5%)
Catalan (ca_*): del, al, pels (~1-2%)
Indonesian (id_*): reduplications (~0.1%)

Action Required:

If your code assumes specific token counts or positions:

# v1.x code that might break:
def get_third_token(example):
    return example["tokens"][2]  # May return different token in v2.0

# Migration fix:
def get_third_syntactic_word(example):
    # v2.0: This is now correct - gets the 3rd syntactic word
    return example["tokens"][2]

def get_third_surface_token(example):
    # v2.0: If you need surface forms, reconstruct from MWTs
    tokens = example["tokens"][:]
    mwts = example["mwt"]

    # Insert MWT forms at appropriate positions
    for mwt in reversed(mwts):  # Process in reverse to maintain indices
        start, end = map(int, mwt["id"].split("-"))
        tokens[start-1:end] = [mwt["form"]]

    return tokens[2]

2. New Schema Field: `mwt`

Impact: Dataset schema now includes an mwt field.

What Changed:

Added: mwt field containing structured MWT information
Schema: [{"id": "1-2", "form": "surface_form", "misc": "metadata"}]
Empty list for treebanks without MWTs

Example Usage:

from datasets import load_dataset

dataset = load_dataset("commul/universal_dependencies", "fr_gsd", split="train")

# Access MWT information
for example in dataset:
    if example["mwt"]:  # Has MWTs
        for mwt in example["mwt"]:
            print(f"MWT {mwt['id']}: {mwt['form']}")
            # Extract range
            start, end = map(int, mwt["id"].split("-"))
            syntactic_words = example["tokens"][start-1:end]
            print(f"  → {' + '.join(syntactic_words)}")

# Output example:
# MWT 2-3: des
#   → de + les

Research Use Cases:

# Count MWTs per treebank
def count_mwts(dataset):
    return sum(len(ex["mwt"]) for ex in dataset)

# Analyze MWT patterns
def analyze_mwt_patterns(dataset):
    patterns = {}
    for ex in dataset:
        for mwt in ex["mwt"]:
            form = mwt["form"]
            patterns[form] = patterns.get(form, 0) + 1
    return patterns

fr_gsd = load_dataset("commul/universal_dependencies", "fr_gsd", split="train")
print(analyze_mwt_patterns(fr_gsd))
# Output: {'des': 1234, 'du': 987, 'au': 654, 'aux': 321, ...}

3. Requires datasets >=4.0.0

Impact: The Python script loader is deprecated (datasets >=4.0.0 policy).

What Changed:

v1.x: Uses Python script with trust_remote_code=True
v2.0: Uses Parquet format (no remote code execution)

Security Benefit:

No arbitrary code execution from dataset loading
Parquet files are data-only, sandboxed
Aligns with HuggingFace security policies

Migration:

# Check your datasets version
python -c "import datasets; print(datasets.__version__)"

# Upgrade if needed
pip install --upgrade "datasets>=4.0.0"

If you cannot upgrade datasets:

# Use v1.x with revision pinning
dataset = load_dataset(
    "commul/universal_dependencies",
    "fr_gsd",
    trust_remote_code=True,
    revision="v1.0"  # Pin to v1.x
)

Helper Functions Moved to External Library

Important: Helper functions for CoNLL-U processing are now in a separate package.

What Moved

The following functions are no longer part of the dataset:

parse_feats(), parse_misc(), parse_deps() - Parse CoNLL-U field strings
write_conllu(), example_to_conllu() - Export data to CoNLL-U format
Various internal conversion utilities

How to Access Helper Functions

If you need CoNLL-U processing utilities, install the external library:

pip install ud-hf-parquet-tools

Then import from the package:

from datasets import load_dataset
from ud_hf_parquet_tools import parse_feats, parse_misc, write_conllu

# Load dataset
ds = load_dataset("commul/universal_dependencies", "en_ewt", split="train")

# Parse optional fields
sentence = ds[0]
for i, token in enumerate(sentence['tokens']):
    feats = parse_feats(sentence['feats'][i])  # Returns dict or {}
    misc = parse_misc(sentence['misc'][i])      # Returns dict or {}
    print(f"{token}: UPOS={sentence['upos'][i]}, feats={feats}, misc={misc}")

# Export back to CoNLL-U format
write_conllu(ds, "output.conllu")

Library Documentation: https://github.com/bot-zen/ud-hf-parquet-tools

If You Don't Need Helper Functions

Most users only need the dataset itself and can work directly with the fields:

from datasets import load_dataset

ds = load_dataset("commul/universal_dependencies", "en_ewt", split="train")

# Access data directly
sentence = ds[0]
print(f"Tokens: {sentence['tokens']}")
print(f"POS tags: {sentence['upos']}")
print(f"Dependencies: {sentence['deprel']}")

# FEATS and MISC are strings in CoNLL-U format
print(f"Features (raw): {sentence['feats'][0]}")  # e.g., "Case=Nom|Number=Sing"
print(f"Misc (raw): {sentence['misc'][0]}")       # e.g., "SpaceAfter=No"

# Parse manually if needed (simple cases)
feats_str = sentence['feats'][0]
if feats_str:
    feats_dict = dict(kv.split('=') for kv in feats_str.split('|'))
    print(f"Features (parsed): {feats_dict}")

New Features in v2.0

1. Parquet Format (5-10x Faster Loading)

# v1.x: Downloads CoNLL-U, parses on-the-fly (~10-30 seconds)
dataset = load_dataset("commul/universal_dependencies", "fr_gsd", trust_remote_code=True)

# v2.0: Loads pre-processed Parquet (~1-3 seconds)
dataset = load_dataset("commul/universal_dependencies", "fr_gsd")

Benefits:

Much faster loading (especially for large treebanks)
Lower memory usage
Better compression
Native support in datasets >=4.0.0

2. Multi-Word Token (MWT) Information

dataset = load_dataset("commul/universal_dependencies", "fr_gsd", split="train")

# Find sentences with MWTs
sentences_with_mwts = [ex for ex in dataset if ex["mwt"]]
print(f"Sentences with MWTs: {len(sentences_with_mwts)}/{len(dataset)}")

# Analyze MWT complexity
complex_mwts = [ex for ex in dataset if any(
    int(mwt["id"].split("-")[1]) - int(mwt["id"].split("-")[0]) > 2
    for mwt in ex["mwt"]
)]
print(f"Sentences with 3+ word MWTs: {len(complex_mwts)}")

3. Enhanced Metadata

# Load dataset info
from datasets import load_dataset_builder

builder = load_dataset_builder("commul/universal_dependencies", "fr_gsd")
info = builder.info

# Now includes MWT statistics
print(info.description)  # Contains num_fused counts

Verification Steps

1. Verify Token Counts Match UD Stats

from datasets import load_dataset
import json

# Load dataset and metadata
dataset = load_dataset("commul/universal_dependencies", "fr_gsd", split="train")

# Count syntactic words
word_count = sum(len(ex["tokens"]) for ex in dataset)

# Load metadata (if available)
with open("metadata.json") as f:
    metadata = json.load(f)

expected_words = int(metadata["fr_gsd"]["splits"]["train"]["num_words"])
print(f"Dataset words: {word_count}")
print(f"Expected words: {expected_words}")
print(f"Match: {word_count == expected_words}")

# This should be True in v2.0 (was False in v1.x for MWT treebanks)

2. Verify MWT Extraction

# Count MWTs
mwt_count = sum(len(ex["mwt"]) for ex in dataset)

expected_mwts = int(metadata["fr_gsd"]["splits"]["train"]["num_fused"])
print(f"Dataset MWTs: {mwt_count}")
print(f"Expected MWTs: {expected_mwts}")
print(f"Match: {mwt_count == expected_mwts}")

3. Compare v1.x vs v2.0 Output

# Load both versions (if v1.x still available)
v1 = load_dataset("commul/universal_dependencies", "en_ewt", split="test[:10]", revision="v1.0", trust_remote_code=True)
v2 = load_dataset("commul/universal_dependencies", "en_ewt", split="test[:10]")

# English-EWT has no MWTs, so should be identical except for new field
for i in range(10):
    assert v1[i]["tokens"] == v2[i]["tokens"], f"Example {i} differs"
    assert v2[i]["mwt"] == [], f"Example {i} has unexpected MWTs"

print("✓ English-EWT unchanged (no MWTs)")

# French-GSD has MWTs, so v2.0 will differ
v1_fr = load_dataset("commul/universal_dependencies", "fr_gsd", split="test[:10]", revision="v1.0", trust_remote_code=True)
v2_fr = load_dataset("commul/universal_dependencies", "fr_gsd", split="test[:10]")

# v1.x token count includes MWTs (WRONG)
v1_token_count = sum(len(ex["tokens"]) for ex in v1_fr)

# v2.0 token count excludes MWTs (CORRECT)
v2_token_count = sum(len(ex["tokens"]) for ex in v2_fr)

print(f"v1.x French token count: {v1_token_count} (includes MWT forms)")
print(f"v2.0 French token count: {v2_token_count} (syntactic words only)")
print(f"Difference: {v1_token_count - v2_token_count} MWT forms removed")

Common Issues

Issue 1: "Dataset script not supported" Error

Error:

RuntimeError: Dataset scripts are no longer supported

Cause: Using datasets >=4.0.0 with v1.x loader

Solution:

pip install --upgrade "datasets>=4.0.0"
# Then use v2.0 (Parquet-based)

Issue 2: Token Count Mismatch

Issue: Your code expects specific token counts that changed in v2.0

Solution: Update your code to use num_words from metadata instead of num_tokens

# v1.x: Used num_tokens (WRONG for MWT treebanks)
expected_count = metadata["splits"]["train"]["num_tokens"]

# v2.0: Use num_words (CORRECT)
expected_count = metadata["splits"]["train"]["num_words"]

Issue 3: MWT Field Not Found (v1.x Code)

Issue: Old code doesn't handle the new mwt field

Solution: Gracefully handle the field or upgrade

# Backwards compatible code
tokens = example["tokens"]
mwts = example.get("mwt", [])  # Empty list if not present

Issue 4: Helper Function Import Errors

Error:

from universal_dependencies import parse_feats
# ImportError: No module named 'universal_dependencies'

Cause: Helper functions moved to separate library

Solution:

# Install the helper library
pip install ud-hf-parquet-tools

# Update imports
from ud_hf_parquet_tools import parse_feats, parse_misc, write_conllu

Or work with raw strings directly (see "If You Don't Need Helper Functions" section above).

Support

If you encounter issues during migration:

Check the CHANGELOG.md for detailed changes
Review the README.md for updated examples
Helper library documentation: https://github.com/bot-zen/ud-hf-parquet-tools
Report issues at: https://huggingface.co/datasets/commul/universal_dependencies/discussions

Summary

Key Takeaways:

✅ v2.0 is more correct: Fixes critical MWT bug ✅ v2.0 is faster: Parquet format is 5-10x quicker ✅ v2.0 is more secure: No remote code execution ✅ v2.0 adds features: MWT information now available ✅ v2.0 is modular: Helper functions available as separate library

Migration Checklist:

Upgrade to datasets >=4.0.0
Test your code with v2.0 data
Update token count expectations (if using MWT treebanks)
Update any hard-coded token indices (if applicable)
If using helper functions: Install ud-hf-parquet-tools and update imports
If exporting to CoNLL-U: Use write_conllu() from ud-hf-parquet-tools
Utilize new MWT field for research (optional)

Estimated Migration Time:

Basic usage: 15-30 minutes
With helper functions: +10 minutes (install library, update imports)

Resources:

Dataset repository: https://huggingface.co/datasets/commul/universal_dependencies
Helper library: https://github.com/bot-zen/ud-hf-parquet-tools
CHANGELOG: CHANGELOG.md

Migration Guide: v1.x → v2.0

What's New in v2.0

Quick Start

For Users with datasets >=4.0.0

For Users with datasets <4.0.0

Breaking Changes

1. Token Sequences Now Exclude MWT Forms

2. New Schema Field: mwt

3. Requires datasets >=4.0.0

Helper Functions Moved to External Library

What Moved

How to Access Helper Functions

If You Don't Need Helper Functions

New Features in v2.0

1. Parquet Format (5-10x Faster Loading)

2. Multi-Word Token (MWT) Information

3. Enhanced Metadata

Verification Steps

1. Verify Token Counts Match UD Stats

2. Verify MWT Extraction

3. Compare v1.x vs v2.0 Output

Common Issues

Issue 1: "Dataset script not supported" Error

Issue 2: Token Count Mismatch

Issue 3: MWT Field Not Found (v1.x Code)

Issue 4: Helper Function Import Errors

Support

Summary

2. New Schema Field: `mwt`