Document binary tag policies and add metadata conversion script

README.md

@@ -10,7 +10,7 @@ tags:
 
 # Speech Quality Test Labels
 
-It publishes only this README and [`metadata.jsonl`](./metadata.jsonl), because the 14 source datasets have different copyright and access terms.
+It publishes this README, [`metadata.jsonl`](./metadata.jsonl), and a tag-to-binary conversion script, because the 14 source datasets have different copyright and access terms.
 
 The manifest contains the 10,728-sample PICSAFEv1 subset. It is not a license to redistribute the underlying recordings.
 
@@ -22,31 +22,6 @@ The manifest contains the 10,728-sample PICSAFEv1 subset. It is not a license to
 - `source_path`: path relative to the origin directory. 
 - `tags`: list of labels.
 
-## Converting tag annotations to binary labels
-
-The ExtraTrees threshold-search script uses `binarize_tags` to map the multi-label `Tags` column to one binary label:
-
-- `1`: positive sample.
-- `0`: negative sample.
-
-The conversion is an exclusion rule: a row is `0` when it contains at least one negative tag for the selected mode; otherwise it is `1`. It does not require a particular positive tag. The modes match `filter_utils/optimal_threshold_search_desiciontree_ExtraTreesClassifier_5.py` exactly:
-
-| `positive_mode` | Any of these tags gives `binary_label=0` | Intended strictness |
-| --- | --- | --- |
-| `strict` | `Nspk`, `speech_overlap`, `low_noise_level`, `mid_high_noise_level`, `reverberation`, `music_or_effect`, `microphone_popping`, `excessive_sibilance`, `distortion` | Strictest quality filter |
-| `mid` | `speech_overlap`, `mid_high_noise_level`, `reverberation`, `music_or_effect`, `microphone_popping`, `excessive_sibilance`, `distortion` | Allows `Nspk` and low-level noise |
-| `loose` | `speech_overlap`, `mid_high_noise_level`, `reverberation`, `music_or_effect`, `distortion` | Most permissive |
-
-The standalone [`convert_tags_to_binary.py`](./convert_tags_to_binary.py) script accepts both `;` (used by the threshold-search script) and `|` (used by the PICSAFE TSV), preserves the input columns, and appends `binary_label`:
-
-```bash
-python convert_tags_to_binary.py \
-  --input datasets/test_datasets_labels.tsv \
-  --output datasets/test_datasets_labels_binary.tsv \
-  --positive-mode strict
-```
-
-Additional negative tags can be supplied with `--negative-tag`; any matching tag forces `binary_label=0` before the selected mode is evaluated, for example `--negative-tag wrong_transcript --negative-tag non_speech`.
 
 ## Source datasets and official download paths
 
@@ -73,6 +48,59 @@ In article, it is described that the 33 labels are:
 
 `Nspk`, `distortion`, `emotional`, `enhanced`, `excessive_sibilance`, `fast_speed`, `female`, `high_pitch`, `imperceptible_noise_level`, `instantaneous_noise`, `low_noise_level`, `low_pitch`, `male`, `microphone_popping`, `mid_high_noise_level`, `music_or_effect`, `nb_noise`, `non_binary`, `non_speech`, `read_speech`, `real_recording`, `regular_pitch`, `regular_speed`, `reverberation`, `singing_voice`, `slow_speed`, `speech_overlap`, `spontaneous_speech`, `synthetic`, `vocal_sound`, `wb_noise`, `whispered_speech`, and `wrong_transcript`.
 
