| |
| """Build the multilingual HateSpeechMix DatasetDict. |
| |
| The conversion is intentionally conservative: |
| |
| * ``label`` uses the shared three-way space: neutral, offensive, and hate. |
| * ``fine_label`` and ``source_label`` retain the available source semantics. |
| * Chinese positives map to offensive because its main labels do not |
| distinguish offensive content from hate. |
| * Official test splits are preserved. Upstream dev splits are folded into |
| train. The unsplit English/Turkish data receives a deterministic, |
| stratified 90/10 split. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import csv |
| import hashlib |
| import io |
| import json |
| import shutil |
| import urllib.request |
| import zipfile |
| from collections import Counter, defaultdict |
| from pathlib import Path |
| from typing import Iterable, Iterator |
|
|
| from datasets import ClassLabel, Dataset, DatasetDict, Features, Value |
|
|
|
|
| BUILD_VERSION = "2.0.0" |
| SPLIT_SEED = "hatespeechmix-v1" |
|
|
| REPO_ROOT = Path(__file__).resolve().parents[1] |
| WORKSPACE_ROOT = REPO_ROOT.parent |
|
|
| SOURCE_SPECS = { |
| "toraman_en_tr": { |
| "url": ( |
| "https://raw.githubusercontent.com/metunlp/hate-speech/" |
| "f27c847b34e68c40ac654219b5824f8750b284d8/" |
| "dataset_v2/Toraman22_hate_speech_v2.tsv" |
| ), |
| "sha256": "c6c110de8e9656577b5781c8173d7974268c8e716adf5d804f98a50b2f4c0a95", |
| "filename": "toraman22_hate_speech_v2.tsv", |
| "revision": "f27c847b34e68c40ac654219b5824f8750b284d8", |
| }, |
| "cold_zh": { |
| "url": ( |
| "https://github.com/thu-coai/COLDataset/archive/" |
| "a0c55a945497ab58e94aef491180e1cf88ffb864.zip" |
| ), |
| "sha256": "8d8e4d2807a5eb5350a47ae733aac14fe6a0b24b77ad98da0a7693dbf8beca52", |
| "filename": "cold_zh.zip", |
| "revision": "a0c55a945497ab58e94aef491180e1cf88ffb864", |
| }, |
| "am_train": { |
| "url": ( |
| "https://huggingface.co/datasets/uhhlt/amharichatespeechranlp/resolve/" |
| "af6f5d115105a75387e8f67843ee77c807b84c4b/train.tsv" |
| ), |
| "sha256": "bccb82e9c777f04b3645e1de74c56520959e43ba782123c827805bbd42d3c6a5", |
| "filename": "am_train.tsv", |
| "revision": "af6f5d115105a75387e8f67843ee77c807b84c4b", |
| }, |
| "am_dev": { |
| "url": ( |
| "https://huggingface.co/datasets/uhhlt/amharichatespeechranlp/resolve/" |
| "af6f5d115105a75387e8f67843ee77c807b84c4b/dev.tsv" |
| ), |
| "sha256": "9d5767e0b52a876de1f87cd685e4a77cdf8564b463dbc547d202401680a61edf", |
| "filename": "am_dev.tsv", |
| "revision": "af6f5d115105a75387e8f67843ee77c807b84c4b", |
| }, |
| "am_test": { |
| "url": ( |
| "https://huggingface.co/datasets/uhhlt/amharichatespeechranlp/resolve/" |
| "af6f5d115105a75387e8f67843ee77c807b84c4b/test.tsv" |
| ), |
| "sha256": "245e88a99894e6687acfca686c6661ad87387fe7ca10750e85e42c72025c1fbb", |
| "filename": "am_test.tsv", |
| "revision": "af6f5d115105a75387e8f67843ee77c807b84c4b", |
| }, |
| } |
|
|
| HINDI_SHA256 = "d419780fe825f9946e3a03da4cf3fdf41699b188932d3662ca304693829994ad" |
| LABEL_NAMES = ["neutral", "offensive", "hate"] |
|
|
| FEATURES = Features( |
| { |
| "text": Value("string"), |
| "label": ClassLabel(names=LABEL_NAMES), |
| "label_text": Value("string"), |
| "fine_label": Value("string"), |
| "language": Value("string"), |
| "source": Value("string"), |
| "source_id": Value("string"), |
| "source_label": Value("string"), |
| "original_split": Value("string"), |
| "topic": Value("string"), |
| "target": Value("string"), |
| "text_available": Value("bool"), |
| } |
| ) |
|
|
| RAW_LANGUAGE_COUNTS = { |
| "am": 15_001, |
| "en": 68_597, |
| "hi": 5_983, |
| "tr": 60_310, |
| "zh": 37_480, |
| } |
|
|
| EXPECTED_LANGUAGE_COUNTS = { |
| "am": 15_000, |
| "en": 68_597, |
| "hi": 5_982, |
| "tr": 60_310, |
| "zh": 37_426, |
| } |
|
|
|
|
| def sha256(path: Path) -> str: |
| digest = hashlib.sha256() |
| with path.open("rb") as handle: |
| for block in iter(lambda: handle.read(1024 * 1024), b""): |
| digest.update(block) |
| return digest.hexdigest() |
|
|
|
|
| def verify_file(path: Path, expected_sha256: str) -> None: |
| actual = sha256(path) |
| if actual != expected_sha256: |
| raise ValueError( |
| f"SHA-256 mismatch for {path}: expected {expected_sha256}, got {actual}" |
| ) |
|
|
|
|
| def download_sources(cache_dir: Path) -> dict[str, Path]: |
| cache_dir.mkdir(parents=True, exist_ok=True) |
| paths: dict[str, Path] = {} |
| for name, spec in SOURCE_SPECS.items(): |
| path = cache_dir / str(spec["filename"]) |
| if path.exists(): |
| try: |
| verify_file(path, str(spec["sha256"])) |
| except ValueError: |
| path.unlink() |
| if not path.exists(): |
| temporary = path.with_suffix(path.suffix + ".partial") |
| with urllib.request.urlopen(str(spec["url"])) as response: |
| with temporary.open("wb") as handle: |
| shutil.copyfileobj(response, handle) |
| verify_file(temporary, str(spec["sha256"])) |
| temporary.replace(path) |
| paths[name] = path |
| return paths |
|
|
|
|
| def zip_member(archive: zipfile.ZipFile, suffix: str) -> str: |
| matches = [name for name in archive.namelist() if name.endswith(suffix)] |
| if len(matches) != 1: |
| raise ValueError(f"Expected one ZIP member ending in {suffix!r}, got {matches}") |
| return matches[0] |
|
|
|
|
| def dict_rows_from_zip( |
| archive_path: Path, member_suffix: str, *, delimiter: str = "," |
| ) -> Iterator[dict[str, str]]: |
| with zipfile.ZipFile(archive_path) as archive: |
| member = zip_member(archive, member_suffix) |
| with archive.open(member) as raw: |
| with io.TextIOWrapper(raw, encoding="utf-8-sig", newline="") as text: |
| yield from csv.DictReader(text, delimiter=delimiter) |
|
|
|
|
| def record( |
| *, |
| text: str | None, |
| label_text: str, |
| fine_label: str, |
| language: str, |
| source: str, |
| source_id: str, |
| source_label: str, |
| original_split: str, |
| topic: str | None = None, |
| target: str | None = None, |
| ) -> dict[str, object]: |
| if label_text not in LABEL_NAMES: |
| raise ValueError(f"Invalid normalized label: {label_text}") |
| return { |
| "text": text, |
| "label": LABEL_NAMES.index(label_text), |
| "label_text": label_text, |
| "fine_label": fine_label, |
| "language": language, |
| "source": source, |
| "source_id": source_id, |
| "source_label": source_label, |
| "original_split": original_split, |
| "topic": topic, |
| "target": target, |
| "text_available": text is not None and text != "", |
| } |
|
|
|
|
| def load_hindi(hindi_zip: Path) -> dict[str, list[dict[str, object]]]: |
| verify_file(hindi_zip, HINDI_SHA256) |
| fine_labels = {"NONE": "neutral", "OFFN": "offensive", "HATE": "hate", "PRFN": "profane"} |
| labels = {"NONE": "neutral", "OFFN": "offensive", "HATE": "hate", "PRFN": "offensive"} |
| targets = {"NONE": None, "TIN": "targeted", "UNT": "untargeted"} |
| members = { |
| "train": "hindi_dataset/hindi_dataset.tsv", |
| "test": "hindi_dataset/hasoc2019_hi_test_gold_2919.tsv", |
| } |
| splits: dict[str, list[dict[str, object]]] = {"train": [], "test": []} |
| for split, member in members.items(): |
| for row in dict_rows_from_zip(hindi_zip, member, delimiter="\t"): |
| task_1 = row["task_1"] |
| label_text = labels[row["task_2"]] |
| splits[split].append( |
| record( |
| text=row["text"], |
| label_text=label_text, |
| fine_label=fine_labels[row["task_2"]], |
| language="hi", |
| source="hasoc2019_hi", |
| source_id=row["text_id"], |
| source_label=f"{task_1}|{row['task_2']}|{row['task_3']}", |
| original_split=split, |
| target=targets[row["task_3"]], |
| ) |
| ) |
| return splits |
|
|
|
|
| def deterministic_stratified_split( |
| rows: list[dict[str, object]], |
| *, |
| strata: tuple[str, ...], |
| test_fraction: float = 0.1, |
| ) -> dict[str, list[dict[str, object]]]: |
| if not 0 < test_fraction < 1: |
| raise ValueError("test_fraction must be between zero and one") |
|
|
| groups: dict[tuple[object, ...], list[dict[str, object]]] = defaultdict(list) |
| for row in rows: |
| groups[tuple(row[field] for field in strata)].append(row) |
|
|
| test_keys: set[tuple[str, str]] = set() |
| for group_rows in groups.values(): |
| ranked = sorted( |
| group_rows, |
| key=lambda row: hashlib.sha256( |
| f"{SPLIT_SEED}:{row['source']}:{row['source_id']}".encode() |
| ).digest(), |
| ) |
| test_size = max(1, round(len(ranked) * test_fraction)) |
| test_keys.update( |
| (str(row["source"]), str(row["source_id"])) for row in ranked[:test_size] |
| ) |
|
|
| splits: dict[str, list[dict[str, object]]] = {"train": [], "test": []} |
| for row in rows: |
| key = (str(row["source"]), str(row["source_id"])) |
| split = "test" if key in test_keys else "train" |
| row = dict(row) |
| row["original_split"] = "unsplit" |
| splits[split].append(row) |
| return splits |
|
|
|
|
| def normalized_tsv_rows(path: Path) -> tuple[list[dict[str, str]], int]: |
| """Read the official TSV after repairing bare carriage returns in text.""" |
| with path.open(encoding="utf-8-sig", newline="") as handle: |
| raw = handle.read() |
| crlf_count = raw.count("\r\n") |
| bare_cr_count = raw.count("\r") - crlf_count |
| normalized = raw.replace("\r\n", "\n").replace("\r", " ") |
| rows = list(csv.DictReader(io.StringIO(normalized, newline=""), delimiter="\t")) |
| return rows, bare_cr_count |
|
|
|
|
| def load_english_turkish( |
| tsv_path: Path, |
| ) -> tuple[dict[str, list[dict[str, object]]], dict[str, object]]: |
| lang = {"0": "tr", "1": "en"} |
| topics = {"0": "religion", "1": "gender", "2": "race", "3": "politics", "4": "sports"} |
| labels = {"0": "neutral", "1": "offensive", "2": "hate"} |
| rows: list[dict[str, object]] = [] |
| dropped_reasons: Counter[str] = Counter() |
| source_rows, normalized_bare_cr = normalized_tsv_rows(tsv_path) |
| seen_ids: set[str] = set() |
| required_columns = {"tweet_id", "topic", "language", "text", "label"} |
|
|
| for row in source_rows: |
| if not required_columns.issubset(row) or any( |
| row.get(column) is None for column in required_columns |
| ): |
| dropped_reasons["malformed_columns"] += 1 |
| continue |
| if not row["tweet_id"].isdigit(): |
| dropped_reasons["invalid_tweet_id"] += 1 |
| continue |
| if row["tweet_id"] in seen_ids: |
| dropped_reasons["duplicate_tweet_id"] += 1 |
| continue |
| if row["language"] not in lang: |
| dropped_reasons["invalid_language"] += 1 |
| continue |
| if row["topic"] not in topics: |
| dropped_reasons["invalid_topic"] += 1 |
| continue |
| if row["label"] not in labels: |
| dropped_reasons["invalid_label"] += 1 |
| continue |
| if not row["text"].strip(): |
| dropped_reasons["empty_text"] += 1 |
| continue |
|
|
| seen_ids.add(row["tweet_id"]) |
| label_text = labels[row["label"]] |
| rows.append( |
| record( |
| text=row["text"], |
| label_text=label_text, |
| fine_label=label_text, |
| language=lang[row["language"]], |
| source="toraman2022_en_tr_v2", |
| source_id=row["tweet_id"], |
| source_label=row["label"], |
| original_split="unsplit", |
| topic=topics[row["topic"]], |
| ) |
| ) |
|
|
| quality_report = { |
| "source_rows": len(source_rows), |
| "retained_rows": len(rows), |
| "dropped_rows": sum(dropped_reasons.values()), |
| "dropped_reasons": dict(sorted(dropped_reasons.items())), |
| "normalized_bare_carriage_returns": normalized_bare_cr, |
| } |
| splits = deterministic_stratified_split( |
| rows, strata=("language", "topic", "fine_label"), test_fraction=0.1 |
| ) |
| return splits, quality_report |
|
|
|
|
| def load_chinese(archive_path: Path) -> dict[str, list[dict[str, object]]]: |
| splits: dict[str, list[dict[str, object]]] = {"train": [], "test": []} |
| fine_test = {"0": "neutral", "1": "offensive", "2": "offensive", "3": "neutral"} |
| target_test = {"0": None, "1": "individual", "2": "group", "3": None} |
| for upstream_split in ("train", "dev", "test"): |
| output_split = "test" if upstream_split == "test" else "train" |
| for index, row in enumerate( |
| dict_rows_from_zip(archive_path, f"COLDataset/{upstream_split}.csv") |
| ): |
| source_binary = row["label"] |
| source_fine = row.get("fine-grained-label") |
| if source_fine is None: |
| fine_label = "neutral" if source_binary == "0" else "offensive" |
| target = None |
| source_label = source_binary |
| else: |
| fine_label = fine_test[source_fine] |
| target = target_test[source_fine] |
| source_label = f"{source_binary}|{source_fine}" |
| splits[output_split].append( |
| record( |
| text=row["TEXT"], |
| label_text="neutral" if source_binary == "0" else "offensive", |
| fine_label=fine_label, |
| language="zh", |
| source="cold_zh", |
| |
| |
| source_id=f"{upstream_split}:{index:05d}", |
| source_label=source_label, |
| original_split=upstream_split, |
| topic=row["topic"], |
| target=target, |
| ) |
| ) |
| return splits |
|
|
|
|
| def load_amharic(paths: dict[str, Path]) -> dict[str, list[dict[str, object]]]: |
| splits: dict[str, list[dict[str, object]]] = {"train": [], "test": []} |
| for upstream_split in ("train", "dev", "test"): |
| output_split = "test" if upstream_split == "test" else "train" |
| with paths[f"am_{upstream_split}"].open(encoding="utf-8", newline="") as handle: |
| for index, row in enumerate(csv.reader(handle, delimiter="\t")): |
| if len(row) != 2: |
| raise ValueError( |
| f"Expected two Amharic TSV columns in {upstream_split} row {index}, got {len(row)}" |
| ) |
| source_fine_label, text = row |
| label_text = ( |
| "neutral" if source_fine_label == "normal" else source_fine_label |
| ) |
| splits[output_split].append( |
| record( |
| text=text, |
| label_text=label_text, |
| fine_label=label_text, |
| language="am", |
| source="amharic_ranlp2023", |
| source_id=f"{upstream_split}:{index:05d}", |
| source_label=source_fine_label, |
| original_split=upstream_split, |
| ) |
| ) |
| return splits |
|
|
|
|
| def merge_sources( |
| sources: Iterable[dict[str, list[dict[str, object]]]], |
| ) -> dict[str, list[dict[str, object]]]: |
| merged: dict[str, list[dict[str, object]]] = {"train": [], "test": []} |
| for source in sources: |
| for split in merged: |
| merged[split].extend(source[split]) |
| return merged |
|
|
|
|
| def remove_cross_split_text_leakage( |
| splits: dict[str, list[dict[str, object]]], |
| ) -> tuple[dict[str, list[dict[str, object]]], dict[str, object]]: |
| """Remove train rows whose exact source/text pair occurs in test. |
| |
| Test rows are authoritative. The `text_available` guard keeps this routine |
| safe if a future source introduces metadata-only rows. |
| """ |
| raw_language_counts = Counter( |
| str(row["language"]) for rows in splits.values() for row in rows |
| ) |
| if dict(sorted(raw_language_counts.items())) != RAW_LANGUAGE_COUNTS: |
| raise ValueError( |
| f"Unexpected raw language counts: {dict(sorted(raw_language_counts.items()))}" |
| ) |
|
|
| test_by_key: dict[tuple[str, str], list[dict[str, object]]] = defaultdict(list) |
| for row in splits["test"]: |
| if row["text_available"]: |
| test_by_key[(str(row["source"]), str(row["text"]))].append(row) |
|
|
| kept_train: list[dict[str, object]] = [] |
| removed: list[dict[str, object]] = [] |
| conflicting_labels = 0 |
| for row in splits["train"]: |
| key = (str(row["source"]), str(row["text"])) |
| matching_test_rows = test_by_key.get(key, []) if row["text_available"] else [] |
| if matching_test_rows: |
| removed.append(row) |
| if any(test_row["label"] != row["label"] for test_row in matching_test_rows): |
| conflicting_labels += 1 |
| else: |
| kept_train.append(row) |
|
|
| cleaned = {"train": kept_train, "test": splits["test"]} |
| report = { |
| "policy": "remove train rows with exact source/text match in test", |
| "removed_train_rows": len(removed), |
| "removed_rows_with_label_conflict": conflicting_labels, |
| "removed_by_source": dict( |
| sorted(Counter(str(row["source"]) for row in removed).items()) |
| ), |
| "removed_by_language": dict( |
| sorted(Counter(str(row["language"]) for row in removed).items()) |
| ), |
| } |
| return cleaned, report |
|
|
|
|
| def validate_records( |
| splits: dict[str, list[dict[str, object]]], |
| leakage_report: dict[str, object] | None = None, |
| ) -> dict[str, object]: |
| if set(splits) != {"train", "test"}: |
| raise ValueError(f"Expected train/test splits, got {sorted(splits)}") |
|
|
| language_counts: Counter[str] = Counter() |
| ids_by_split: dict[str, set[tuple[str, str]]] = {} |
| duplicate_texts: dict[str, int] = {} |
| for split, rows in splits.items(): |
| ids = [(str(row["source"]), str(row["source_id"])) for row in rows] |
| if len(ids) != len(set(ids)): |
| raise ValueError(f"Duplicate source/source_id pairs within {split}") |
| ids_by_split[split] = set(ids) |
|
|
| texts = [str(row["text"]) for row in rows if row["text_available"]] |
| duplicate_texts[split] = len(texts) - len(set(texts)) |
| for row in rows: |
| language_counts[str(row["language"])] += 1 |
| if bool(row["text_available"]) != ( |
| row["text"] is not None and row["text"] != "" |
| ): |
| raise ValueError("text_available disagrees with text") |
| expected_label = LABEL_NAMES.index(str(row["label_text"])) |
| if row["label"] != expected_label: |
| raise ValueError("label disagrees with label_text") |
|
|
| overlap = ids_by_split["train"] & ids_by_split["test"] |
| if overlap: |
| raise ValueError(f"{len(overlap)} source IDs occur in both train and test") |
|
|
| train_texts = { |
| (str(row["source"]), str(row["text"])) |
| for row in splits["train"] |
| if row["text_available"] |
| } |
| test_texts = { |
| (str(row["source"]), str(row["text"])) |
| for row in splits["test"] |
| if row["text_available"] |
| } |
| text_overlap = train_texts & test_texts |
| if text_overlap: |
| raise ValueError(f"{len(text_overlap)} exact texts occur in both train and test") |
| if dict(sorted(language_counts.items())) != EXPECTED_LANGUAGE_COUNTS: |
| raise ValueError( |
| f"Unexpected language counts: {dict(sorted(language_counts.items()))}" |
| ) |
|
|
| all_rows = splits["train"] + splits["test"] |
| return { |
| "build_version": BUILD_VERSION, |
| "split_seed": SPLIT_SEED, |
| "num_rows": len(all_rows), |
| "num_text_rows": sum(bool(row["text_available"]) for row in all_rows), |
| "num_metadata_only_rows": sum(not bool(row["text_available"]) for row in all_rows), |
| "split_counts": {split: len(rows) for split, rows in splits.items()}, |
| "language_counts": dict(sorted(language_counts.items())), |
| "split_language_counts": { |
| split: dict(sorted(Counter(str(row["language"]) for row in rows).items())) |
| for split, rows in splits.items() |
| }, |
| "label_counts": dict( |
| sorted(Counter(str(row["label_text"]) for row in all_rows).items()) |
| ), |
| "source_counts": dict( |
| sorted(Counter(str(row["source"]) for row in all_rows).items()) |
| ), |
| "cross_split_text_leakage": leakage_report, |
| "within_split_duplicate_text_counts": duplicate_texts, |
| } |
|
|
|
|
| def to_dataset_dict(splits: dict[str, list[dict[str, object]]]) -> DatasetDict: |
| return DatasetDict( |
| { |
| split: Dataset.from_list(rows, features=FEATURES) |
| for split, rows in splits.items() |
| } |
| ) |
|
|
|
|
| def write_outputs( |
| dataset: DatasetDict, |
| summary: dict[str, object], |
| output_dir: Path, |
| ) -> None: |
| data_dir = output_dir / "data" |
| metadata_dir = output_dir / "metadata" |
| local_dir = output_dir / "local_dataset" |
| data_dir.mkdir(parents=True, exist_ok=True) |
| metadata_dir.mkdir(parents=True, exist_ok=True) |
| local_dir.mkdir(parents=True, exist_ok=True) |
|
|
| for split, split_dataset in dataset.items(): |
| split_dataset.to_parquet(data_dir / f"{split}-00000-of-00001.parquet") |
| dataset.save_to_disk(local_dir) |
| (metadata_dir / "build_summary.json").write_text( |
| json.dumps(summary, indent=2, ensure_ascii=False) + "\n", |
| encoding="utf-8", |
| ) |
|
|
|
|
| def parse_args() -> argparse.Namespace: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument( |
| "--hindi-zip", |
| type=Path, |
| default=WORKSPACE_ROOT / "hindi_dataset.zip", |
| help="Path to the registered-access HASOC 2019 Hindi archive.", |
| ) |
| parser.add_argument( |
| "--cache-dir", |
| type=Path, |
| default=REPO_ROOT / ".cache" / "sources", |
| help="Download cache for pinned public sources.", |
| ) |
| parser.add_argument( |
| "--output-dir", |
| type=Path, |
| default=REPO_ROOT, |
| help="Repository/output directory.", |
| ) |
| return parser.parse_args() |
|
|
|
|
| def main() -> None: |
| args = parse_args() |
| source_paths = download_sources(args.cache_dir) |
| english_turkish, english_turkish_quality = load_english_turkish( |
| source_paths["toraman_en_tr"] |
| ) |
| splits = merge_sources( |
| [ |
| load_hindi(args.hindi_zip), |
| english_turkish, |
| load_chinese(source_paths["cold_zh"]), |
| load_amharic(source_paths), |
| ] |
| ) |
| splits, leakage_report = remove_cross_split_text_leakage(splits) |
| summary = validate_records(splits, leakage_report) |
| summary["source_quality"] = { |
| "toraman2022_en_tr_v2": english_turkish_quality, |
| } |
| dataset = to_dataset_dict(splits) |
| write_outputs(dataset, summary, args.output_dir) |
| print(json.dumps(summary, indent=2, ensure_ascii=False)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
