yashkumaratri/wikidata-label-maps-20250820

Wikidata Label Maps 2025-08-20

Label maps extracted from the 2025-08-20 Wikidata dump.
Use these to resolve Q and P identifiers to English labels quickly.

Files

• entity_map.parquet - columns: id, label, description
  Q items. 77.4M rows.
• prop_map.parquet - columns: id, label, description, datatype
  P items. 11,568 rows.

All files are Parquet with Zstandard compression.

Download Options

A) Hugging Face snapshot to a local folder

from huggingface_hub import snapshot_download
local_dir = snapshot_download(repo_id="yashkumaratri/wikidata-label-maps-20250820")
print(local_dir)  # contains entity_map.parquet and prop_map.parquet

B) Git LFS

git lfs install
git clone https://huggingface.co/datasets/yashkumaratri/wikidata-label-maps-20250820

Citation

If you find this dataset useful in your research or applications, please consider citing it:

@misc{atri2025wikidatalabelmaps,
  title        = {Wikidata Label Maps (20250820 snapshot)},
  author       = {Yash Kumar Atri},
  year         = {2025},
  howpublished = {\url{https://huggingface.co/datasets/yashkumaratri/wikidata-label-maps-20250820}},
  note         = {Dataset on Hugging Face}
}

This dataset is part of ongoing work on large-scale dynamic knowledge resources; a broader benchmark and paper will be released later.

Usage Examples

Polars

Basic usage:

import polars as pl

pq = pl.read_parquet("entity_map.parquet")
pp = pl.read_parquet("prop_map.parquet")

print(pq.shape, pp.shape)
print(pq.head(3))
print(pp.filter(pl.col("id") == "P31"))

Lazy joins for speed and low memory:

import polars as pl

events = pl.scan_parquet("events_sample.parquet")  # needs subj_id, pred_id, maybe obj_id
pp = pl.scan_parquet("prop_map.parquet").select("id","label","datatype").rename({"id":"pred_id","label":"predicate_label","datatype":"predicate_datatype"})
pq = pl.scan_parquet("entity_map.parquet").select("id","label").rename({"id":"subj_id","label":"subject_label"})

resolved = (
    events
    .join(pp, on="pred_id", how="left")
    .join(pq, on="subj_id", how="left")
).collect(streaming=True)

print(resolved.head())

pandas

import pandas as pd

pq = pd.read_parquet("entity_map.parquet", columns=["id","label"])
pp = pd.read_parquet("prop_map.parquet", columns=["id","label","datatype"])

events = pd.read_parquet("events_sample.parquet", columns=["subj_id","pred_id"])

events = events.merge(pp.rename(columns={"id":"pred_id","label":"predicate_label","datatype":"predicate_datatype"}), on="pred_id", how="left")
events = events.merge(pq.rename(columns={"id":"subj_id","label":"subject_label"}), on="subj_id", how="left")
print(events.head())

Hugging Face datasets

from datasets import load_dataset

ds_q = load_dataset("yashkumaratri/wikidata-label-maps-20250820", data_files="entity_map.parquet", split="train")
ds_p = load_dataset("yashkumaratri/wikidata-label-maps-20250820", data_files="prop_map.parquet", split="train")

print(ds_q.num_rows, ds_p.num_rows)
print(ds_p.filter(lambda x: x["id"] == "P31")[:1])

DuckDB SQL

-- in duckdb shell or via Python duckdb.execute
INSTALL httpfs; LOAD httpfs; -- if reading from remote
PRAGMA threads=16;

-- Point to local files if already downloaded
CREATE VIEW entity_map AS SELECT * FROM parquet_scan('entity_map.parquet');
CREATE VIEW prop_map   AS SELECT * FROM parquet_scan('prop_map.parquet');

-- Sample lookup
SELECT e.id AS qid, e.label AS q_label, e.description
FROM entity_map e
WHERE e.id IN ('Q155','Q42')
LIMIT 10;

-- Join against an events parquet
SELECT ev.*, p.label AS predicate_label, q.label AS subject_label
FROM parquet_scan('events_sample.parquet') ev
LEFT JOIN prop_map p ON ev.pred_id = p.id
LEFT JOIN entity_map q ON ev.subj_id = q.id
LIMIT 20;

PySpark

from pyspark.sql import SparkSession

spark = SparkSession.builder.getOrCreate()
pq = spark.read.parquet("entity_map.parquet").selectExpr("id as subj_id", "label as subject_label")
pp = spark.read.parquet("prop_map.parquet").selectExpr("id as pred_id", "label as predicate_label", "datatype as predicate_datatype")
ev = spark.read.parquet("events_sample.parquet")  # must have subj_id, pred_id

resolved = ev.join(pp, "pred_id", "left").join(pq, "subj_id", "left")
resolved.show(5, truncate=False)

Fast Lookup Helpers

Polars dictionary maps

For very fast lookups when you need to resolve many IDs:

import polars as pl

pq = pl.read_parquet("entity_map.parquet", columns=["id","label"])
pp = pl.read_parquet("prop_map.parquet", columns=["id","label","datatype"])

Q_LABEL = dict(zip(pq["id"].to_list(), pq["label"].to_list()))
P_LABEL = dict(zip(pp["id"].to_list(), pp["label"].to_list()))
P_TYPE  = dict(zip(pp["id"].to_list(), pp["datatype"].to_list()))

print(Q_LABEL.get("Q155","Q155"))
print(P_LABEL.get("P31","P31"), P_TYPE.get("P31"))

Minimal resolver class

import polars as pl

class WDResolver:
    def __init__(self, entity_parquet: str, prop_parquet: str):
        self.q = pl.read_parquet(entity_parquet).select(["id","label"]).rename({"id":"qid"})
        self.p = pl.read_parquet(prop_parquet).select(["id","label","datatype"]).rename({"id":"pid"})

    def resolve_subjects(self, df: pl.DataFrame, subj_col="subj_id") -> pl.DataFrame:
        return (
            df.lazy()
            .join(self.q.rename({"qid": subj_col, "label": "subject_label"}), on=subj_col, how="left")
            .collect(streaming=True)
        )

    def resolve_predicates(self, df: pl.DataFrame, pred_col="pred_id") -> pl.DataFrame:
        return (
            df.lazy()
            .join(self.p.rename({"pid": pred_col, "label": "predicate_label", "datatype": "predicate_datatype"}), on=pred_col, how="left")
            .collect(streaming=True)
        )

Utility Functions

Simple quantity unit display example

For displaying Wikidata quantity values with proper unit labels:

def display_quantity(text: str, qlabel_map: dict) -> str:
    # Examples: "+267106 1" or "+1234 Q11573" where second token may be a unit QID
    if not isinstance(text, str):
        return str(text)
    parts = text.strip().split()
    if not parts:
        return text
    amt = parts[0].lstrip("+")
    if len(parts) == 1:
        return amt
    unit = parts[1]
    if unit.startswith("Q"):
        return f"{amt} {qlabel_map.get(unit, unit)}"
    return f"{amt} {unit}"

Validator script

To validate the downloaded files:

# validate_maps.py
import polars as pl, os
root = os.path.dirname(__file__) or "."
q = pl.read_parquet(os.path.join(root, "entity_map.parquet"), columns=["id","label","description"])
p = pl.read_parquet(os.path.join(root, "prop_map.parquet"), columns=["id","label","description","datatype"])
print(f"[ok] entity_map rows={q.height:,} unique ids={q.select(pl.col('id').n_unique()).item():,}")
print(f"[ok] prop_map   rows={p.height:,} unique ids={p.select(pl.col('id').n_unique()).item():,}")
print("[sample] P31:", p.filter(pl.col("id")=="P31").to_dicts())
print(q.sample(3, seed=42).to_dicts())

Common Use Cases

• Knowledge Graph Processing: Join these maps with your Wikidata triples to get human-readable labels
• Data Analysis: Convert Q/P identifiers in your datasets to meaningful names
• Search & Discovery: Build search indices with proper entity and property names
• Data Validation: Check if your Q/P identifiers exist and get their descriptions

Performance Tips

• Use lazy evaluation with Polars .scan_parquet() for large datasets
• Create dictionary lookups for frequent ID resolution
• Use streaming collection for memory-efficient processing
• Consider loading only the columns you need with columns=["id","label"]