+
+## Converting tags to binary labels
+
+Labels are derived from the human tags, not predictions
+from a decision tree or metric thresholds.
+
+- `1`: accepted under the selected policy (positive).
+- `0`: rejected because at least one negative tag is present (negative).
+
+The label is `0` if any annotation tag belongs to the mode-specific negative
+set below or the additional `--negative_tags` set; otherwise it is `1`.
+
+| Mode | Tags that produce label `0` (any match) |
+| --- | --- |
+| `strict` (default) | `Nspk`, `speech_overlap`, `low_noise_level`, `mid_high_noise_level`, `reverberation`, `music_or_effect`, `microphone_popping`, `excessive_sibilance`, `distortion` |
+| `mid` | `speech_overlap`, `mid_high_noise_level`, `reverberation`, `music_or_effect`, `microphone_popping`, `excessive_sibilance`, `distortion` |
+| `loose` | `speech_overlap`, `mid_high_noise_level`, `reverberation`, `music_or_effect`, `distortion` |
+
+`mid` allows `Nspk` and `low_noise_level`; `loose` additionally allows
+`microphone_popping` and `excessive_sibilance`. Other tags do not independently
+cause rejection. In particular, `non_speech`, `wrong_transcript`, `singing_voice`,
+`vocal_sound`, `nb_noise`, `wb_noise`, and `instantaneous_noise` are **not** default
+negative tags. Label `1` means policy acceptance, not a universal claim of clean
+speech or a correct transcript. Add rejection tags explicitly if needed.
+Names are case-sensitive (`Nspk`). An empty tag list yields `1`, matching the
+reference function, but does not establish annotation completeness.
+Missing tag fields and unknown tag names are errors.
+
+Run from the repository directory:
+
+```bash
+# Default policy.
+python3 tags_to_binary.py --input metadata.jsonl --output /tmp/picsafe_strict.jsonl
+
+# Alternative policy (also supports loose).
+python3 tags_to_binary.py --input metadata.jsonl --output /tmp/picsafe_mid.jsonl --positive_mode mid
+
+# Custom policy, different from the default labels.
+python3 tags_to_binary.py --input metadata.jsonl --output /tmp/picsafe_custom.jsonl --negative_tags non_speech wrong_transcript
+
+# Original annotations: UID and semicolon-separated Tags columns.
+python3 tags_to_binary.py --input annotations.tsv --output /tmp/picsafe_from_tsv.jsonl
+```
+
+Output JSONL preserves all original fields and adds `binary_label` and
+`label_policy` (the selected `positive_mode` and additional `negative_tags`).
+TSV input also adds `id` from `UID` and `tags` from `Tags`.
+The script prints class counts, validates unique IDs and tag names, and refuses
+to overwrite existing output files. The source `metadata.jsonl` is unchanged.
+Join with metric scores using globally unique `id`; basenames can collide.
+To reproduce a threshold-search run, use the same mode, additional negative
+tags, and sample subset.
+
 ## Licensing and limitations
 
 This repository does not grant, aggregate, or override any source-dataset license. Obtain the audio directly from the source providers and follow their current terms, attribution requirements, access restrictions, and applicable privacy/publicity rules. Some sources require non-commercial research use, registration, a license, or direct permission from the authors.

convert_tags_to_binary.py

