Upload folder using huggingface_hub

CITATION.cff

@@ -0,0 +1,9 @@
+cff-version: 1.2.0
+message: "If you use MDU-RiskText or MDU-RiskBench, please cite this dataset and the PriVTE paper."
+title: "MDU-RiskText and MDU-RiskBench"
+type: dataset
+authors:
+  - name: "PriVTE Authors"
+version: "1.0.0"
+date-released: "2026-07-28"
+repository-code: "https://github.com/Herrieson/privte-public"

LICENSE_DATA.md

@@ -0,0 +1,18 @@
+# MDU-RiskText / MDU-RiskBench Data Terms
+
+Copyright (c) 2026 PriVTE contributors.
+
+Permission is granted to use, reproduce, and redistribute the released
+MDU-RiskText and MDU-RiskBench files for research, education, evaluation, and
+non-commercial development, provided that users:
+
+1. cite the dataset and PriVTE paper;
+2. do not attempt to identify or contact participants or institutions;
+3. do not combine the records with external data for re-identification;
+4. do not use the data or derived systems for automated punishment,
+   disciplinary action, eligibility denial, or individual surveillance; and
+5. preserve these terms and the dataset attribution in redistributions.
+
+The data are provided as-is, without warranty. These terms cover the dataset
+records and benchmark metadata; separately released source code may use a
+different software license.

MANIFEST.json

@@ -0,0 +1,179 @@
+{
+  "schema_version": "mdu_risk_huggingface_release_manifest.v1",
+  "release_version": "1.0.0",
+  "participant_count": 850,
+  "selected_source_video_count": 9831,
+  "settings": [
+    "video_only",
+    "non_video_only",
+    "all_filtered_text"
+  ],
+  "split_counts": {
+    "train": 593,
+    "validation": 131,
+    "test": 126
+  },
+  "label_counts": {
+    "no_observed_risk": 226,
+    "mild_risk": 432,
+    "moderate_risk": 172,
+    "high_risk": 20
+  },
+  "files": [
+    {
+      "path": "CITATION.cff",
+      "bytes": 316,
+      "sha256": "e60eeab531e9b8556bbd95ad16e8198c802261d16d0ebd3c1a79491001881f4c"
+    },
+    {
+      "path": "LICENSE_DATA.md",
+      "bytes": 860,
+      "sha256": "4731d9956f0900820af455d36015a7b7b63c19b4b52a378741661224b2620c74"
+    },
+    {
+      "path": "MDU-RiskBench/README.md",
+      "bytes": 759,
+      "sha256": "5c94c9a26d85f7a80eec2fbb2b9b043305d7e47ffadca8c84abf54648c6efc07"
+    },
+    {
+      "path": "MDU-RiskBench/benchmark.json",
+      "bytes": 1453,
+      "sha256": "9b8a1b0f223d8ebc557c95829991decd5af18f059e48da076ad65a7a183c661a"
+    },
+    {
+      "path": "MDU-RiskBench/participants.jsonl.gz",
+      "bytes": 7467,
+      "sha256": "6bc074886abe1c6e309cf10e94ca8ac7969d0a0473a92f77e73888d8547e8173",
+      "rows": 850
+    },
+    {
+      "path": "MDU-RiskBench/prediction.schema.json",
+      "bytes": 764,
+      "sha256": "5207d5befc52e95cae52cd01825ff0019b978ffbbf831d73097f725c1b9309be"
+    },
+    {
+      "path": "MDU-RiskBench/reference_results/direct_video_comparison.csv",
+      "bytes": 324,
+      "sha256": "a1031b9f7cd54aa1b4132250686e3b6d92fb24b5a4bde9878efd10c173da6608"
+    },
+    {
+      "path": "MDU-RiskBench/reference_results/direct_video_comparison.json",
+      "bytes": 797,
+      "sha256": "acec89ae7074ad5d3cf7c4ac86432d2594d10dd87b9f396a2e8cc2458fc15f76"
+    },
+    {
+      "path": "MDU-RiskBench/reference_results/llm_full_matrix.csv",
+      "bytes": 1296,
+      "sha256": "e1c3a88e1d758ab438c9ea004533c48bd0db6917c89414a123cbbf06e6ec08de"
+    },
+    {
+      "path": "MDU-RiskBench/reference_results/llm_full_matrix.json",
+      "bytes": 3913,
+      "sha256": "cb9b08127d27525251fce3278f75cc7cba91d150b7b0583856bd70cde8bc7266"
+    },
+    {
+      "path": "MDU-RiskBench/reference_results/llm_setting_means.csv",
+      "bytes": 391,
+      "sha256": "06580cfc9fe94b50c4269361941dbc835c59be5767d10c1fcac83725627d6683"
+    },
+    {
+      "path": "MDU-RiskBench/reference_results/llm_setting_means.json",
+      "bytes": 972,
+      "sha256": "0a4b37af4ab6ece03ca730fbab174afcd1fc8044aa5d611ab6cdabc8690d0673"
+    },
+    {
+      "path": "MDU-RiskBench/reference_results/trained_video_only_baselines.csv",
+      "bytes": 356,
+      "sha256": "3a746a0ea3acbda8e122dc353a8e2e907077d4692f1cefd652ac9ee6a97ea129"
+    },
+    {
+      "path": "MDU-RiskBench/reference_results/trained_video_only_baselines.json",
+      "bytes": 1067,
+      "sha256": "fe5cc83e5a219b658d71f92081e397ed73245563b5ed3c0a13c2f888caa8b5d9"
+    },
+    {
+      "path": "MDU-RiskText/README.md",
+      "bytes": 934,
+      "sha256": "510f3ae71076f421e29d826b9512c8ea39418053afb10f98fc529c97fdee960f"
+    },
+    {
+      "path": "MDU-RiskText/all_filtered_text/test.jsonl.gz",
+      "bytes": 452994,
+      "sha256": "50840c1ddc3fc76ebe21814cf2b41865644830ea21fa20e1a293e15c173439e4",
+      "rows": 126
+    },
+    {
+      "path": "MDU-RiskText/all_filtered_text/train.jsonl.gz",
+      "bytes": 2099999,
+      "sha256": "6046f11a57db90a140ecb9e1f1d81c9182277d97f3ae9c9b139c080df5f8a1ca",
+      "rows": 593
+    },
+    {
+      "path": "MDU-RiskText/all_filtered_text/validation.jsonl.gz",
+      "bytes": 480862,
+      "sha256": "4ed49e171f093761671416ff060da0f1242a56eb38c2e42773170d2810ec44e4",
+      "rows": 131
+    },
+    {
+      "path": "MDU-RiskText/non_video_only/test.jsonl.gz",
+      "bytes": 32918,
+      "sha256": "4044b80e11222672f8f0c31c1f74e6e86fd1f97a758f869e2e92257c3eec4fd3",
+      "rows": 126
+    },
+    {
+      "path": "MDU-RiskText/non_video_only/train.jsonl.gz",
+      "bytes": 139533,
+      "sha256": "8a95077c2d8e95a1cb5e20a5b5c9c954853a942bbff01cdc5a815ad25201164a",
+      "rows": 593
+    },
+    {
+      "path": "MDU-RiskText/non_video_only/validation.jsonl.gz",
+      "bytes": 34139,
+      "sha256": "a8bbdeecd60c97e9a800f5a4c8c027c63966208e512165ec28daed7557991fcb",
+      "rows": 131
+    },
+    {
+      "path": "MDU-RiskText/record.schema.json",
+      "bytes": 1164,
+      "sha256": "760713b21f391c0f876a8b038c6b06872d4ea23c8243c8de3cd8948f55869bad"
+    },
+    {
+      "path": "MDU-RiskText/video_only/test.jsonl.gz",
+      "bytes": 260025,
+      "sha256": "09d1de11c631057e2c675ffc905070659aa7476659129406fa553edac6982013",
+      "rows": 126
+    },
+    {
+      "path": "MDU-RiskText/video_only/train.jsonl.gz",
+      "bytes": 1175832,
+      "sha256": "3dce8f876a5d1b190ee2963b6dcf7f754091c73b18c51ed24f3addf1b2c7ebd3",
+      "rows": 593
+    },
+    {
+      "path": "MDU-RiskText/video_only/validation.jsonl.gz",
+      "bytes": 274850,
+      "sha256": "d9be520041a74fa35669171e4ae863f2cac83a218c458164b2d096706cd383fb",
+      "rows": 131
+    },
+    {
+      "path": "README.md",
+      "bytes": 4855,
+      "sha256": "115f9f2b26bbbb9f4e683b0e1afaa916a79e42089fef782cfaa9476812c4f745"
+    },
+    {
+      "path": "scripts/build_release.py",
+      "bytes": 30862,
+      "sha256": "26603875fc69b9e2d6c5b73be2721f30a4391444593454f2968df9b5a280666b"
+    },
+    {
+      "path": "scripts/evaluate_predictions.py",
+      "bytes": 2927,
+      "sha256": "415f25e6bd395b420911c01b4a2ad253aefea8fee8568e821e4b4e7e3ca57696"
+    },
+    {
+      "path": "scripts/verify_release.py",
+      "bytes": 3005,
+      "sha256": "48ebf393e9ff5c392f4ff20cafbaab04c9ca1f3faeaed8dbed41fb3d9a499104"
+    }
+  ]
+}

