Upload TypePrediction dataset

.gitattributes

@@ -58,3 +58,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+type_predictor_data.jsonl filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,83 @@
+# TypePrediction
+
+Unified mention-level type prediction data built from all available local Wojood NER datasets except `WojoodRelations`.
+
+## Main file
+
+- `type_predictor_data.jsonl`
+
+Each row contains:
+
+```json
+{
+  "entity": "النص",
+  "type": "ORG",
+  "sentence": "الجملة الكاملة",
+  "start_token": 0,
+  "end_token": 1,
+  "start_char": 0,
+  "end_char": 10,
+  "raw_types": ["ORG", "NONGOV"],
+  "sources": [
+    {"dataset": "WojoodFine", "split": "train"},
+    {"dataset": "Wojood1_1_nested", "split": "train"}
+  ]
+}
+```
+
+## Construction
+
+1. Parse all sentence-separated CoNLL-style files from:
+   - `Wojood1_1_flat`
+   - `Wojood1_1_nested`
+   - `WojoodFine`
+   - `WojoodFine-Flat`
+2. Extract every entity span, including nested spans when multiple BIO tags are present on the same token sequence.
+3. Map fine labels to coarse labels using `wojood_ontology.json`.
+4. Reconstruct full sentence text and both token and character spans.
+5. Deduplicate by `(sentence, entity, type, start_token, end_token)` and merge provenance.
+
+## Summary
+
+- total rows: `132763`
+- unique sentences: `34187`
+- raw extracted mentions before dedupe: `408035`
+- rows merged by dedupe: `275272`
+
+## Source breakdown
+
+- `Wojood1_1_flat/test`: 14573 mentions from 6606 sentences
+- `Wojood1_1_flat/train`: 49959 mentions from 23125 sentences
+- `Wojood1_1_flat/val`: 7143 mentions from 3304 sentences
+- `Wojood1_1_nested/test`: 18045 mentions from 6606 sentences
+- `Wojood1_1_nested/train`: 62377 mentions from 23125 sentences
+- `Wojood1_1_nested/val`: 8944 mentions from 3304 sentences
+- `WojoodFine/test`: 27848 mentions from 5748 sentences
+- `WojoodFine/train`: 96188 mentions from 19484 sentences
+- `WojoodFine/val`: 13800 mentions from 2828 sentences
+- `WojoodFine-Flat/split10`: 10859 mentions from 3304 sentences
+- `WojoodFine-Flat/split20`: 22208 mentions from 6606 sentences
+- `WojoodFine-Flat/split70`: 76091 mentions from 23125 sentences
+
+## Top coarse types
+
+- `GPE`: 29992
+- `ORG`: 29864
+- `DATE`: 19765
+- `PERS`: 10726
+- `NORP`: 10220
+- `ORDINAL`: 7817
+- `OCC`: 7696
+- `EVENT`: 3785
+- `CARDINAL`: 3731
+- `LOC`: 2418
+- `FAC`: 1507
+- `WEBSITE`: 1481
+- `LAW`: 904
+- `TIME`: 871
+- `MONEY`: 465
+- `CURR`: 456
+- `LANGUAGE`: 332
+- `PERCENT`: 312
+- `PRODUCT`: 191
+- `QUANTITY`: 115

build_type_prediction_dataset.py