@@ -1,161 +0,0 @@
-#!/usr/bin/env python3
-"""Convert UID/Tags TSV annotations to binary labels."""
-
-import argparse
-import csv
-import re
-from pathlib import Path
-
-
-VALID_TAGS = frozenset(
-    {
-        "real_recording",
-        "synthetic",
-        "enhanced",
-        "non_speech",
-        "whispered_speech",
-        "read_speech",
-        "spontaneous_speech",
-        "singing_voice",
-        "vocal_sound",
-        "emotional",
-        "regular_speed",
-        "slow_speed",
-        "fast_speed",
-        "regular_pitch",
-        "low_pitch",
-        "high_pitch",
-        "male",
-        "female",
-        "non_binary",
-        "Nspk",
-        "speech_overlap",
-        "nb_noise",
-        "wb_noise",
-        "instantaneous_noise",
-        "imperceptible_noise_level",
-        "low_noise_level",
-        "mid_high_noise_level",
-        "reverberation",
-        "music_or_effect",
-        "microphone_popping",
-        "excessive_sibilance",
-        "distortion",
-        "wrong_transcript",
-    }
-)
-
-NEGATIVE_TAGS = {
-    "strict": frozenset(
-        {
-            "Nspk",
-            "speech_overlap",
-            "low_noise_level",
-            "mid_high_noise_level",
-            "reverberation",
-            "music_or_effect",
-            "microphone_popping",
-            "excessive_sibilance",
-            "distortion",
-        }
-    ),
-    "mid": frozenset(
-        {
-            "speech_overlap",
-            "mid_high_noise_level",
-            "reverberation",
-            "music_or_effect",
-            "microphone_popping",
-            "excessive_sibilance",
-            "distortion",
-        }
-    ),
-    "loose": frozenset(
-        {
-            "speech_overlap",
-            "mid_high_noise_level",
-            "reverberation",
-            "music_or_effect",
-            "distortion",
-        }
-    ),
-}
-
-
-def parse_tags(value):
-    """Accept both the source script's ';' and PICSAFE's '|' separators."""
-    return [tag.strip() for tag in re.split(r"[;|]", value) if tag.strip()]
-
-
-def binarize_tags(tags, positive_mode, custom_negative_tags):
-    tags = set(tags)
-    invalid_tags = tags - VALID_TAGS
-    if invalid_tags:
-        raise ValueError(f"Invalid tags: {sorted(invalid_tags)}")
-    if tags.intersection(custom_negative_tags):
-        return 0
-    return int(not tags.intersection(NEGATIVE_TAGS[positive_mode]))
-
-
-def convert(input_path, output_path, positive_mode, custom_negative_tags):
-    output_path.parent.mkdir(parents=True, exist_ok=True)
-    with input_path.open("r", encoding="utf-8-sig", newline="") as source:
-        reader = csv.DictReader(source, delimiter="\t")
-        if not reader.fieldnames or {"UID", "Tags"} - set(reader.fieldnames):
-            raise ValueError("Input TSV must contain UID and Tags columns")
-
-        fieldnames = [*reader.fieldnames, "binary_label"]
-        counts = {0: 0, 1: 0}
-        seen_uids = set()
-        with output_path.open("w", encoding="utf-8", newline="") as target:
-            writer = csv.DictWriter(target, fieldnames=fieldnames, delimiter="\t")
-            writer.writeheader()
-            for row in reader:
-                uid = row["UID"]
-                if uid in seen_uids:
-                    raise ValueError(f"Duplicate UID: {uid}")
-                seen_uids.add(uid)
-                label = binarize_tags(
-                    parse_tags(row["Tags"]), positive_mode, custom_negative_tags
-                )
-                row["binary_label"] = label
-                writer.writerow(row)
-                counts[label] += 1
-    return len(seen_uids), counts
-
-
-def main():
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--input", type=Path, required=True, help="Input TSV")
-    parser.add_argument("--output", type=Path, required=True, help="Output TSV")
-    parser.add_argument(
-        "--positive-mode",
-        choices=sorted(NEGATIVE_TAGS),
-        default="strict",
-        help="Binarization rule (default: strict)",
-    )
-    parser.add_argument(
-        "--negative-tag",
-        action="append",
-        default=[],
-        help="Additional negative tag; repeat the option or separate values with commas",
-    )
-    args = parser.parse_args()
-
-    custom_negative_tags = {
-        tag.strip()
-        for value in args.negative_tag
-        for tag in value.split(",")
-        if tag.strip()
-    }
-    rows, counts = convert(
-        args.input, args.output, args.positive_mode, custom_negative_tags
-    )
-    print(
-        f"Wrote {rows} rows to {args.output} "
-        f"(positive=1: {counts[1]}, negative=0: {counts[0]})"
-    )
-
-
-if __name__ == "__main__":
-    main()

tags_to_binary.py