MDU-RiskBench/README.md

@@ -0,0 +1,20 @@
+# MDU-RiskBench
+
+MDU-RiskBench is the benchmark definition paired with MDU-RiskText. It
+contains:
+
+- `benchmark.json`: cohort, labels, settings, and metric definitions;
+- `participants.jsonl.gz`: the frozen 850-participant index;
+- `prediction.schema.json`: submission record contract;
+- `reference_results/`: aggregate result tables when available;
+- `../scripts/evaluate_predictions.py`: reference evaluator;
+- `../scripts/verify_release.py`: integrity and alignment validator.
+
+A prediction JSONL contains one object per participant:
+
+```json
+{"sample_id":"MDURT_000001","risk_level":"mild_risk"}
+```
+
+Models may additionally output `confidence`, evidence references, rationale,
+and review flags; the reference evaluator uses `sample_id` and `risk_level`.

MDU-RiskBench/benchmark.json

@@ -0,0 +1,47 @@
+{
+  "schema_version": "mdu_riskbench.v1",
+  "name": "MDU-RiskBench",
+  "paired_dataset": "MDU-RiskText v1",
+  "task": "Text-only Youth Digital Use Risk Screening",
+  "participant_count": 850,
+  "selected_source_video_count": 9831,
+  "participant_disjoint_splits": true,
+  "split_counts": {
+    "train": 593,
+    "validation": 131,
+    "test": 126
+  },
+  "ordinal_labels": [
+    "no_observed_risk",
+    "mild_risk",
+    "moderate_risk",
+    "high_risk"
+  ],
+  "abstention_label": "insufficient_evidence",
+  "label_counts": {
+    "no_observed_risk": 226,
+    "mild_risk": 432,
+    "moderate_risk": 172,
+    "high_risk": 20
+  },
+  "headline_settings": {
+    "video_only": "PriVTE privacy-filtered video-to-text evidence",
+    "non_video_only": "coarse app-category, heart-rate-bin, and questionnaire-risk text",
+    "all_filtered_text": "PriVTE evidence plus coarse auxiliary text"
+  },
+  "primary_metrics": [
+    "accuracy",
+    "macro_f1",
+    "ordinal_mae",
+    "ordinal_rmse",
+    "coverage"
+  ],
+  "ordinal_metric_policy": "MAE and RMSE are computed on predictions in the four ordinal labels; insufficient_evidence is reported through coverage.",
+  "source_video_selection": {
+    "maximum_selected_per_participant": 12,
+    "selection": "uniform_over_ordered_source_inventory",
+    "minimum_video_stream_duration_seconds": 4.0,
+    "all_selected_files_must_pass_technical_validation": true,
+    "replacement_after_selected_file_failure": false
+  }
+}

MDU-RiskBench/participants.jsonl.gz

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

MDU-RiskBench/prediction.schema.json

@@ -0,0 +1,41 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "MDU-RiskBench prediction record",
+  "type": "object",
+  "required": [
+    "sample_id",
+    "risk_level"
+  ],
+  "properties": {
+    "sample_id": {
+      "type": "string",
+      "pattern": "^MDURT_[0-9]{6}$"
+    },
+    "risk_level": {
+      "enum": [
+        "no_observed_risk",
+        "mild_risk",
+        "moderate_risk",
+        "high_risk",
+        "insufficient_evidence"
+      ]
+    },
+    "confidence": {
+      "enum": [
+        "low",
+        "medium",
+        "high"
+      ]
+    },
+    "evidence_used": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "needs_human_review": {
+      "type": "boolean"
+    }
+  },
+  "additionalProperties": true
+}

MDU-RiskBench/reference_results/direct_video_comparison.csv

@@ -0,0 +1,4 @@
+input,model,participants,accuracy,macro_f1,coverage,selective_ordinal_mae,selective_within_one,elevated_recall
+direct_video,Keye-VL-1.5-8B,704,0.1747,0.0744,1.0,1.1023,0.75,0.0
+direct_video,Qwen3-VL-8B-Instruct,704,0.2514,0.1443,1.0,0.9702,0.8026,0.0
+privte_text,Qwen3.6-Flash,704,0.3935,0.2094,0.9616,0.7208,0.8833,0.0

MDU-RiskBench/reference_results/direct_video_comparison.json

@@ -0,0 +1,35 @@
+[
+  {
+    "input": "direct_video",
+    "model": "Keye-VL-1.5-8B",
+    "participants": 704,
+    "accuracy": 0.1747,
+    "macro_f1": 0.0744,
+    "coverage": 1.0,
+    "selective_ordinal_mae": 1.1023,
+    "selective_within_one": 0.75,
+    "elevated_recall": 0.0
+  },
+  {
+    "input": "direct_video",
+    "model": "Qwen3-VL-8B-Instruct",
+    "participants": 704,
+    "accuracy": 0.2514,
+    "macro_f1": 0.1443,
+    "coverage": 1.0,
+    "selective_ordinal_mae": 0.9702,
+    "selective_within_one": 0.8026,
+    "elevated_recall": 0.0
+  },
+  {
+    "input": "privte_text",
+    "model": "Qwen3.6-Flash",
+    "participants": 704,
+    "accuracy": 0.3935,
+    "macro_f1": 0.2094,
+    "coverage": 0.9616,
+    "selective_ordinal_mae": 0.7208,
+    "selective_within_one": 0.8833,
+    "elevated_recall": 0.0
+  }
+]

MDU-RiskBench/reference_results/llm_full_matrix.csv

@@ -0,0 +1,13 @@
+setting,model,participants,accuracy,macro_f1,ordinal_mae,qwk,within_one,severe_error,elevated_recall,abstention,coverage
+video_only,qwen3.6-flash,850,0.3941,0.2204,0.7015,0.0498,0.8943,0.1057,0.0,0.0541,0.9459
+video_only,deepseek-v4-flash,850,0.1906,0.1231,0.9924,-0.01,0.782,0.218,0.0,0.2282,0.7718
+video_only,gpt-5.6-terra,850,0.1918,0.088,1.0433,0.0084,0.7638,0.2362,0.0,0.1035,0.8965
+video_only,gemini-3.5-flash,850,0.1412,0.0702,1.0981,-0.0013,0.7504,0.2496,0.0,0.2082,0.7918
+non_video_only,qwen3.6-flash,850,0.4612,0.3204,0.6191,0.3109,0.9186,0.0814,0.7969,0.0024,0.9976
+non_video_only,deepseek-v4-flash,850,0.5141,0.3161,0.5131,0.2821,0.9667,0.0333,0.2135,0.0118,0.9882
+non_video_only,gpt-5.6-terra,850,0.5047,0.3641,0.5541,0.4098,0.9412,0.0588,0.849,0.0,1.0
+non_video_only,gemini-3.5-flash,850,0.4718,0.3413,0.5833,0.3724,0.9393,0.0607,0.776,0.0118,0.9882
+all_privacy_filtered_text,qwen3.6-flash,850,0.5024,0.3124,0.54,0.2511,0.9576,0.0424,0.2708,0.0,1.0
+all_privacy_filtered_text,deepseek-v4-flash,850,0.5106,0.2772,0.506,0.2669,0.9736,0.0264,0.0314,0.0188,0.9812
+all_privacy_filtered_text,gpt-5.6-terra,850,0.5282,0.3923,0.5212,0.4559,0.9506,0.0494,0.7865,0.0,1.0
+all_privacy_filtered_text,gemini-3.5-flash,850,0.5106,0.3748,0.529,0.4346,0.9574,0.0426,0.6979,0.0059,0.9941

MDU-RiskBench/reference_results/llm_full_matrix.json

