Upload TypePrediction dataset

.gitattributes

@@ -59,3 +59,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.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
+artifacts/split_assignments.jsonl filter=lfs diff=lfs merge=lfs -text
+type_predictor_train.jsonl filter=lfs diff=lfs merge=lfs -text

README.md

@@ -20,10 +20,16 @@ Unified mention-level type prediction data built from all available local Wojood
 ## Main file
 
 - `type_predictor_data.jsonl`
+- `type_predictor_train.jsonl`
+- `type_predictor_val.jsonl`
+- `type_predictor_test.jsonl`
 - `summary.json`
+- `split_summary.json`
 - `build_type_prediction_dataset.py`
 - `push_to_hf.py`
+- `split_data.py`
 - `artifacts/ambiguous_span_type_conflicts.jsonl`
+- `artifacts/split_assignments.jsonl`
 
 Each row contains:
 
@@ -192,3 +198,38 @@ Example merged across multiple source datasets:
 - verified deduped rows merge provenance rather than silently dropping it
 - verified no exact span in the main file has more than one coarse type
 - verified ids are unique and deterministic
+
+## Split files
+
+The repo also includes a mention-level stratified split built from `type_predictor_data.jsonl`:
+
+- `type_predictor_train.jsonl`
+- `type_predictor_val.jsonl`
+- `type_predictor_test.jsonl`
+- `split_summary.json`
+- `artifacts/split_assignments.jsonl`
+- `split_data.py`
+
+Split policy:
+
+1. Start from the clean `type_predictor_data.jsonl`.
+2. Perform a stratified `80/20` split by the `type` column with `random_state = 42`.
+3. Split the holdout pool again, stratified by `type`, into equal halves.
+4. Keep sentence overlap allowed across splits.
+5. Preserve all original fields.
+6. Add `evaluation_category` only to validation and test rows:
+   - `unseen_sentence`
+   - `seen_sentence_new_entity`
+
+Current split sizes:
+
+- train: `100,796`
+- validation: `12,600`
+- test: `12,600`
+
+Current evaluation-category counts:
+
+- validation `seen_sentence_new_entity`: `11,661`
+- validation `unseen_sentence`: `939`
+- test `seen_sentence_new_entity`: `11,606`
+- test `unseen_sentence`: `994`

artifacts/split_assignments.jsonl

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

split_data.py