@@ -0,0 +1,372 @@
+import json
+from collections import Counter, defaultdict
+from dataclasses import dataclass
+from pathlib import Path
+
+
+ROOT = Path("/root/knowledgegrapheval")
+OUT_DIR = ROOT / "type_prediction_dataset"
+OUT_PATH = OUT_DIR / "type_predictor_data.jsonl"
+SUMMARY_PATH = OUT_DIR / "summary.json"
+README_PATH = OUT_DIR / "README.md"
+ONTOLOGY_PATH = ROOT / "data_preprocessed" / "wojood_ontology.json"
+
+
+@dataclass(frozen=True)
+class SourceSpec:
+    dataset: str
+    split: str
+    path: Path
+    mode: str
+
+
+SOURCES = [
+    SourceSpec("Wojood1_1_flat", "train", ROOT / "Wojood" / "Wojood1_1_flat" / "train.txt", "space"),
+    SourceSpec("Wojood1_1_flat", "val", ROOT / "Wojood" / "Wojood1_1_flat" / "val.txt", "space"),
+    SourceSpec("Wojood1_1_flat", "test", ROOT / "Wojood" / "Wojood1_1_flat" / "test.txt", "space"),
+    SourceSpec("Wojood1_1_nested", "train", ROOT / "Wojood" / "Wojood1_1_nested" / "train.txt", "space"),
+    SourceSpec("Wojood1_1_nested", "val", ROOT / "Wojood" / "Wojood1_1_nested" / "val.txt", "space"),
+    SourceSpec("Wojood1_1_nested", "test", ROOT / "Wojood" / "Wojood1_1_nested" / "test.txt", "space"),
+    SourceSpec("WojoodFine", "train", ROOT / "WojoodFine" / "train.txt", "tab"),
+    SourceSpec("WojoodFine", "val", ROOT / "WojoodFine" / "val.txt", "tab"),
+    SourceSpec("WojoodFine", "test", ROOT / "WojoodFine" / "test.txt", "tab"),
+    SourceSpec("WojoodFine-Flat", "split70", ROOT / "WojoodFine-Flat" / "split70.conll", "tab"),
+    SourceSpec("WojoodFine-Flat", "split20", ROOT / "WojoodFine-Flat" / "split20.conll", "tab"),
+    SourceSpec("WojoodFine-Flat", "split10", ROOT / "WojoodFine-Flat" / "split10.conll", "tab"),
+]
+
+
+def load_type_mapping() -> tuple[set[str], dict[str, str]]:
+    ontology = json.loads(ONTOLOGY_PATH.read_text(encoding="utf-8"))
+    coarse = {item["id"] for item in ontology["coarse_entity_types"]}
+    fine_to_coarse = {item["id"]: item["parent"] for item in ontology["fine_entity_types"]}
+    return coarse, fine_to_coarse
+
+
+def canonicalize_type_label(raw_type: str, coarse_types: set[str], fine_to_coarse: dict[str, str]) -> str:
+    candidates = [
+        raw_type,
+        raw_type.upper(),
+        raw_type.replace("-", "_"),
+        raw_type.upper().replace("-", "_"),
+        raw_type.replace("_", "-"),
+        raw_type.upper().replace("_", "-"),
+    ]
+    known = coarse_types | set(fine_to_coarse)
+    for candidate in candidates:
+        if candidate in known:
+            return candidate
+    raise KeyError(raw_type)
+
+
+def parse_line(line: str, mode: str) -> tuple[str, list[str]]:
+    if mode == "space":
+        parts = line.split()
+        token = parts[0]
+        tags = parts[1:]
+    elif mode == "tab":
+        parts = line.split("\t")
+        token = parts[0]
+        tags = []
+        for part in parts[1:]:
+            if not part:
+                continue
+            tags.extend(piece for piece in part.split() if piece)
+    else:
+        raise ValueError(f"Unknown parse mode: {mode}")
+    return token, tags
+
+
+def iter_sentences(spec: SourceSpec):
+    tokens: list[str] = []
+    tag_lists: list[list[str]] = []
+    with spec.path.open(encoding="utf-8") as handle:
+        for raw_line in handle:
+            line = raw_line.rstrip("\n\r")
+            if not line.strip():
+                if tokens:
+                    yield tokens, tag_lists
+                    tokens = []
+                    tag_lists = []
+                continue
+            token, tags = parse_line(line, spec.mode)
+            tokens.append(token)
+            tag_lists.append(tags)
+    if tokens:
+        yield tokens, tag_lists
+
+
+def sentence_and_offsets(tokens: list[str]) -> tuple[str, list[int], list[int]]:
+    chars = []
+    starts = []
+    ends = []
+    pos = 0
+    for idx, token in enumerate(tokens):
+        if idx > 0:
+            chars.append(" ")
+            pos += 1
+        starts.append(pos)
+        chars.append(token)
+        pos += len(token)
+        ends.append(pos)
+    return "".join(chars), starts, ends
+
+
+def close_span(active, spans, token_idx):
+    if active is None:
+        return None
+    active["end_token"] = token_idx - 1
+    spans.append(active)
+    return None
+
+
+def extract_raw_spans(tokens: list[str], tag_lists: list[list[str]]) -> list[dict]:
+    spans = []
+    active_by_raw_type: dict[str, dict] = {}
+
+    for idx, tags in enumerate(tag_lists):
+        parsed_tags = []
+        seen_raw = set()
+        for tag in tags:
+            if tag == "O":
+                continue
+            if "-" not in tag:
+                continue
+            prefix, raw_type = tag.split("-", 1)
+            if raw_type in seen_raw:
+                continue
+            seen_raw.add(raw_type)
+            parsed_tags.append((prefix, raw_type))
+
+        current_raw = {raw_type for _, raw_type in parsed_tags}
+        for raw_type in list(active_by_raw_type):
+            if raw_type not in current_raw:
+                active_by_raw_type[raw_type] = close_span(active_by_raw_type[raw_type], spans, idx)
+                if active_by_raw_type[raw_type] is None:
+                    del active_by_raw_type[raw_type]
+
+        for prefix, raw_type in parsed_tags:
+            active = active_by_raw_type.get(raw_type)
+            if prefix == "B":
+                if active is not None:
+                    active_by_raw_type[raw_type] = close_span(active, spans, idx)
+                active_by_raw_type[raw_type] = {
+                    "raw_type": raw_type,
+                    "start_token": idx,
+                    "end_token": idx,
+                }
+            elif prefix == "I":
+                if active is None:
+                    active_by_raw_type[raw_type] = {
+                        "raw_type": raw_type,
+                        "start_token": idx,
+                        "end_token": idx,
+                    }
+                else:
+                    active["end_token"] = idx
+            else:
+                raise ValueError(f"Unknown BIO prefix: {prefix}")
+
+    final_idx = len(tokens)
+    for raw_type in list(active_by_raw_type):
+        active_by_raw_type[raw_type] = close_span(active_by_raw_type[raw_type], spans, final_idx)
+        if active_by_raw_type[raw_type] is None:
+            del active_by_raw_type[raw_type]
+    return spans
+
+
+def build_record(
+    sentence: str,
+    char_starts: list[int],
+    char_ends: list[int],
+    tokens: list[str],
+    span: dict,
+    coarse_types: set[str],
+    fine_to_coarse: dict[str, str],
+    spec: SourceSpec,
+) -> dict:
+    raw_type = canonicalize_type_label(span["raw_type"], coarse_types, fine_to_coarse)
+    coarse_type = raw_type if raw_type in coarse_types else fine_to_coarse[raw_type]
+    start_token = span["start_token"]
+    end_token = span["end_token"]
+    start_char = char_starts[start_token]
+    end_char = char_ends[end_token]
+    entity = sentence[start_char:end_char]
+    if entity != " ".join(tokens[start_token : end_token + 1]):
+        raise ValueError("Entity surface mismatch during reconstruction.")
+    return {
+        "entity": entity,
+        "type": coarse_type,
+        "sentence": sentence,
+        "start_token": start_token,
+        "end_token": end_token,
+        "start_char": start_char,
+        "end_char": end_char,
+        "raw_type": raw_type,
+        "source_dataset": spec.dataset,
+        "source_split": spec.split,
+    }
+
+
+def make_readme(summary: dict) -> str:
+    sources = "\n".join(
+        f"- `{item['dataset']}/{item['split']}`: {item['mentions']} mentions from {item['sentences']} sentences"
+        for item in summary["source_breakdown"]
+    )
+    top_types = "\n".join(
+        f"- `{item['type']}`: {item['count']}"
+        for item in summary["type_breakdown"][:20]
+    )
+    return f"""# TypePrediction
+
+Unified mention-level type prediction data built from all available local Wojood NER datasets except `WojoodRelations`.
+
+## Main file
+
+- `type_predictor_data.jsonl`
+
+Each row contains:
+
+```json
+{{
+  "entity": "النص",
+  "type": "ORG",
+  "sentence": "الجملة الكاملة",
+  "start_token": 0,
+  "end_token": 1,
+  "start_char": 0,
+  "end_char": 10,
+  "raw_types": ["ORG", "NONGOV"],
+  "sources": [
+    {{"dataset": "WojoodFine", "split": "train"}},
+    {{"dataset": "Wojood1_1_nested", "split": "train"}}
+  ]
+}}
+```
+
+## Construction
+
+1. Parse all sentence-separated CoNLL-style files from:
+   - `Wojood1_1_flat`
+   - `Wojood1_1_nested`
+   - `WojoodFine`
+   - `WojoodFine-Flat`
+2. Extract every entity span, including nested spans when multiple BIO tags are present on the same token sequence.
+3. Map fine labels to coarse labels using `wojood_ontology.json`.
+4. Reconstruct full sentence text and both token and character spans.
+5. Deduplicate by `(sentence, entity, type, start_token, end_token)` and merge provenance.
+
+## Summary
+
+- total rows: `{summary['total_rows']}`
+- unique sentences: `{summary['unique_sentences']}`
+- raw extracted mentions before dedupe: `{summary['raw_mentions_before_dedupe']}`
+- rows merged by dedupe: `{summary['duplicates_merged']}`
+
+## Source breakdown
+
+{sources}
+
+## Top coarse types
+
+{top_types}
+"""
+
+
+def main():
+    OUT_DIR.mkdir(parents=True, exist_ok=True)
+    coarse_types, fine_to_coarse = load_type_mapping()
+
+    grouped = {}
+    raw_mentions_before_dedupe = 0
+    source_sentence_counts = defaultdict(int)
+    source_mention_counts = defaultdict(int)
+
+    for spec in SOURCES:
+        for tokens, tag_lists in iter_sentences(spec):
+            source_sentence_counts[(spec.dataset, spec.split)] += 1
+            sentence, char_starts, char_ends = sentence_and_offsets(tokens)
+            spans = extract_raw_spans(tokens, tag_lists)
+            for span in spans:
+                raw_mentions_before_dedupe += 1
+                record = build_record(
+                    sentence=sentence,
+                    char_starts=char_starts,
+                    char_ends=char_ends,
+                    tokens=tokens,
+                    span=span,
+                    coarse_types=coarse_types,
+                    fine_to_coarse=fine_to_coarse,
+                    spec=spec,
+                )
+                source_mention_counts[(spec.dataset, spec.split)] += 1
+                key = (
+                    record["sentence"],
+                    record["entity"],
+                    record["type"],
+                    record["start_token"],
+                    record["end_token"],
+                )
+                existing = grouped.get(key)
+                if existing is None:
+                    grouped[key] = {
+                        "entity": record["entity"],
+                        "type": record["type"],
+                        "sentence": record["sentence"],
+                        "start_token": record["start_token"],
+                        "end_token": record["end_token"],
+                        "start_char": record["start_char"],
+                        "end_char": record["end_char"],
+                        "raw_types": [record["raw_type"]],
+                        "sources": [
+                            {
+                                "dataset": record["source_dataset"],
+                                "split": record["source_split"],
+                            }
+                        ],
+                    }
+                else:
+                    if record["raw_type"] not in existing["raw_types"]:
+                        existing["raw_types"].append(record["raw_type"])
+                    source_entry = {
+                        "dataset": record["source_dataset"],
+                        "split": record["source_split"],
+                    }
+                    if source_entry not in existing["sources"]:
+                        existing["sources"].append(source_entry)
+
+    rows = sorted(
+        grouped.values(),
+        key=lambda row: (row["sentence"], row["start_token"], row["end_token"], row["type"], row["entity"]),
+    )
+    with OUT_PATH.open("w", encoding="utf-8") as handle:
+        for row in rows:
+            handle.write(json.dumps(row, ensure_ascii=False) + "\n")
+
+    type_counts = Counter(row["type"] for row in rows)
+    summary = {
+        "total_rows": len(rows),
+        "unique_sentences": len({row["sentence"] for row in rows}),
+        "raw_mentions_before_dedupe": raw_mentions_before_dedupe,
+        "duplicates_merged": raw_mentions_before_dedupe - len(rows),
+        "source_breakdown": [
+            {
+                "dataset": dataset,
+                "split": split,
+                "sentences": source_sentence_counts[(dataset, split)],
+                "mentions": source_mention_counts[(dataset, split)],
+            }
+            for dataset, split in sorted(source_sentence_counts)
+        ],
+        "type_breakdown": [
+            {"type": entity_type, "count": count}
+            for entity_type, count in type_counts.most_common()
+        ],
+    }
+    SUMMARY_PATH.write_text(json.dumps(summary, ensure_ascii=False, indent=2), encoding="utf-8")
+    README_PATH.write_text(make_readme(summary), encoding="utf-8")
+    print(json.dumps(summary, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()

push_to_hf.py

@@ -0,0 +1,52 @@
+import os
+from pathlib import Path
+
+from huggingface_hub import HfApi, create_repo
+
+
+ROOT = Path("/root/knowledgegrapheval/type_prediction_dataset")
+ENV_PATHS = [
+    Path("/root/knowledgegrapheval/.env"),
+    Path("/root/knowledge-graph-rag/.env"),
+]
+REPO_ID = "U4RASD/TypePrediction"
+
+
+def load_env():
+    for env_path in ENV_PATHS:
+        if not env_path.exists():
+            continue
+        for line in env_path.read_text(encoding="utf-8").splitlines():
+            line = line.strip()
+            if not line or line.startswith("#") or "=" not in line:
+                continue
+            key, value = line.split("=", 1)
+            os.environ.setdefault(key.strip(), value.strip().strip('"').strip("'"))
+
+
+def main():
+    load_env()
+    token = os.environ.get("HF_TOKEN_UNIT") or os.environ.get("HF_TOKEN")
+    if not token:
+        raise RuntimeError("Missing HF token.")
+
+    create_repo(
+        repo_id=REPO_ID,
+        repo_type="dataset",
+        token=token,
+        exist_ok=True,
+        private=True,
+    )
+    api = HfApi(token=token)
+    api.upload_folder(
+        repo_id=REPO_ID,
+        repo_type="dataset",
+        folder_path=str(ROOT),
+        path_in_repo=".",
+        commit_message="Upload TypePrediction dataset",
+    )
+    print(REPO_ID)
+
+
+if __name__ == "__main__":
+    main()

summary.json

@@ -0,0 +1,166 @@
+{
+  "total_rows": 132763,
+  "unique_sentences": 34187,
+  "raw_mentions_before_dedupe": 408035,
+  "duplicates_merged": 275272,
+  "source_breakdown": [
+    {
+      "dataset": "Wojood1_1_flat",
+      "split": "test",
+      "sentences": 6606,
+      "mentions": 14573
+    },
+    {
+      "dataset": "Wojood1_1_flat",
+      "split": "train",
+      "sentences": 23125,
+      "mentions": 49959
+    },
+    {
+      "dataset": "Wojood1_1_flat",
+      "split": "val",
+      "sentences": 3304,
+      "mentions": 7143
+    },
+    {
+      "dataset": "Wojood1_1_nested",
+      "split": "test",
+      "sentences": 6606,
+      "mentions": 18045
+    },
+    {
+      "dataset": "Wojood1_1_nested",
+      "split": "train",
+      "sentences": 23125,
+      "mentions": 62377
+    },
+    {
+      "dataset": "Wojood1_1_nested",
+      "split": "val",
+      "sentences": 3304,
+      "mentions": 8944
+    },
+    {
+      "dataset": "WojoodFine",
+      "split": "test",
+      "sentences": 5748,
+      "mentions": 27848
+    },
+    {
+      "dataset": "WojoodFine",
+      "split": "train",
+      "sentences": 19484,
+      "mentions": 96188
+    },
+    {
+      "dataset": "WojoodFine",
+      "split": "val",
+      "sentences": 2828,
+      "mentions": 13800
+    },
+    {
+      "dataset": "WojoodFine-Flat",
+      "split": "split10",
+      "sentences": 3304,
+      "mentions": 10859
+    },
+    {
+      "dataset": "WojoodFine-Flat",
+      "split": "split20",
+      "sentences": 6606,
+      "mentions": 22208
+    },
+    {
+      "dataset": "WojoodFine-Flat",
+      "split": "split70",
+      "sentences": 23125,
+      "mentions": 76091
+    }
+  ],
+  "type_breakdown": [
+    {
+      "type": "GPE",
+      "count": 29992
+    },
+    {
+      "type": "ORG",
+      "count": 29864
+    },
+    {
+      "type": "DATE",
+      "count": 19765
+    },
+    {
+      "type": "PERS",
+      "count": 10726
+    },
+    {
+      "type": "NORP",
+      "count": 10220
+    },
+    {
+      "type": "ORDINAL",
+      "count": 7817
+    },
+    {
+      "type": "OCC",
+      "count": 7696
+    },
+    {
+      "type": "EVENT",
+      "count": 3785
+    },
+    {
+      "type": "CARDINAL",
+      "count": 3731
+    },
+    {
+      "type": "LOC",
+      "count": 2418
+    },
+    {
+      "type": "FAC",
+      "count": 1507
+    },
+    {
+      "type": "WEBSITE",
+      "count": 1481
+    },
+    {
+      "type": "LAW",
+      "count": 904
+    },
+    {
+      "type": "TIME",
+      "count": 871
+    },
+    {
+      "type": "MONEY",
+      "count": 465
+    },
+    {
+      "type": "CURR",
+      "count": 456
+    },
+    {
+      "type": "LANGUAGE",
+      "count": 332
+    },
+    {
+      "type": "PERCENT",
+      "count": 312
+    },
+    {
+      "type": "PRODUCT",
+      "count": 191
+    },
+    {
+      "type": "QUANTITY",
+      "count": 115
+    },
+    {
+      "type": "UNIT",
+      "count": 115
+    }
+  ]
+}

type_predictor_data.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c86d6152e1d2ca5ff2b96e92ff576ac35fe1effb6943453dc81d7a19e4f07d81
+size 92382233