@@ -0,0 +1,170 @@
+[
+  {
+    "setting": "video_only",
+    "model": "qwen3.6-flash",
+    "participants": 850,
+    "accuracy": 0.3941,
+    "macro_f1": 0.2204,
+    "ordinal_mae": 0.7015,
+    "qwk": 0.0498,
+    "within_one": 0.8943,
+    "severe_error": 0.1057,
+    "elevated_recall": 0.0,
+    "abstention": 0.0541,
+    "coverage": 0.9459
+  },
+  {
+    "setting": "video_only",
+    "model": "deepseek-v4-flash",
+    "participants": 850,
+    "accuracy": 0.1906,
+    "macro_f1": 0.1231,
+    "ordinal_mae": 0.9924,
+    "qwk": -0.01,
+    "within_one": 0.782,
+    "severe_error": 0.218,
+    "elevated_recall": 0.0,
+    "abstention": 0.2282,
+    "coverage": 0.7718
+  },
+  {
+    "setting": "video_only",
+    "model": "gpt-5.6-terra",
+    "participants": 850,
+    "accuracy": 0.1918,
+    "macro_f1": 0.088,
+    "ordinal_mae": 1.0433,
+    "qwk": 0.0084,
+    "within_one": 0.7638,
+    "severe_error": 0.2362,
+    "elevated_recall": 0.0,
+    "abstention": 0.1035,
+    "coverage": 0.8965
+  },
+  {
+    "setting": "video_only",
+    "model": "gemini-3.5-flash",
+    "participants": 850,
+    "accuracy": 0.1412,
+    "macro_f1": 0.0702,
+    "ordinal_mae": 1.0981,
+    "qwk": -0.0013,
+    "within_one": 0.7504,
+    "severe_error": 0.2496,
+    "elevated_recall": 0.0,
+    "abstention": 0.2082,
+    "coverage": 0.7918
+  },
+  {
+    "setting": "non_video_only",
+    "model": "qwen3.6-flash",
+    "participants": 850,
+    "accuracy": 0.4612,
+    "macro_f1": 0.3204,
+    "ordinal_mae": 0.6191,
+    "qwk": 0.3109,
+    "within_one": 0.9186,
+    "severe_error": 0.0814,
+    "elevated_recall": 0.7969,
+    "abstention": 0.0024,
+    "coverage": 0.9976
+  },
+  {
+    "setting": "non_video_only",
+    "model": "deepseek-v4-flash",
+    "participants": 850,
+    "accuracy": 0.5141,
+    "macro_f1": 0.3161,
+    "ordinal_mae": 0.5131,
+    "qwk": 0.2821,
+    "within_one": 0.9667,
+    "severe_error": 0.0333,
+    "elevated_recall": 0.2135,
+    "abstention": 0.0118,
+    "coverage": 0.9882
+  },
+  {
+    "setting": "non_video_only",
+    "model": "gpt-5.6-terra",
+    "participants": 850,
+    "accuracy": 0.5047,
+    "macro_f1": 0.3641,
+    "ordinal_mae": 0.5541,
+    "qwk": 0.4098,
+    "within_one": 0.9412,
+    "severe_error": 0.0588,
+    "elevated_recall": 0.849,
+    "abstention": 0.0,
+    "coverage": 1.0
+  },
+  {
+    "setting": "non_video_only",
+    "model": "gemini-3.5-flash",
+    "participants": 850,
+    "accuracy": 0.4718,
+    "macro_f1": 0.3413,
+    "ordinal_mae": 0.5833,
+    "qwk": 0.3724,
+    "within_one": 0.9393,
+    "severe_error": 0.0607,
+    "elevated_recall": 0.776,
+    "abstention": 0.0118,
+    "coverage": 0.9882
+  },
+  {
+    "setting": "all_privacy_filtered_text",
+    "model": "qwen3.6-flash",
+    "participants": 850,
+    "accuracy": 0.5024,
+    "macro_f1": 0.3124,
+    "ordinal_mae": 0.54,
+    "qwk": 0.2511,
+    "within_one": 0.9576,
+    "severe_error": 0.0424,
+    "elevated_recall": 0.2708,
+    "abstention": 0.0,
+    "coverage": 1.0
+  },
+  {
+    "setting": "all_privacy_filtered_text",
+    "model": "deepseek-v4-flash",
+    "participants": 850,
+    "accuracy": 0.5106,
+    "macro_f1": 0.2772,
+    "ordinal_mae": 0.506,
+    "qwk": 0.2669,
+    "within_one": 0.9736,
+    "severe_error": 0.0264,
+    "elevated_recall": 0.0314,
+    "abstention": 0.0188,
+    "coverage": 0.9812
+  },
+  {
+    "setting": "all_privacy_filtered_text",
+    "model": "gpt-5.6-terra",
+    "participants": 850,
+    "accuracy": 0.5282,
+    "macro_f1": 0.3923,
+    "ordinal_mae": 0.5212,
+    "qwk": 0.4559,
+    "within_one": 0.9506,
+    "severe_error": 0.0494,
+    "elevated_recall": 0.7865,
+    "abstention": 0.0,
+    "coverage": 1.0
+  },
+  {
+    "setting": "all_privacy_filtered_text",
+    "model": "gemini-3.5-flash",
+    "participants": 850,
+    "accuracy": 0.5106,
+    "macro_f1": 0.3748,
+    "ordinal_mae": 0.529,
+    "qwk": 0.4346,
+    "within_one": 0.9574,
+    "severe_error": 0.0426,
+    "elevated_recall": 0.6979,
+    "abstention": 0.0059,
+    "coverage": 0.9941
+  }
+]

MDU-RiskBench/reference_results/llm_setting_means.csv

@@ -0,0 +1,4 @@
+setting,models,participants_per_model,accuracy,macro_f1,ordinal_mae,qwk,within_one,severe_error,elevated_recall,abstention,coverage
+video_only,4,850,0.2294,0.1254,0.9588,0.0117,0.7976,0.2024,0.0,0.1485,0.8515
+non_video_only,4,850,0.4879,0.3355,0.5674,0.3438,0.9415,0.0585,0.6589,0.0065,0.9935
+all_privacy_filtered_text,4,850,0.513,0.3392,0.5241,0.3521,0.9598,0.0402,0.4466,0.0062,0.9938

MDU-RiskBench/reference_results/llm_setting_means.json

@@ -0,0 +1,44 @@
+[
+  {
+    "setting": "video_only",
+    "models": 4,
+    "participants_per_model": 850,
+    "accuracy": 0.2294,
+    "macro_f1": 0.1254,
+    "ordinal_mae": 0.9588,
+    "qwk": 0.0117,
+    "within_one": 0.7976,
+    "severe_error": 0.2024,
+    "elevated_recall": 0.0,
+    "abstention": 0.1485,
+    "coverage": 0.8515
+  },
+  {
+    "setting": "non_video_only",
+    "models": 4,
+    "participants_per_model": 850,
+    "accuracy": 0.4879,
+    "macro_f1": 0.3355,
+    "ordinal_mae": 0.5674,
+    "qwk": 0.3438,
+    "within_one": 0.9415,
+    "severe_error": 0.0585,
+    "elevated_recall": 0.6589,
+    "abstention": 0.0065,
+    "coverage": 0.9935
+  },
+  {
+    "setting": "all_privacy_filtered_text",
+    "models": 4,
+    "participants_per_model": 850,
+    "accuracy": 0.513,
+    "macro_f1": 0.3392,
+    "ordinal_mae": 0.5241,
+    "qwk": 0.3521,
+    "within_one": 0.9598,
+    "severe_error": 0.0402,
+    "elevated_recall": 0.4466,
+    "abstention": 0.0062,
+    "coverage": 0.9938
+  }
+]

MDU-RiskBench/reference_results/trained_video_only_baselines.csv

@@ -0,0 +1,6 @@
+method,test_participants,accuracy,macro_f1,ordinal_mae,qwk,within_one,elevated_recall
+Majority,126,0.4921,0.1649,0.5317,0.0,0.9762,0.0
+TF-IDF,126,0.619,0.3307,0.4206,0.284,0.9683,0.0
+Logistic,126,0.4683,0.4,0.746,0.3384,0.8095,0.6296
+Boosted stumps,126,0.6349,0.3477,0.4206,0.2876,0.9603,0.0
+Positional-W,126,0.5079,0.3826,0.6349,0.3001,0.873,0.4074

MDU-RiskBench/reference_results/trained_video_only_baselines.json

@@ -0,0 +1,52 @@
+[
+  {
+    "method": "Majority",
+    "test_participants": 126,
+    "accuracy": 0.4921,
+    "macro_f1": 0.1649,
+    "ordinal_mae": 0.5317,
+    "qwk": 0.0,
+    "within_one": 0.9762,
+    "elevated_recall": 0.0
+  },
+  {
+    "method": "TF-IDF",
+    "test_participants": 126,
+    "accuracy": 0.619,
+    "macro_f1": 0.3307,
+    "ordinal_mae": 0.4206,
+    "qwk": 0.284,
+    "within_one": 0.9683,
+    "elevated_recall": 0.0
+  },
+  {
+    "method": "Logistic",
+    "test_participants": 126,
+    "accuracy": 0.4683,
+    "macro_f1": 0.4,
+    "ordinal_mae": 0.746,
+    "qwk": 0.3384,
+    "within_one": 0.8095,
+    "elevated_recall": 0.6296
+  },
+  {
+    "method": "Boosted stumps",
+    "test_participants": 126,
+    "accuracy": 0.6349,
+    "macro_f1": 0.3477,
+    "ordinal_mae": 0.4206,
+    "qwk": 0.2876,
+    "within_one": 0.9603,
+    "elevated_recall": 0.0
+  },
+  {
+    "method": "Positional-W",
+    "test_participants": 126,
+    "accuracy": 0.5079,
+    "macro_f1": 0.3826,
+    "ordinal_mae": 0.6349,
+    "qwk": 0.3001,
+    "within_one": 0.873,
+    "elevated_recall": 0.4074
+  }
+]