@@ -0,0 +1,280 @@
+import copy
+import json
+from collections import Counter, defaultdict
+from pathlib import Path
+
+from sklearn.model_selection import train_test_split
+
+
+ROOT = Path("/root/knowledgegrapheval/type_prediction_dataset")
+ARTIFACTS_DIR = ROOT / "artifacts"
+INPUT_PATH = ROOT / "type_predictor_data.jsonl"
+TRAIN_PATH = ROOT / "type_predictor_train.jsonl"
+VAL_PATH = ROOT / "type_predictor_val.jsonl"
+TEST_PATH = ROOT / "type_predictor_test.jsonl"
+SUMMARY_PATH = ROOT / "split_summary.json"
+ASSIGNMENTS_PATH = ARTIFACTS_DIR / "split_assignments.jsonl"
+
+RANDOM_STATE = 42
+TRAIN_RATIO = 0.8
+VAL_RATIO = 0.1
+TEST_RATIO = 0.1
+
+
+def load_rows() -> list[dict]:
+    with INPUT_PATH.open(encoding="utf-8") as handle:
+        return [json.loads(line) for line in handle if line.strip()]
+
+
+def dump_jsonl(path: Path, rows: list[dict]) -> None:
+    with path.open("w", encoding="utf-8") as handle:
+        for row in rows:
+            handle.write(json.dumps(row, ensure_ascii=False) + "\n")
+
+
+def extract_entity_from_spans(row: dict) -> tuple[str, str]:
+    sentence = row["sentence"]
+    entity_from_chars = sentence[row["start_char"] : row["end_char"]]
+    entity_from_tokens = " ".join(sentence.split(" ")[row["start_token"] : row["end_token"] + 1])
+    return entity_from_chars, entity_from_tokens
+
+
+def stratified_split(rows: list[dict]) -> tuple[list[dict], list[dict], list[dict]]:
+    labels = [row["type"] for row in rows]
+    indices = list(range(len(rows)))
+
+    train_idx, holdout_idx = train_test_split(
+        indices,
+        test_size=(1.0 - TRAIN_RATIO),
+        stratify=labels,
+        random_state=RANDOM_STATE,
+        shuffle=True,
+    )
+
+    holdout_labels = [labels[idx] for idx in holdout_idx]
+    val_idx, test_idx = train_test_split(
+        holdout_idx,
+        test_size=0.5,
+        stratify=holdout_labels,
+        random_state=RANDOM_STATE,
+        shuffle=True,
+    )
+
+    train_rows = [copy.deepcopy(rows[idx]) for idx in train_idx]
+    val_rows = [copy.deepcopy(rows[idx]) for idx in val_idx]
+    test_rows = [copy.deepcopy(rows[idx]) for idx in test_idx]
+    return train_rows, val_rows, test_rows
+
+
+def add_eval_categories(train_rows: list[dict], eval_rows: list[dict]) -> list[dict]:
+    train_sentences = {row["sentence"] for row in train_rows}
+    output = []
+    for row in eval_rows:
+        new_row = copy.deepcopy(row)
+        if new_row["sentence"] in train_sentences:
+            new_row["evaluation_category"] = "seen_sentence_new_entity"
+        else:
+            new_row["evaluation_category"] = "unseen_sentence"
+        output.append(new_row)
+    return output
+
+
+def count_types(rows: list[dict]) -> Counter:
+    return Counter(row["type"] for row in rows)
+
+
+def count_type_and_category(rows: list[dict]) -> dict[str, dict[str, int]]:
+    counts = defaultdict(lambda: {"unseen_sentence": 0, "seen_sentence_new_entity": 0})
+    for row in rows:
+        counts[row["type"]][row["evaluation_category"]] += 1
+    return dict(sorted(counts.items()))
+
+
+def write_split_assignments(
+    train_rows: list[dict],
+    val_rows: list[dict],
+    test_rows: list[dict],
+) -> None:
+    ARTIFACTS_DIR.mkdir(parents=True, exist_ok=True)
+    sentence_groups = []
+    for split_name, rows in [("train", train_rows), ("validation", val_rows), ("test", test_rows)]:
+        by_sentence = defaultdict(list)
+        for row in rows:
+            by_sentence[row["sentence"]].append(row)
+        for sentence, sentence_rows in by_sentence.items():
+            type_counts = Counter(row["type"] for row in sentence_rows)
+            sentence_groups.append(
+                {
+                    "sentence": sentence,
+                    "assigned_split": split_name,
+                    "row_count": len(sentence_rows),
+                    "type_counts": dict(sorted(type_counts.items())),
+                    "row_ids": [row["id"] for row in sentence_rows],
+                }
+            )
+
+    sentence_groups.sort(key=lambda item: (item["assigned_split"], item["sentence"]))
+    dump_jsonl(ASSIGNMENTS_PATH, sentence_groups)
+
+
+def validate(
+    original_rows: list[dict],
+    train_rows: list[dict],
+    val_rows: list[dict],
+    test_rows: list[dict],
+) -> dict:
+    errors = []
+    all_rows = train_rows + val_rows + test_rows
+    original_by_id = {row["id"]: row for row in original_rows}
+    seen_ids = set()
+
+    for split_name, rows in [("train", train_rows), ("validation", val_rows), ("test", test_rows)]:
+        for row in rows:
+            row_id = row["id"]
+            if row_id in seen_ids:
+                errors.append(f"duplicate row id across splits: {row_id}")
+            seen_ids.add(row_id)
+
+            if row_id not in original_by_id:
+                errors.append(f"row id missing from original dataset: {row_id}")
+                continue
+
+            baseline = original_by_id[row_id]
+            compare_keys = sorted(set(row.keys()) | set(baseline.keys()) - {"evaluation_category"})
+            for key in compare_keys:
+                if key == "evaluation_category":
+                    continue
+                if row.get(key) != baseline.get(key):
+                    errors.append(f"{split_name} row {row_id} changed original field {key}")
+                    break
+
+            chars_entity, tokens_entity = extract_entity_from_spans(row)
+            if chars_entity != row["entity"]:
+                errors.append(f"{split_name} row {row_id} char span mismatch")
+            if tokens_entity != row["entity"]:
+                errors.append(f"{split_name} row {row_id} token span mismatch")
+
+            if split_name == "train":
+                if "evaluation_category" in row:
+                    errors.append(f"train row {row_id} should not have evaluation_category")
+            else:
+                if row.get("evaluation_category") not in {"unseen_sentence", "seen_sentence_new_entity"}:
+                    errors.append(f"{split_name} row {row_id} missing valid evaluation_category")
+
+    if len(original_rows) != len(all_rows):
+        errors.append("row count mismatch after splitting")
+    if len(original_by_id) != len(seen_ids):
+        errors.append("not all row ids are present exactly once")
+
+    all_types = sorted({row["type"] for row in original_rows})
+    for split_name, rows in [("train", train_rows), ("validation", val_rows), ("test", test_rows)]:
+        split_types = {row["type"] for row in rows}
+        missing_types = sorted(set(all_types) - split_types)
+        if missing_types:
+            errors.append(f"{split_name} missing types: {missing_types}")
+
+    repeat_train, repeat_val, repeat_test = stratified_split(original_rows)
+    repeat_val = add_eval_categories(repeat_train, repeat_val)
+    repeat_test = add_eval_categories(repeat_train, repeat_test)
+    if [row["id"] for row in repeat_train] != [row["id"] for row in train_rows]:
+        errors.append("train split is not deterministic for the fixed seed")
+    if [row["id"] for row in repeat_val] != [row["id"] for row in val_rows]:
+        errors.append("validation split is not deterministic for the fixed seed")
+    if [row["id"] for row in repeat_test] != [row["id"] for row in test_rows]:
+        errors.append("test split is not deterministic for the fixed seed")
+
+    return {
+        "ok": not errors,
+        "errors": errors,
+    }
+
+
+def make_summary(
+    original_rows: list[dict],
+    train_rows: list[dict],
+    val_rows: list[dict],
+    test_rows: list[dict],
+    validation_result: dict,
+) -> dict:
+    original_type_counts = count_types(original_rows)
+    train_type_counts = count_types(train_rows)
+    val_type_counts = count_types(val_rows)
+    test_type_counts = count_types(test_rows)
+
+    def split_block(name: str, rows: list[dict]) -> dict:
+        return {
+            "name": name,
+            "rows": len(rows),
+            "percentage": len(rows) / len(original_rows),
+            "unique_sentences": len({row["sentence"] for row in rows}),
+            "type_counts": dict(sorted(count_types(rows).items())),
+        }
+
+    summary = {
+        "random_seed": RANDOM_STATE,
+        "requested_split_ratios": {
+            "train": TRAIN_RATIO,
+            "validation": VAL_RATIO,
+            "test": TEST_RATIO,
+        },
+        "totals": {
+            "original_rows": len(original_rows),
+            "train_rows": len(train_rows),
+            "validation_rows": len(val_rows),
+            "test_rows": len(test_rows),
+        },
+        "splits": {
+            "train": split_block("train", train_rows),
+            "validation": split_block("validation", val_rows),
+            "test": split_block("test", test_rows),
+        },
+        "per_type_counts": {},
+        "evaluation_category_counts": {
+            "validation": dict(sorted(Counter(row["evaluation_category"] for row in val_rows).items())),
+            "test": dict(sorted(Counter(row["evaluation_category"] for row in test_rows).items())),
+        },
+        "evaluation_category_counts_by_type": {
+            "validation": count_type_and_category(val_rows),
+            "test": count_type_and_category(test_rows),
+        },
+        "validation": validation_result,
+    }
+
+    for entity_type in sorted(original_type_counts):
+        summary["per_type_counts"][entity_type] = {
+            "original": original_type_counts[entity_type],
+            "train": train_type_counts[entity_type],
+            "validation": val_type_counts[entity_type],
+            "test": test_type_counts[entity_type],
+            "train_ratio": train_type_counts[entity_type] / original_type_counts[entity_type],
+            "validation_ratio": val_type_counts[entity_type] / original_type_counts[entity_type],
+            "test_ratio": test_type_counts[entity_type] / original_type_counts[entity_type],
+        }
+
+    return summary
+
+
+def main() -> None:
+    original_rows = load_rows()
+    ARTIFACTS_DIR.mkdir(parents=True, exist_ok=True)
+    train_rows, val_rows, test_rows = stratified_split(original_rows)
+    val_rows = add_eval_categories(train_rows, val_rows)
+    test_rows = add_eval_categories(train_rows, test_rows)
+
+    dump_jsonl(TRAIN_PATH, train_rows)
+    dump_jsonl(VAL_PATH, val_rows)
+    dump_jsonl(TEST_PATH, test_rows)
+    write_split_assignments(train_rows, val_rows, test_rows)
+
+    validation_result = validate(original_rows, train_rows, val_rows, test_rows)
+    summary = make_summary(original_rows, train_rows, val_rows, test_rows, validation_result)
+    SUMMARY_PATH.write_text(json.dumps(summary, ensure_ascii=False, indent=2), encoding="utf-8")
+
+    print(json.dumps(summary["totals"], ensure_ascii=False, indent=2))
+    print(json.dumps(summary["evaluation_category_counts"], ensure_ascii=False, indent=2))
+    if not validation_result["ok"]:
+        raise SystemExit("split validation failed")
+
+
+if __name__ == "__main__":
+    main()