@@ -0,0 +1,153 @@
+#!/usr/bin/env python3
+"""Convert PICSAFEv1 tags to binary labels using only the standard library.
+
+Policy copied from binarize_tags in optimal_threshold_search_desiciontree.py.
+1 = accepted under the selected policy; 0 = rejected.
+"""
+import argparse
+import csv
+import json
+from pathlib import Path
+from typing import List, Tuple, Union
+
+VALID_TAGS = set(
+    [  # Data source
+        "real_recording",
+        "synthetic",
+        "enhanced",
+        # Speech styles
+        "non_speech",
+        "whispered_speech",
+        "read_speech",
+        "spontaneous_speech",
+        "singing_voice",
+        "vocal_sound",
+        "emotional",
+        # Speaking rate and pitch
+        "regular_speed",
+        "slow_speed",
+        "fast_speed",
+        "regular_pitch",
+        "low_pitch",
+        "high_pitch",
+        # Speaker attributes
+        "male",
+        "female",
+        "non_binary",
+        "Nspk",
+        "speech_overlap",
+        # Noise
+        "nb_noise",
+        "wb_noise",
+        "instantaneous_noise",
+        "imperceptible_noise_level",
+        "low_noise_level",
+        "mid_high_noise_level",
+        # Reverberation, distortion, and other interferences
+        "reverberation",
+        "music_or_effect",
+        "microphone_popping",
+        "excessive_sibilance",
+        "distortion",
+        "wrong_transcript",
+    ]
+)
+
+def binarize_tags( #标签二值化函数：根据不同标签和mode将音频分为0/1两类
+    tags: Union[List[str], Tuple[str]],
+    positive_mode: str = "strict",
+    negative_tags: Union[List[str], Tuple[str], None] = (),
+):
+    if not VALID_TAGS.issuperset(tags):
+        raise ValueError(f"Invalid tags: {tags}")
+    if negative_tags and set(tags).intersection(negative_tags):
+        # If any of the negative tags is present, consider the sample as negative
+        return 0
+    if positive_mode == "strict":
+        # Only consider tags that are strictly positive (clean speech)
+        negative_tags = set(
+            [
+                "Nspk",
+                "speech_overlap",
+                "low_noise_level",
+                "mid_high_noise_level",
+                "reverberation",
+                "music_or_effect",
+                "microphone_popping",
+                "excessive_sibilance",
+                "distortion",
+            ]
+        )
+        return 0 if negative_tags.intersection(tags) else 1
+    elif positive_mode == "mid":
+        # Consider tags that are either clean speech or low-level noise
+        negative_tags = set(
+            [
+                "speech_overlap",
+                "mid_high_noise_level",
+                "reverberation",
+                "music_or_effect",
+                "microphone_popping",
+                "excessive_sibilance",
+                "distortion",
+            ]
+        )
+        return 0 if negative_tags.intersection(tags) else 1
+    elif positive_mode == "loose":
+        # Consider all tags, including distortions and noise
+        negative_tags = set(
+            [
+                "speech_overlap",
+                "mid_high_noise_level",
+                "reverberation",
+                "music_or_effect",
+                "distortion",
+            ]
+        )
+        return 0 if negative_tags.intersection(tags) else 1
+    else:
+        raise ValueError(f"Invalid positive mode: {positive_mode}")
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--input", type=Path, default=Path(__file__).with_name("metadata.jsonl"))
+    parser.add_argument("--output", type=Path, required=True, help="New JSONL output path")
+    parser.add_argument("--positive_mode", choices=["strict", "mid", "loose"], default="strict")
+    parser.add_argument("--negative_tags", nargs="+", default=[], choices=sorted(VALID_TAGS))
+    args = parser.parse_args()
+    if args.input.resolve() == args.output.resolve():
+        parser.error("Input and output must be different files")
+    records, seen = [], set()
+    with args.input.open(encoding="utf-8") as stream:
+        is_tsv = args.input.suffix.lower() == ".tsv"
+        rows = csv.DictReader(stream, delimiter="\t") if is_tsv else (
+            json.loads(line) for line in stream if line.strip()
+        )
+        for row in rows:
+            if is_tsv:
+                row = dict(row, id=row["UID"], tags=row["Tags"].split(";"))
+            uid, tags = row["id"], row["tags"]
+            if not isinstance(uid, str) or not uid or uid in seen:
+                raise ValueError(f"Empty, invalid or duplicate id: {uid!r}")
+            seen.add(uid)
+            if not isinstance(tags, list) or not all(isinstance(t, str) for t in tags):
+                raise ValueError(f"{uid}: tags must be a list of strings")
+            if "binary_label" in row or "label_policy" in row:
+                raise ValueError(f"{uid}: input already has binary label fields")
+            records.append(dict(row,
+                binary_label=binarize_tags(tags, args.positive_mode, args.negative_tags),
+                label_policy={"positive_mode": args.positive_mode,
+                              "negative_tags": args.negative_tags}))
+    if not records:
+        raise ValueError("Input contains no records")
+    with args.output.open("x", encoding="utf-8") as stream:
+        for row in records:
+            stream.write(json.dumps(row, ensure_ascii=False) + "\n")
+    positive = sum(row["binary_label"] for row in records)
+    print(json.dumps({"total": len(records), "positive": positive,
+                      "negative": len(records) - positive,
+                      "positive_mode": args.positive_mode,
+                      "negative_tags": args.negative_tags}))
+
+if __name__ == "__main__":
+    main()