MDU-RiskText/README.md

@@ -0,0 +1,20 @@
+# MDU-RiskText
+
+MDU-RiskText contains all 850 participant-level textual evidence records for
+the three headline evidence settings. Each setting is split into train,
+validation, and test gzip-compressed JSONL files.
+
+Every row has the following fields:
+
+- `schema_version`: public participant-record schema version;
+- `sample_id`: stable public participant ID shared across settings;
+- `split`: `train`, `validation`, or `test`;
+- `target_label`: ordinal risk label and aggregated window-label counts;
+- `benchmark_setting`: evidence configuration name;
+- `llm_evidence_package`: structured model-facing JSON object;
+- `text_evidence`: compact serialization of that same package.
+
+The public files preserve the complete model-facing inputs. They intentionally
+exclude redundant internal feature blocks, source paths, source filenames,
+internal participant IDs, and preprocessing debug views that were not supplied
+to benchmark models.

MDU-RiskText/all_filtered_text/test.jsonl.gz

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

MDU-RiskText/all_filtered_text/train.jsonl.gz

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

MDU-RiskText/all_filtered_text/validation.jsonl.gz

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

MDU-RiskText/non_video_only/test.jsonl.gz

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

MDU-RiskText/non_video_only/train.jsonl.gz

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

MDU-RiskText/non_video_only/validation.jsonl.gz

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

MDU-RiskText/record.schema.json

@@ -0,0 +1,60 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "MDU-RiskText participant record",
+  "type": "object",
+  "required": [
+    "schema_version",
+    "sample_id",
+    "split",
+    "target_label",
+    "benchmark_setting",
+    "llm_evidence_package",
+    "text_evidence"
+  ],
+  "properties": {
+    "schema_version": {
+      "const": "mdu_risktext.participant_record.v1"
+    },
+    "sample_id": {
+      "type": "string",
+      "pattern": "^MDURT_[0-9]{6}$"
+    },
+    "split": {
+      "enum": [
+        "train",
+        "validation",
+        "test"
+      ]
+    },
+    "benchmark_setting": {
+      "enum": [
+        "video_only",
+        "non_video_only",
+        "all_filtered_text"
+      ]
+    },
+    "target_label": {
+      "type": "object",
+      "required": [
+        "risk_level",
+        "available"
+      ],
+      "properties": {
+        "risk_level": {
+          "enum": [
+            "no_observed_risk",
+            "mild_risk",
+            "moderate_risk",
+            "high_risk"
+          ]
+        }
+      }
+    },
+    "llm_evidence_package": {
+      "type": "object"
+    },
+    "text_evidence": {
+      "type": "string"
+    }
+  }
+}

MDU-RiskText/video_only/test.jsonl.gz

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

MDU-RiskText/video_only/train.jsonl.gz

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

MDU-RiskText/video_only/validation.jsonl.gz

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

README.md

@@ -0,0 +1,127 @@
+---
+pretty_name: MDU-RiskText and MDU-RiskBench
+language:
+- en
+- zh
+license: other
+task_categories:
+- text-classification
+tags:
+- privacy
+- video-to-text
+- ordinal-classification
+- youth-digital-use
+- evidence-grounding
+configs:
+- config_name: video_only
+  data_files:
+  - split: train
+    path: MDU-RiskText/video_only/train.jsonl.gz
+  - split: validation
+    path: MDU-RiskText/video_only/validation.jsonl.gz
+  - split: test
+    path: MDU-RiskText/video_only/test.jsonl.gz
+- config_name: non_video_only
+  data_files:
+  - split: train
+    path: MDU-RiskText/non_video_only/train.jsonl.gz
+  - split: validation
+    path: MDU-RiskText/non_video_only/validation.jsonl.gz
+  - split: test
+    path: MDU-RiskText/non_video_only/test.jsonl.gz
+- config_name: all_filtered_text
+  data_files:
+  - split: train
+    path: MDU-RiskText/all_filtered_text/train.jsonl.gz
+  - split: validation
+    path: MDU-RiskText/all_filtered_text/validation.jsonl.gz
+  - split: test
+    path: MDU-RiskText/all_filtered_text/test.jsonl.gz
+---
+
+# MDU-RiskText and MDU-RiskBench
+
+This repository contains the public 850-participant release associated with
+PriVTE: Privacy-Preserving Video-to-Text Evidence Encoding for Youth Digital
+Use Risk Screening.
+
+## Data products
+
+- **MDU-RiskText** contains participant-level, privacy-filtered textual
+  evidence, the frozen ordinal target, and participant-disjoint split for all
+  850 participants.
+- **MDU-RiskBench** defines the task, label order, three headline evidence
+  settings, participant index, evaluation protocol, and reference metric code.
+
+The frozen cohort contains 9,831 selected source videos. It is split into 593
+train, 131 validation, and 126 test participants. Target counts are 226
+`no_observed_risk`, 432 `mild_risk`, 172 `moderate_risk`, and 20 `high_risk`.
+
+## Load with Hugging Face Datasets
+
+```python
+from datasets import load_dataset
+
+video = load_dataset("Herrieson/MDU-RiskText", "video_only")
+non_video = load_dataset("Herrieson/MDU-RiskText", "non_video_only")
+combined = load_dataset("Herrieson/MDU-RiskText", "all_filtered_text")
+```
+
+Replace `Herrieson/MDU-RiskText` if the final dataset repository uses a
+different owner or name. Each row includes `sample_id`, `split`,
+`target_label`, `benchmark_setting`, `llm_evidence_package`, and
+`text_evidence`. The last field is the compact JSON string supplied to the
+text-only model runners.
+
+## Headline settings
+
+| Configuration | Model-facing evidence |
+|---|---|
+| `video_only` | PriVTE evidence derived from locally processed video |
+| `non_video_only` | Coarsened app-category, heart-rate-bin, and questionnaire-risk text |
+| `all_filtered_text` | PriVTE video evidence plus the coarsened auxiliary text |
+
+## Labels and evaluation
+
+The four risk labels are ordinal in the order listed above.
+`insufficient_evidence` is reserved for model abstention and is not a fifth
+severity. The benchmark reports exact accuracy and macro-F1, together with
+ordinal MAE and RMSE on non-abstained predictions and prediction coverage.
+
+## Data construction
+
+The source cohort was collected in school-based field studies involving young
+participants in primary, middle, and high school settings in Beijing,
+Zhejiang, Inner Mongolia, and other regions. Participants completed an
+approximately 45-minute tablet-use session. PriVTE processes source video
+locally and emits ordered observable-behavior evidence with quality gates,
+relative stages, and evidence references. Auxiliary inputs are released only
+as coarse categories or risk-signal bins.
+
+Each participant contributes at most 12 videos selected uniformly over source
+order. Every selected file was required to be nonempty, parseable, contain a
+video stream of known duration, and provide at least four seconds of video.
+The selection protocol does not replace a failed selected file with a nearby
+file.
+
+## Public record design
+
+Public sample IDs (`MDURT_######`) are consistent across all three settings.
+The release records contain the complete model-facing evidence used by
+MDU-RiskBench, but omit redundant internal preprocessing/debug copies and
+operational provenance fields. `MANIFEST.json` reports row counts, byte sizes,
+and SHA-256 hashes for every release artifact.
+
+## Intended use
+
+The resource supports research on privacy-preserving behavioral evidence,
+text-only ordinal screening, evidence grounding, selective prediction, and
+comparison with direct-video systems. The targets are field-derived screening
+judgments rather than clinical diagnoses. Model outputs are intended for
+research analysis and human review rather than automated punitive decisions.
+
+## License and citation
+
+See `LICENSE_DATA.md` for the dataset terms and `CITATION.cff` for citation
+metadata. Software scripts are released under the accompanying code license;
+the data terms apply to MDU-RiskText and MDU-RiskBench records.

scripts/build_release.py