split_summary.json

@@ -0,0 +1,482 @@
+{
+  "random_seed": 42,
+  "requested_split_ratios": {
+    "train": 0.8,
+    "validation": 0.1,
+    "test": 0.1
+  },
+  "totals": {
+    "original_rows": 125996,
+    "train_rows": 100796,
+    "validation_rows": 12600,
+    "test_rows": 12600
+  },
+  "splits": {
+    "train": {
+      "name": "train",
+      "rows": 100796,
+      "percentage": 0.7999936505920823,
+      "unique_sentences": 32409,
+      "type_counts": {
+        "CARDINAL": 2979,
+        "CURR": 329,
+        "DATE": 15809,
+        "EVENT": 3015,
+        "FAC": 1037,
+        "GPE": 21521,
+        "LANGUAGE": 266,
+        "LAW": 723,
+        "LOC": 1910,
+        "MONEY": 336,
+        "NORP": 8174,
+        "OCC": 6157,
+        "ORDINAL": 6246,
+        "ORG": 21274,
+        "PERCENT": 250,
+        "PERS": 8569,
+        "PRODUCT": 152,
+        "QUANTITY": 85,
+        "TIME": 697,
+        "UNIT": 85,
+        "WEBSITE": 1182
+      }
+    },
+    "validation": {
+      "name": "validation",
+      "rows": 12600,
+      "percentage": 0.10000317470395885,
+      "unique_sentences": 10139,
+      "type_counts": {
+        "CARDINAL": 373,
+        "CURR": 41,
+        "DATE": 1976,
+        "EVENT": 377,
+        "FAC": 130,
+        "GPE": 2690,
+        "LANGUAGE": 33,
+        "LAW": 90,
+        "LOC": 239,
+        "MONEY": 42,
+        "NORP": 1022,
+        "OCC": 769,
+        "ORDINAL": 780,
+        "ORG": 2660,
+        "PERCENT": 31,
+        "PERS": 1072,
+        "PRODUCT": 19,
+        "QUANTITY": 11,
+        "TIME": 87,
+        "UNIT": 10,
+        "WEBSITE": 148
+      }
+    },
+    "test": {
+      "name": "test",
+      "rows": 12600,
+      "percentage": 0.10000317470395885,
+      "unique_sentences": 10161,
+      "type_counts": {
+        "CARDINAL": 372,
+        "CURR": 41,
+        "DATE": 1977,
+        "EVENT": 377,
+        "FAC": 129,
+        "GPE": 2691,
+        "LANGUAGE": 33,
+        "LAW": 91,
+        "LOC": 239,
+        "MONEY": 42,
+        "NORP": 1021,
+        "OCC": 770,
+        "ORDINAL": 781,
+        "ORG": 2659,
+        "PERCENT": 31,
+        "PERS": 1071,
+        "PRODUCT": 19,
+        "QUANTITY": 10,
+        "TIME": 87,
+        "UNIT": 11,
+        "WEBSITE": 148
+      }
+    }
+  },
+  "per_type_counts": {
+    "CARDINAL": {
+      "original": 3724,
+      "train": 2979,
+      "validation": 373,
+      "test": 372,
+      "train_ratio": 0.7999462943071965,
+      "validation_ratio": 0.10016111707841031,
+      "test_ratio": 0.09989258861439312
+    },
+    "CURR": {
+      "original": 411,
+      "train": 329,
+      "validation": 41,
+      "test": 41,
+      "train_ratio": 0.8004866180048662,
+      "validation_ratio": 0.09975669099756691,
+      "test_ratio": 0.09975669099756691
+    },
+    "DATE": {
+      "original": 19762,
+      "train": 15809,
+      "validation": 1976,
+      "test": 1977,
+      "train_ratio": 0.7999696387005364,
+      "validation_ratio": 0.09998987956684546,
+      "test_ratio": 0.10004048173261816
+    },
+    "EVENT": {
+      "original": 3769,
+      "train": 3015,
+      "validation": 377,
+      "test": 377,
+      "train_ratio": 0.7999469355266648,
+      "validation_ratio": 0.10002653223666755,
+      "test_ratio": 0.10002653223666755
+    },
+    "FAC": {
+      "original": 1296,
+      "train": 1037,
+      "validation": 130,
+      "test": 129,
+      "train_ratio": 0.8001543209876543,
+      "validation_ratio": 0.10030864197530864,
+      "test_ratio": 0.09953703703703703
+    },
+    "GPE": {
+      "original": 26902,
+      "train": 21521,
+      "validation": 2690,
+      "test": 2691,
+      "train_ratio": 0.7999776968255148,
+      "validation_ratio": 0.09999256560850495,
+      "test_ratio": 0.10002973756598023
+    },
+    "LANGUAGE": {
+      "original": 332,
+      "train": 266,
+      "validation": 33,
+      "test": 33,
+      "train_ratio": 0.8012048192771084,
+      "validation_ratio": 0.09939759036144578,
+      "test_ratio": 0.09939759036144578
+    },
+    "LAW": {
+      "original": 904,
+      "train": 723,
+      "validation": 90,
+      "test": 91,
+      "train_ratio": 0.7997787610619469,
+      "validation_ratio": 0.09955752212389381,
+      "test_ratio": 0.1006637168141593
+    },
+    "LOC": {
+      "original": 2388,
+      "train": 1910,
+      "validation": 239,
+      "test": 239,
+      "train_ratio": 0.7998324958123953,
+      "validation_ratio": 0.10008375209380234,
+      "test_ratio": 0.10008375209380234
+    },
+    "MONEY": {
+      "original": 420,
+      "train": 336,
+      "validation": 42,
+      "test": 42,
+      "train_ratio": 0.8,
+      "validation_ratio": 0.1,
+      "test_ratio": 0.1
+    },
+    "NORP": {
+      "original": 10217,
+      "train": 8174,
+      "validation": 1022,
+      "test": 1021,
+      "train_ratio": 0.8000391504355486,
+      "validation_ratio": 0.10002936282666144,
+      "test_ratio": 0.09993148673778995
+    },
+    "OCC": {
+      "original": 7696,
+      "train": 6157,
+      "validation": 769,
+      "test": 770,
+      "train_ratio": 0.8000259875259875,
+      "validation_ratio": 0.09992203742203742,
+      "test_ratio": 0.10005197505197505
+    },
+    "ORDINAL": {
+      "original": 7807,
+      "train": 6246,
+      "validation": 780,
+      "test": 781,
+      "train_ratio": 0.8000512360701935,
+      "validation_ratio": 0.09991033687716153,
+      "test_ratio": 0.10003842705264507
+    },
+    "ORG": {
+      "original": 26593,
+      "train": 21274,
+      "validation": 2660,
+      "test": 2659,
+      "train_ratio": 0.7999849584477118,
+      "validation_ratio": 0.10002632271650434,
+      "test_ratio": 0.09998871883578385
+    },
+    "PERCENT": {
+      "original": 312,
+      "train": 250,
+      "validation": 31,
+      "test": 31,
+      "train_ratio": 0.8012820512820513,
+      "validation_ratio": 0.09935897435897435,
+      "test_ratio": 0.09935897435897435
+    },
+    "PERS": {
+      "original": 10712,
+      "train": 8569,
+      "validation": 1072,
+      "test": 1071,
+      "train_ratio": 0.7999439880507841,
+      "validation_ratio": 0.10007468259895444,
+      "test_ratio": 0.09998132935026138
+    },
+    "PRODUCT": {
+      "original": 190,
+      "train": 152,
+      "validation": 19,
+      "test": 19,
+      "train_ratio": 0.8,
+      "validation_ratio": 0.1,
+      "test_ratio": 0.1
+    },
+    "QUANTITY": {
+      "original": 106,
+      "train": 85,
+      "validation": 11,
+      "test": 10,
+      "train_ratio": 0.8018867924528302,
+      "validation_ratio": 0.10377358490566038,
+      "test_ratio": 0.09433962264150944
+    },
+    "TIME": {
+      "original": 871,
+      "train": 697,
+      "validation": 87,
+      "test": 87,
+      "train_ratio": 0.8002296211251435,
+      "validation_ratio": 0.09988518943742825,
+      "test_ratio": 0.09988518943742825
+    },
+    "UNIT": {
+      "original": 106,
+      "train": 85,
+      "validation": 10,
+      "test": 11,
+      "train_ratio": 0.8018867924528302,
+      "validation_ratio": 0.09433962264150944,
+      "test_ratio": 0.10377358490566038
+    },
+    "WEBSITE": {
+      "original": 1478,
+      "train": 1182,
+      "validation": 148,
+      "test": 148,
+      "train_ratio": 0.7997293640054127,
+      "validation_ratio": 0.10013531799729364,
+      "test_ratio": 0.10013531799729364
+    }
+  },
+  "evaluation_category_counts": {
+    "validation": {
+      "seen_sentence_new_entity": 11661,
+      "unseen_sentence": 939
+    },
+    "test": {
+      "seen_sentence_new_entity": 11606,
+      "unseen_sentence": 994
+    }
+  },
+  "evaluation_category_counts_by_type": {
+    "validation": {
+      "CARDINAL": {
+        "unseen_sentence": 49,
+        "seen_sentence_new_entity": 324
+      },
+      "CURR": {
+        "unseen_sentence": 2,
+        "seen_sentence_new_entity": 39
+      },
+      "DATE": {
+        "unseen_sentence": 124,
+        "seen_sentence_new_entity": 1852
+      },
+      "EVENT": {
+        "unseen_sentence": 15,
+        "seen_sentence_new_entity": 362
+      },
+      "FAC": {
+        "unseen_sentence": 13,
+        "seen_sentence_new_entity": 117
+      },
+      "GPE": {
+        "unseen_sentence": 159,
+        "seen_sentence_new_entity": 2531
+      },
+      "LANGUAGE": {
+        "unseen_sentence": 3,
+        "seen_sentence_new_entity": 30
+      },
+      "LAW": {
+        "unseen_sentence": 7,
+        "seen_sentence_new_entity": 83
+      },
+      "LOC": {
+        "unseen_sentence": 17,
+        "seen_sentence_new_entity": 222
+      },
+      "MONEY": {
+        "unseen_sentence": 1,
+        "seen_sentence_new_entity": 41
+      },
+      "NORP": {
+        "unseen_sentence": 101,
+        "seen_sentence_new_entity": 921
+      },
+      "OCC": {
+        "unseen_sentence": 45,
+        "seen_sentence_new_entity": 724
+      },
+      "ORDINAL": {
+        "unseen_sentence": 89,
+        "seen_sentence_new_entity": 691
+      },
+      "ORG": {
+        "unseen_sentence": 114,
+        "seen_sentence_new_entity": 2546
+      },
+      "PERCENT": {
+        "unseen_sentence": 2,
+        "seen_sentence_new_entity": 29
+      },
+      "PERS": {
+        "unseen_sentence": 145,
+        "seen_sentence_new_entity": 927
+      },
+      "PRODUCT": {
+        "unseen_sentence": 3,
+        "seen_sentence_new_entity": 16
+      },
+      "QUANTITY": {
+        "unseen_sentence": 0,
+        "seen_sentence_new_entity": 11
+      },
+      "TIME": {
+        "unseen_sentence": 12,
+        "seen_sentence_new_entity": 75
+      },
+      "UNIT": {
+        "unseen_sentence": 1,
+        "seen_sentence_new_entity": 9
+      },
+      "WEBSITE": {
+        "unseen_sentence": 37,
+        "seen_sentence_new_entity": 111
+      }
+    },
+    "test": {
+      "CARDINAL": {
+        "unseen_sentence": 49,
+        "seen_sentence_new_entity": 323
+      },
+      "CURR": {
+        "unseen_sentence": 3,
+        "seen_sentence_new_entity": 38
+      },
+      "DATE": {
+        "unseen_sentence": 120,
+        "seen_sentence_new_entity": 1857
+      },
+      "EVENT": {
+        "unseen_sentence": 14,
+        "seen_sentence_new_entity": 363
+      },
+      "FAC": {
+        "unseen_sentence": 8,
+        "seen_sentence_new_entity": 121
+      },
+      "GPE": {
+        "unseen_sentence": 153,
+        "seen_sentence_new_entity": 2538
+      },
+      "LANGUAGE": {
+        "unseen_sentence": 8,
+        "seen_sentence_new_entity": 25
+      },
+      "LAW": {
+        "unseen_sentence": 8,
+        "seen_sentence_new_entity": 83
+      },
+      "LOC": {
+        "unseen_sentence": 15,
+        "seen_sentence_new_entity": 224
+      },
+      "MONEY": {
+        "unseen_sentence": 1,
+        "seen_sentence_new_entity": 41
+      },
+      "NORP": {
+        "unseen_sentence": 125,
+        "seen_sentence_new_entity": 896
+      },
+      "OCC": {
+        "unseen_sentence": 50,
+        "seen_sentence_new_entity": 720
+      },
+      "ORDINAL": {
+        "unseen_sentence": 82,
+        "seen_sentence_new_entity": 699
+      },
+      "ORG": {
+        "unseen_sentence": 139,
+        "seen_sentence_new_entity": 2520
+      },
+      "PERCENT": {
+        "unseen_sentence": 2,
+        "seen_sentence_new_entity": 29
+      },
+      "PERS": {
+        "unseen_sentence": 143,
+        "seen_sentence_new_entity": 928
+      },
+      "PRODUCT": {
+        "unseen_sentence": 2,
+        "seen_sentence_new_entity": 17
+      },
+      "QUANTITY": {
+        "unseen_sentence": 1,
+        "seen_sentence_new_entity": 9
+      },
+      "TIME": {
+        "unseen_sentence": 19,
+        "seen_sentence_new_entity": 68
+      },
+      "UNIT": {
+        "unseen_sentence": 0,
+        "seen_sentence_new_entity": 11
+      },
+      "WEBSITE": {
+        "unseen_sentence": 52,
+        "seen_sentence_new_entity": 96
+      }
+    }
+  },
+  "validation": {
+    "ok": true,
+    "errors": []
+  }
+}

type_predictor_train.jsonl

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