@@ -0,0 +1,839 @@
+#!/usr/bin/env python3
+"""Build the public MDU-RiskText and MDU-RiskBench Hugging Face bundle.
+
+The internal experiment JSONL files contain several redundant pipeline views.
+This builder publishes the complete model-facing evidence packages used by the
+benchmark, frozen labels and splits, while replacing internal participant IDs
+with stable public IDs.
+"""
+
+from __future__ import annotations
+
+import argparse
+import gzip
+import hashlib
+import io
+import json
+import re
+import shutil
+from collections import Counter
+from pathlib import Path
+from typing import Any, Iterable
+
+
+SETTINGS = ("video_only", "non_video_only", "all_filtered_text")
+SPLITS = ("train", "validation", "test")
+RISK_LEVELS = (
+    "no_observed_risk",
+    "mild_risk",
+    "moderate_risk",
+    "high_risk",
+)
+SETTING_ALIASES = {"all_privacy_filtered_text": "all_filtered_text"}
+BLOCKED_TEXT_PATTERNS = {
+    "developer_home": re.compile(r"/home/[A-Za-z0-9._-]+/"),
+    "mounted_drive": re.compile(r"/mnt/[A-Za-z]/"),
+    "windows_user": re.compile(r"[A-Za-z]:\\\\Users\\\\[^\\\\]+\\\\"),
+    "internal_evidence_id": re.compile(r"evidence_internal_[A-Za-z0-9_-]+"),
+    "internal_person_id": re.compile(r"\binternal_[A-Za-z0-9_-]+\b"),
+    "source_subset": re.compile(r"strict850|schemafix", re.I),
+    "spreadsheet": re.compile(r"\.xlsx?\b", re.I),
+}
+
+
+def compact_json(value: Any) -> str:
+    return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
+
+
+def sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def write_json(path: Path, value: Any) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(value, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+
+
+def write_text(path: Path, value: str) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(value.rstrip() + "\n", encoding="utf-8")
+
+
+class DeterministicGzipJsonlWriter:
+    def __init__(self, path: Path) -> None:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        self.raw = path.open("wb")
+        self.gz = gzip.GzipFile(filename="", mode="wb", fileobj=self.raw, mtime=0)
+        self.text = io.TextIOWrapper(self.gz, encoding="utf-8", newline="\n")
+
+    def write(self, value: Any) -> None:
+        self.text.write(compact_json(value) + "\n")
+
+    def close(self) -> None:
+        self.text.flush()
+        self.text.detach()
+        self.gz.close()
+        self.raw.close()
+
+    def __enter__(self) -> "DeterministicGzipJsonlWriter":
+        return self
+
+    def __exit__(self, *_: Any) -> None:
+        self.close()
+
+
+def iter_jsonl(path: Path) -> Iterable[dict[str, Any]]:
+    with path.open(encoding="utf-8") as handle:
+        for line_number, line in enumerate(handle, 1):
+            if not line.strip():
+                continue
+            value = json.loads(line)
+            if not isinstance(value, dict):
+                raise ValueError(f"{path}:{line_number}: expected a JSON object")
+            yield value
+
+
+def transform_strings(value: Any, old_id: str, public_id: str) -> Any:
+    if isinstance(value, dict):
+        return {
+            key: transform_strings(item, old_id, public_id)
+            for key, item in value.items()
+            if key not in {"internal_debug"}
+        }
+    if isinstance(value, list):
+        return [transform_strings(item, old_id, public_id) for item in value]
+    if isinstance(value, str):
+        value = value.replace(old_id, public_id)
+        return SETTING_ALIASES.get(value, value)
+    return value
+
+
+def public_target_label(source: dict[str, Any]) -> dict[str, Any]:
+    risk_level = source.get("risk_level")
+    if risk_level not in RISK_LEVELS:
+        raise ValueError(f"unexpected target label: {risk_level!r}")
+    counts = source.get("risk_label_counts", {})
+    if not isinstance(counts, dict):
+        counts = {}
+    return {
+        "risk_level": risk_level,
+        "available": True,
+        "aggregation_method": "majority_vote_over_non_insufficient_windows",
+        "window_label_counts": {
+            str(key): int(value)
+            for key, value in sorted(counts.items())
+            if isinstance(value, (int, float))
+        },
+    }
+
+
+def build_record(
+    source: dict[str, Any], setting: str, public_id: str
+) -> dict[str, Any]:
+    old_id = source.get("sample_id")
+    if not isinstance(old_id, str):
+        raise ValueError("record lacks sample_id")
+    split = source.get("split")
+    if split not in SPLITS:
+        raise ValueError(f"unexpected split: {split!r}")
+    package_text = source.get("text_evidence")
+    if not isinstance(package_text, str):
+        raise ValueError(f"{old_id}: text_evidence is not a string")
+    package = json.loads(package_text)
+    package = transform_strings(package, old_id, public_id)
+    package["sample_id"] = public_id
+    package["benchmark_setting"] = setting
+    return {
+        "schema_version": "mdu_risktext.participant_record.v1",
+        "sample_id": public_id,
+        "split": split,
+        "target_label": public_target_label(source.get("target_label", {})),
+        "benchmark_setting": setting,
+        "llm_evidence_package": package,
+        "text_evidence": compact_json(package),
+    }
+
+
+def collect_sources(paths: dict[str, Path]) -> dict[str, dict[str, dict[str, Any]]]:
+    records: dict[str, dict[str, dict[str, Any]]] = {}
+    for setting, path in paths.items():
+        setting_rows: dict[str, dict[str, Any]] = {}
+        for row in iter_jsonl(path):
+            sample_id = row.get("sample_id")
+            if not isinstance(sample_id, str):
+                raise ValueError(f"{path}: record lacks a string sample_id")
+            if sample_id in setting_rows:
+                raise ValueError(f"{path}: duplicate sample_id {sample_id}")
+            setting_rows[sample_id] = row
+        records[setting] = setting_rows
+    base_ids = set(records["video_only"])
+    if len(base_ids) != 850:
+        raise ValueError(f"expected 850 participants, found {len(base_ids)}")
+    for setting in SETTINGS:
+        if set(records[setting]) != base_ids:
+            raise ValueError(f"participant mismatch for {setting}")
+        for sample_id in base_ids:
+            base = records["video_only"][sample_id]
+            other = records[setting][sample_id]
+            if base.get("split") != other.get("split"):
+                raise ValueError(f"split mismatch for {sample_id} in {setting}")
+            if base.get("target_label", {}).get("risk_level") != other.get(
+                "target_label", {}
+            ).get("risk_level"):
+                raise ValueError(f"label mismatch for {sample_id} in {setting}")
+    return records
+
+
+def make_public_id_map(internal_ids: Iterable[str]) -> dict[str, str]:
+    return {
+        internal_id: f"MDURT_{index:06d}"
+        for index, internal_id in enumerate(sorted(internal_ids), 1)
+    }
+
+
+def dataset_card() -> str:
+    return """---
+pretty_name: MDU-RiskText and MDU-RiskBench
+language:
+- en
+- zh
+license: other
+task_categories:
+- text-classification
+tags:
+- privacy
+- video-to-text
+- ordinal-classification
+- youth-digital-use
+- evidence-grounding
+configs:
+- config_name: video_only
+  data_files:
+  - split: train
+    path: MDU-RiskText/video_only/train.jsonl.gz
+  - split: validation
+    path: MDU-RiskText/video_only/validation.jsonl.gz
+  - split: test
+    path: MDU-RiskText/video_only/test.jsonl.gz
+- config_name: non_video_only
+  data_files:
+  - split: train
+    path: MDU-RiskText/non_video_only/train.jsonl.gz
+  - split: validation
+    path: MDU-RiskText/non_video_only/validation.jsonl.gz
+  - split: test
+    path: MDU-RiskText/non_video_only/test.jsonl.gz
+- config_name: all_filtered_text
+  data_files:
+  - split: train
+    path: MDU-RiskText/all_filtered_text/train.jsonl.gz
+  - split: validation
+    path: MDU-RiskText/all_filtered_text/validation.jsonl.gz
+  - split: test
+    path: MDU-RiskText/all_filtered_text/test.jsonl.gz
+---
+
+# MDU-RiskText and MDU-RiskBench
+
+This repository contains the public 850-participant release associated with
+PriVTE: Privacy-Preserving Video-to-Text Evidence Encoding for Youth Digital
+Use Risk Screening.
+
+## Data products
+
+- **MDU-RiskText** contains participant-level, privacy-filtered textual
+  evidence, the frozen ordinal target, and participant-disjoint split for all
+  850 participants.
+- **MDU-RiskBench** defines the task, label order, three headline evidence
+  settings, participant index, evaluation protocol, and reference metric code.
+
+The frozen cohort contains 9,831 selected source videos. It is split into 593
+train, 131 validation, and 126 test participants. Target counts are 226
+`no_observed_risk`, 432 `mild_risk`, 172 `moderate_risk`, and 20 `high_risk`.
+
+## Load with Hugging Face Datasets
+
+```python
+from datasets import load_dataset
+
+video = load_dataset("Herrieson/MDU-RiskText", "video_only")
+non_video = load_dataset("Herrieson/MDU-RiskText", "non_video_only")
+combined = load_dataset("Herrieson/MDU-RiskText", "all_filtered_text")
+```
+
+Replace `Herrieson/MDU-RiskText` if the final dataset repository uses a
+different owner or name. Each row includes `sample_id`, `split`,
+`target_label`, `benchmark_setting`, `llm_evidence_package`, and
+`text_evidence`. The last field is the compact JSON string supplied to the
+text-only model runners.
+
+## Headline settings
+
+| Configuration | Model-facing evidence |
+|---|---|
+| `video_only` | PriVTE evidence derived from locally processed video |
+| `non_video_only` | Coarsened app-category, heart-rate-bin, and questionnaire-risk text |
+| `all_filtered_text` | PriVTE video evidence plus the coarsened auxiliary text |
+
+## Labels and evaluation
+
+The four risk labels are ordinal in the order listed above.
+`insufficient_evidence` is reserved for model abstention and is not a fifth
+severity. The benchmark reports exact accuracy and macro-F1, together with
+ordinal MAE and RMSE on non-abstained predictions and prediction coverage.
+
+## Data construction
+
+The source cohort was collected in school-based field studies involving young
+participants in primary, middle, and high school settings in Beijing,
+Zhejiang, Inner Mongolia, and other regions. Participants completed an
+approximately 45-minute tablet-use session. PriVTE processes source video
+locally and emits ordered observable-behavior evidence with quality gates,
+relative stages, and evidence references. Auxiliary inputs are released only
+as coarse categories or risk-signal bins.
+
+Each participant contributes at most 12 videos selected uniformly over source
+order. Every selected file was required to be nonempty, parseable, contain a
+video stream of known duration, and provide at least four seconds of video.
+The selection protocol does not replace a failed selected file with a nearby
+file.
+
+## Public record design
+
+Public sample IDs (`MDURT_######`) are consistent across all three settings.
+The release records contain the complete model-facing evidence used by
+MDU-RiskBench, but omit redundant internal preprocessing/debug copies and
+operational provenance fields. `MANIFEST.json` reports row counts, byte sizes,
+and SHA-256 hashes for every release artifact.
+
+## Intended use
+
+The resource supports research on privacy-preserving behavioral evidence,
+text-only ordinal screening, evidence grounding, selective prediction, and
+comparison with direct-video systems. The targets are field-derived screening
+judgments rather than clinical diagnoses. Model outputs are intended for
+research analysis and human review rather than automated punitive decisions.
+
+## License and citation
+
+See `LICENSE_DATA.md` for the dataset terms and `CITATION.cff` for citation
+metadata. Software scripts are released under the accompanying code license;
+the data terms apply to MDU-RiskText and MDU-RiskBench records.
+"""
+
+
+def mdu_risktext_readme() -> str:
+    return """# MDU-RiskText
+
+MDU-RiskText contains all 850 participant-level textual evidence records for
+the three headline evidence settings. Each setting is split into train,
+validation, and test gzip-compressed JSONL files.
+
+Every row has the following fields:
+
+- `schema_version`: public participant-record schema version;
+- `sample_id`: stable public participant ID shared across settings;
+- `split`: `train`, `validation`, or `test`;
+- `target_label`: ordinal risk label and aggregated window-label counts;
+- `benchmark_setting`: evidence configuration name;
+- `llm_evidence_package`: structured model-facing JSON object;
+- `text_evidence`: compact serialization of that same package.
+
+The public files preserve the complete model-facing inputs. They intentionally
+exclude redundant internal feature blocks, source paths, source filenames,
+internal participant IDs, and preprocessing debug views that were not supplied
+to benchmark models.
+"""
+
+
+def benchmark_readme() -> str:
+    return """# MDU-RiskBench
+
+MDU-RiskBench is the benchmark definition paired with MDU-RiskText. It
+contains:
+
+- `benchmark.json`: cohort, labels, settings, and metric definitions;
+- `participants.jsonl.gz`: the frozen 850-participant index;
+- `prediction.schema.json`: submission record contract;
+- `reference_results/`: aggregate result tables when available;
+- `../scripts/evaluate_predictions.py`: reference evaluator;
+- `../scripts/verify_release.py`: integrity and alignment validator.
+
+A prediction JSONL contains one object per participant:
+
+```json
+{"sample_id":"MDURT_000001","risk_level":"mild_risk"}
+```
+
+Models may additionally output `confidence`, evidence references, rationale,
+and review flags; the reference evaluator uses `sample_id` and `risk_level`.
+"""
+
+
+def data_license() -> str:
+    return """# MDU-RiskText / MDU-RiskBench Data Terms
+
+Copyright (c) 2026 PriVTE contributors.
+
+Permission is granted to use, reproduce, and redistribute the released
+MDU-RiskText and MDU-RiskBench files for research, education, evaluation, and
+non-commercial development, provided that users:
+
+1. cite the dataset and PriVTE paper;
+2. do not attempt to identify or contact participants or institutions;
+3. do not combine the records with external data for re-identification;
+4. do not use the data or derived systems for automated punishment,
+   disciplinary action, eligibility denial, or individual surveillance; and
+5. preserve these terms and the dataset attribution in redistributions.
+
+The data are provided as-is, without warranty. These terms cover the dataset
+records and benchmark metadata; separately released source code may use a
+different software license.
+"""
+
+
+def verify_script() -> str:
+    return r'''#!/usr/bin/env python3
+"""Verify MDU-RiskText/MDU-RiskBench row alignment and file hashes."""
+
+from __future__ import annotations
+
+import gzip
+import hashlib
+import json
+from collections import Counter
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+SETTINGS = ("video_only", "non_video_only", "all_filtered_text")
+SPLITS = ("train", "validation", "test")
+
+
+def digest(path: Path) -> str:
+    value = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            value.update(chunk)
+    return value.hexdigest()
+
+
+def rows(path: Path):
+    with gzip.open(path, "rt", encoding="utf-8") as handle:
+        for line in handle:
+            if line.strip():
+                yield json.loads(line)
+
+
+def main() -> None:
+    manifest = json.loads((ROOT / "MANIFEST.json").read_text(encoding="utf-8"))
+    for entry in manifest["files"]:
+        path = ROOT / entry["path"]
+        if path.stat().st_size != entry["bytes"]:
+            raise SystemExit(f"size mismatch: {entry['path']}")
+        if digest(path) != entry["sha256"]:
+            raise SystemExit(f"hash mismatch: {entry['path']}")
+
+    identities = {}
+    for setting in SETTINGS:
+        current = {}
+        for split in SPLITS:
+            path = ROOT / "MDU-RiskText" / setting / f"{split}.jsonl.gz"
+            for row in rows(path):
+                if row["split"] != split or row["benchmark_setting"] != setting:
+                    raise SystemExit(f"metadata mismatch: {path}")
+                package = row["llm_evidence_package"]
+                if package["sample_id"] != row["sample_id"]:
+                    raise SystemExit(f"package ID mismatch: {row['sample_id']}")
+                if json.loads(row["text_evidence"]) != package:
+                    raise SystemExit(f"text package mismatch: {row['sample_id']}")
+                current[row["sample_id"]] = (
+                    split,
+                    row["target_label"]["risk_level"],
+                )
+        if len(current) != 850:
+            raise SystemExit(f"{setting}: expected 850 records, got {len(current)}")
+        if identities and current != identities:
+            raise SystemExit(f"cross-setting identity mismatch: {setting}")
+        identities = current
+
+    split_counts = Counter(split for split, _ in identities.values())
+    label_counts = Counter(label for _, label in identities.values())
+    expected_splits = {"train": 593, "validation": 131, "test": 126}
+    expected_labels = {
+        "no_observed_risk": 226,
+        "mild_risk": 432,
+        "moderate_risk": 172,
+        "high_risk": 20,
+    }
+    if dict(split_counts) != expected_splits:
+        raise SystemExit(f"split counts differ: {dict(split_counts)}")
+    if dict(label_counts) != expected_labels:
+        raise SystemExit(f"label counts differ: {dict(label_counts)}")
+    print("Verified 850 aligned participants across 3 settings and 9 data files.")
+
+
+if __name__ == "__main__":
+    main()
+'''
+
+
+def evaluator_script() -> str:
+    return r'''#!/usr/bin/env python3
+"""Evaluate MDU-RiskBench participant-level prediction JSONL."""
+
+from __future__ import annotations
+
+import argparse
+import gzip
+import json
+import math
+from collections import Counter
+from pathlib import Path
+
+ORDER = {
+    "no_observed_risk": 0,
+    "mild_risk": 1,
+    "moderate_risk": 2,
+    "high_risk": 3,
+}
+ABSTAIN = "insufficient_evidence"
+
+
+def read_jsonl(path: Path):
+    opener = gzip.open if path.suffix == ".gz" else open
+    with opener(path, "rt", encoding="utf-8") as handle:
+        for line in handle:
+            if line.strip():
+                yield json.loads(line)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--gold", type=Path, required=True)
+    parser.add_argument("--predictions", type=Path, required=True)
+    parser.add_argument("--output", type=Path)
+    args = parser.parse_args()
+
+    gold = {
+        row["sample_id"]: row["target_label"]["risk_level"]
+        for row in read_jsonl(args.gold)
+    }
+    pred = {row["sample_id"]: row["risk_level"] for row in read_jsonl(args.predictions)}
+    unknown = sorted(set(pred) - set(gold))
+    if unknown:
+        raise SystemExit(f"unknown prediction IDs: {unknown[:5]}")
+
+    labels = list(ORDER)
+    total = len(gold)
+    covered = [(gold[sid], pred.get(sid)) for sid in gold if pred.get(sid) in ORDER]
+    abstained = total - len(covered)
+    exact = sum(actual == predicted for actual, predicted in covered)
+    distances = [abs(ORDER[actual] - ORDER[predicted]) for actual, predicted in covered]
+    squared = [value * value for value in distances]
+    f1_values = []
+    for label in labels:
+        tp = sum(actual == label and predicted == label for actual, predicted in covered)
+        fp = sum(actual != label and predicted == label for actual, predicted in covered)
+        fn = sum(actual == label and predicted != label for actual, predicted in covered)
+        precision = tp / (tp + fp) if tp + fp else 0.0
+        recall = tp / (tp + fn) if tp + fn else 0.0
+        f1_values.append(
+            2 * precision * recall / (precision + recall) if precision + recall else 0.0
+        )
+
+    n = len(covered)
+    report = {
+        "gold_records": total,
+        "prediction_records": len(pred),
+        "covered_records": n,
+        "abstained_or_missing_records": abstained,
+        "coverage": n / total if total else 0.0,
+        "selective_accuracy": exact / n if n else None,
+        "selective_macro_f1": sum(f1_values) / len(f1_values) if n else None,
+        "ordinal_mae": sum(distances) / n if n else None,
+        "ordinal_rmse": math.sqrt(sum(squared) / n) if n else None,
+        "prediction_distribution": dict(sorted(Counter(pred.values()).items())),
+    }
+    rendered = json.dumps(report, indent=2) + "\n"
+    if args.output:
+        args.output.write_text(rendered, encoding="utf-8")
+    print(rendered, end="")
+
+
+if __name__ == "__main__":
+    main()
+'''
+
+
+def prediction_schema() -> dict[str, Any]:
+    return {
+        "$schema": "https://json-schema.org/draft/2020-12/schema",
+        "title": "MDU-RiskBench prediction record",
+        "type": "object",
+        "required": ["sample_id", "risk_level"],
+        "properties": {
+            "sample_id": {"type": "string", "pattern": "^MDURT_[0-9]{6}$"},
+            "risk_level": {
+                "enum": [*RISK_LEVELS, "insufficient_evidence"]
+            },
+            "confidence": {"enum": ["low", "medium", "high"]},
+            "evidence_used": {"type": "array", "items": {"type": "string"}},
+            "needs_human_review": {"type": "boolean"},
+        },
+        "additionalProperties": True,
+    }
+
+
+def record_schema() -> dict[str, Any]:
+    return {
+        "$schema": "https://json-schema.org/draft/2020-12/schema",
+        "title": "MDU-RiskText participant record",
+        "type": "object",
+        "required": [
+            "schema_version",
+            "sample_id",
+            "split",
+            "target_label",
+            "benchmark_setting",
+            "llm_evidence_package",
+            "text_evidence",
+        ],
+        "properties": {
+            "schema_version": {"const": "mdu_risktext.participant_record.v1"},
+            "sample_id": {"type": "string", "pattern": "^MDURT_[0-9]{6}$"},
+            "split": {"enum": list(SPLITS)},
+            "benchmark_setting": {"enum": list(SETTINGS)},
+            "target_label": {
+                "type": "object",
+                "required": ["risk_level", "available"],
+                "properties": {"risk_level": {"enum": list(RISK_LEVELS)}},
+            },
+            "llm_evidence_package": {"type": "object"},
+            "text_evidence": {"type": "string"},
+        },
+    }
+
+
+def benchmark_definition() -> dict[str, Any]:
+    return {
+        "schema_version": "mdu_riskbench.v1",
+        "name": "MDU-RiskBench",
+        "paired_dataset": "MDU-RiskText v1",
+        "task": "Text-only Youth Digital Use Risk Screening",
+        "participant_count": 850,
+        "selected_source_video_count": 9831,
+        "participant_disjoint_splits": True,
+        "split_counts": {"train": 593, "validation": 131, "test": 126},
+        "ordinal_labels": list(RISK_LEVELS),
+        "abstention_label": "insufficient_evidence",
+        "label_counts": {
+            "no_observed_risk": 226,
+            "mild_risk": 432,
+            "moderate_risk": 172,
+            "high_risk": 20,
+        },
+        "headline_settings": {
+            "video_only": "PriVTE privacy-filtered video-to-text evidence",
+            "non_video_only": (
+                "coarse app-category, heart-rate-bin, and questionnaire-risk text"
+            ),
+            "all_filtered_text": "PriVTE evidence plus coarse auxiliary text",
+        },
+        "primary_metrics": [
+            "accuracy",
+            "macro_f1",
+            "ordinal_mae",
+            "ordinal_rmse",
+            "coverage",
+        ],
+        "ordinal_metric_policy": (
+            "MAE and RMSE are computed on predictions in the four ordinal labels; "
+            "insufficient_evidence is reported through coverage."
+        ),
+        "source_video_selection": {
+            "maximum_selected_per_participant": 12,
+            "selection": "uniform_over_ordered_source_inventory",
+            "minimum_video_stream_duration_seconds": 4.0,
+            "all_selected_files_must_pass_technical_validation": True,
+            "replacement_after_selected_file_failure": False,
+        },
+    }
+
+
+def citation_cff() -> str:
+    return """cff-version: 1.2.0
+message: "If you use MDU-RiskText or MDU-RiskBench, please cite this dataset and the PriVTE paper."
+title: "MDU-RiskText and MDU-RiskBench"
+type: dataset
+authors:
+  - name: "PriVTE Authors"
+version: "1.0.0"
+date-released: "2026-07-28"
+repository-code: "https://github.com/Herrieson/privte-public"
+"""
+
+
+def write_base_files(output: Path) -> None:
+    write_text(output / "README.md", dataset_card())
+    write_text(output / "LICENSE_DATA.md", data_license())
+    write_text(output / "CITATION.cff", citation_cff())
+    write_text(output / "MDU-RiskText" / "README.md", mdu_risktext_readme())
+    write_text(output / "MDU-RiskBench" / "README.md", benchmark_readme())
+    write_json(output / "MDU-RiskText" / "record.schema.json", record_schema())
+    write_json(output / "MDU-RiskBench" / "benchmark.json", benchmark_definition())
+    write_json(
+        output / "MDU-RiskBench" / "prediction.schema.json", prediction_schema()
+    )
+    write_text(output / "scripts" / "verify_release.py", verify_script())
+    write_text(output / "scripts" / "evaluate_predictions.py", evaluator_script())
+    shutil.copy2(Path(__file__).resolve(), output / "scripts" / "build_release.py")
+
+
+def copy_reference_results(source: Path | None, output: Path) -> None:
+    if source is None or not source.exists():
+        return
+    destination = output / "MDU-RiskBench" / "reference_results"
+    destination.mkdir(parents=True, exist_ok=True)
+    for name in (
+        "trained_video_only_baselines.csv",
+        "trained_video_only_baselines.json",
+        "llm_full_matrix.csv",
+        "llm_full_matrix.json",
+        "llm_setting_means.csv",
+        "llm_setting_means.json",
+        "direct_video_comparison.csv",
+        "direct_video_comparison.json",
+    ):
+        candidate = source / name
+        if candidate.exists():
+            shutil.copy2(candidate, destination / name)
+
+
+def audit_text(value: Any, context: str) -> None:
+    rendered = compact_json(value)
+    for name, pattern in BLOCKED_TEXT_PATTERNS.items():
+        match = pattern.search(rendered)
+        if match:
+            raise ValueError(f"{context}: blocked {name}: {match.group(0)!r}")
+
+
+def build(args: argparse.Namespace) -> None:
+    output = args.output.resolve()
+    if output.exists():
+        if not args.overwrite:
+            raise SystemExit(f"output exists; pass --overwrite: {output}")
+        shutil.rmtree(output)
+    output.mkdir(parents=True)
+
+    paths = {
+        "video_only": args.video_only.resolve(),
+        "non_video_only": args.non_video_only.resolve(),
+        "all_filtered_text": args.all_filtered_text.resolve(),
+    }
+    records = collect_sources(paths)
+    public_ids = make_public_id_map(records["video_only"])
+    writers = {
+        (setting, split): DeterministicGzipJsonlWriter(
+            output / "MDU-RiskText" / setting / f"{split}.jsonl.gz"
+        )
+        for setting in SETTINGS
+        for split in SPLITS
+    }
+    participant_writer = DeterministicGzipJsonlWriter(
+        output / "MDU-RiskBench" / "participants.jsonl.gz"
+    )
+    row_counts: Counter[tuple[str, str]] = Counter()
+    split_counts: Counter[str] = Counter()
+    label_counts: Counter[str] = Counter()
+    try:
+        for internal_id in sorted(public_ids):
+            public_id = public_ids[internal_id]
+            base = records["video_only"][internal_id]
+            split = base["split"]
+            target = public_target_label(base["target_label"])
+            participant_writer.write(
+                {
+                    "sample_id": public_id,
+                    "split": split,
+                    "target_label": target,
+                }
+            )
+            split_counts[split] += 1
+            label_counts[target["risk_level"]] += 1
+            for setting in SETTINGS:
+                record = build_record(records[setting][internal_id], setting, public_id)
+                audit_text(record, f"{setting}/{public_id}")
+                writers[(setting, split)].write(record)
+                row_counts[(setting, split)] += 1
+    finally:
+        participant_writer.close()
+        for writer in writers.values():
+            writer.close()
+
+    expected_splits = {"train": 593, "validation": 131, "test": 126}
+    expected_labels = {
+        "no_observed_risk": 226,
+        "mild_risk": 432,
+        "moderate_risk": 172,
+        "high_risk": 20,
+    }
+    if dict(split_counts) != expected_splits:
+        raise ValueError(f"unexpected split counts: {dict(split_counts)}")
+    if dict(label_counts) != expected_labels:
+        raise ValueError(f"unexpected label counts: {dict(label_counts)}")
+
+    write_base_files(output)
+    copy_reference_results(args.reference_results, output)
+
+    files = []
+    for path in sorted(output.rglob("*")):
+        if not path.is_file() or path.name == "MANIFEST.json":
+            continue
+        relative = path.relative_to(output).as_posix()
+        entry: dict[str, Any] = {
+            "path": relative,
+            "bytes": path.stat().st_size,
+            "sha256": sha256(path),
+        }
+        if path.name.endswith(".jsonl.gz"):
+            if relative == "MDU-RiskBench/participants.jsonl.gz":
+                entry["rows"] = 850
+            else:
+                parts = path.relative_to(output / "MDU-RiskText").parts
+                setting = parts[0]
+                split = path.name.removesuffix(".jsonl.gz")
+                entry["rows"] = row_counts[(setting, split)]
+        files.append(entry)
+    manifest = {
+        "schema_version": "mdu_risk_huggingface_release_manifest.v1",
+        "release_version": "1.0.0",
+        "participant_count": 850,
+        "selected_source_video_count": 9831,
+        "settings": list(SETTINGS),
+        "split_counts": expected_splits,
+        "label_counts": expected_labels,
+        "files": files,
+    }
+    write_json(output / "MANIFEST.json", manifest)
+    print(f"Built Hugging Face release at {output}")
+    print(f"Participants: {sum(split_counts.values())}")
+    print(f"Compressed bundle bytes: {sum(p.stat().st_size for p in output.rglob('*') if p.is_file())}")
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--video-only", type=Path, required=True)
+    parser.add_argument("--non-video-only", type=Path, required=True)
+    parser.add_argument("--all-filtered-text", type=Path, required=True)
+    parser.add_argument("--reference-results", type=Path)
+    parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument("--overwrite", action="store_true")
+    return parser.parse_args()
+
+
+if __name__ == "__main__":
+    build(parse_args())

scripts/evaluate_predictions.py

@@ -0,0 +1,84 @@
+#!/usr/bin/env python3
+"""Evaluate MDU-RiskBench participant-level prediction JSONL."""
+
+from __future__ import annotations
+
+import argparse
+import gzip
+import json
+import math
+from collections import Counter
+from pathlib import Path
+
+ORDER = {
+    "no_observed_risk": 0,
+    "mild_risk": 1,
+    "moderate_risk": 2,
+    "high_risk": 3,
+}
+ABSTAIN = "insufficient_evidence"
+
+
+def read_jsonl(path: Path):
+    opener = gzip.open if path.suffix == ".gz" else open
+    with opener(path, "rt", encoding="utf-8") as handle:
+        for line in handle:
+            if line.strip():
+                yield json.loads(line)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--gold", type=Path, required=True)
+    parser.add_argument("--predictions", type=Path, required=True)
+    parser.add_argument("--output", type=Path)
+    args = parser.parse_args()
+
+    gold = {
+        row["sample_id"]: row["target_label"]["risk_level"]
+        for row in read_jsonl(args.gold)
+    }
+    pred = {row["sample_id"]: row["risk_level"] for row in read_jsonl(args.predictions)}
+    unknown = sorted(set(pred) - set(gold))
+    if unknown:
+        raise SystemExit(f"unknown prediction IDs: {unknown[:5]}")
+
+    labels = list(ORDER)
+    total = len(gold)
+    covered = [(gold[sid], pred.get(sid)) for sid in gold if pred.get(sid) in ORDER]
+    abstained = total - len(covered)
+    exact = sum(actual == predicted for actual, predicted in covered)
+    distances = [abs(ORDER[actual] - ORDER[predicted]) for actual, predicted in covered]
+    squared = [value * value for value in distances]
+    f1_values = []
+    for label in labels:
+        tp = sum(actual == label and predicted == label for actual, predicted in covered)
+        fp = sum(actual != label and predicted == label for actual, predicted in covered)
+        fn = sum(actual == label and predicted != label for actual, predicted in covered)
+        precision = tp / (tp + fp) if tp + fp else 0.0
+        recall = tp / (tp + fn) if tp + fn else 0.0
+        f1_values.append(
+            2 * precision * recall / (precision + recall) if precision + recall else 0.0
+        )
+
+    n = len(covered)
+    report = {
+        "gold_records": total,
+        "prediction_records": len(pred),
+        "covered_records": n,
+        "abstained_or_missing_records": abstained,
+        "coverage": n / total if total else 0.0,
+        "selective_accuracy": exact / n if n else None,
+        "selective_macro_f1": sum(f1_values) / len(f1_values) if n else None,
+        "ordinal_mae": sum(distances) / n if n else None,
+        "ordinal_rmse": math.sqrt(sum(squared) / n) if n else None,
+        "prediction_distribution": dict(sorted(Counter(pred.values()).items())),
+    }
+    rendered = json.dumps(report, indent=2) + "\n"
+    if args.output:
+        args.output.write_text(rendered, encoding="utf-8")
+    print(rendered, end="")
+
+
+if __name__ == "__main__":
+    main()

scripts/verify_release.py

@@ -0,0 +1,81 @@
+#!/usr/bin/env python3
+"""Verify MDU-RiskText/MDU-RiskBench row alignment and file hashes."""
+
+from __future__ import annotations
+
+import gzip
+import hashlib
+import json
+from collections import Counter
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+SETTINGS = ("video_only", "non_video_only", "all_filtered_text")
+SPLITS = ("train", "validation", "test")
+
+
+def digest(path: Path) -> str:
+    value = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            value.update(chunk)
+    return value.hexdigest()
+
+
+def rows(path: Path):
+    with gzip.open(path, "rt", encoding="utf-8") as handle:
+        for line in handle:
+            if line.strip():
+                yield json.loads(line)
+
+
+def main() -> None:
+    manifest = json.loads((ROOT / "MANIFEST.json").read_text(encoding="utf-8"))
+    for entry in manifest["files"]:
+        path = ROOT / entry["path"]
+        if path.stat().st_size != entry["bytes"]:
+            raise SystemExit(f"size mismatch: {entry['path']}")
+        if digest(path) != entry["sha256"]:
+            raise SystemExit(f"hash mismatch: {entry['path']}")
+
+    identities = {}
+    for setting in SETTINGS:
+        current = {}
+        for split in SPLITS:
+            path = ROOT / "MDU-RiskText" / setting / f"{split}.jsonl.gz"
+            for row in rows(path):
+                if row["split"] != split or row["benchmark_setting"] != setting:
+                    raise SystemExit(f"metadata mismatch: {path}")
+                package = row["llm_evidence_package"]
+                if package["sample_id"] != row["sample_id"]:
+                    raise SystemExit(f"package ID mismatch: {row['sample_id']}")
+                if json.loads(row["text_evidence"]) != package:
+                    raise SystemExit(f"text package mismatch: {row['sample_id']}")
+                current[row["sample_id"]] = (
+                    split,
+                    row["target_label"]["risk_level"],
+                )
+        if len(current) != 850:
+            raise SystemExit(f"{setting}: expected 850 records, got {len(current)}")
+        if identities and current != identities:
+            raise SystemExit(f"cross-setting identity mismatch: {setting}")
+        identities = current
+
+    split_counts = Counter(split for split, _ in identities.values())
+    label_counts = Counter(label for _, label in identities.values())
+    expected_splits = {"train": 593, "validation": 131, "test": 126}
+    expected_labels = {
+        "no_observed_risk": 226,
+        "mild_risk": 432,
+        "moderate_risk": 172,
+        "high_risk": 20,
+    }
+    if dict(split_counts) != expected_splits:
+        raise SystemExit(f"split counts differ: {dict(split_counts)}")
+    if dict(label_counts) != expected_labels:
+        raise SystemExit(f"label counts differ: {dict(label_counts)}")
+    print("Verified 850 aligned participants across 3 settings and 9 data files.")
+
+
+if __name__ == "__main__":
+    main()