ksasse/government-ai-detection

Government AI Text Detection — Results

Completed AI-detection output from the government-ai pipeline, which measures the prevalence of AI-generated/edited text across four kinds of US government media, 2000–2026:

source	what
bills	Congressional bill text (as-introduced versions), from govinfo
speeches	Floor speeches + Extensions of Remarks from the Congressional Record
comments	Public comments on regulations.gov (via the Mirrulations mirror)
documents	The Federal Register rules/notices those comments respond to

Detection uses Pangram EditLens (arXiv:2510.03154), a regression model quantifying how much of a document was written or edited by an LLM. Years 2000–2021 predate LLM availability, so they serve as each source's false-positive baseline; the signal of interest is the post-2022 rise above that baseline.

Backed by plain Parquet files — one named split per source, no config argument needed:

from datasets import load_dataset

bills              = load_dataset("ksasse/government-ai-detection", split="bills")
speeches           = load_dataset("ksasse/government-ai-detection", split="speeches")
comments           = load_dataset("ksasse/government-ai-detection", split="comments")
documents          = load_dataset("ksasse/government-ai-detection", split="documents")
stance             = load_dataset("ksasse/government-ai-detection", split="stance")
robotic_rulemaking = load_dataset("ksasse/government-ai-detection", split="robotic_rulemaking")

Requires access to this private repo (hf auth login first).

All six splits share one wide column schema (the union of every source's columns) so they can live under a single datasets config — a bills row has null in chamber/stance/etc., a stance row has null in congress/n_sent/etc. See the per-source column list below.

Or, without the datasets library, read the underlying Parquet directly with pandas — this gives you only that source's actual columns, no padded nulls:

import pandas as pd
from huggingface_hub import hf_hub_download, list_repo_files

repo = "ksasse/government-ai-detection"
files = [f for f in list_repo_files(repo, repo_type="dataset") if f.startswith("scores_comments_")]
comments = pd.concat(
    pd.read_parquet(hf_hub_download(repo, f, repo_type="dataset")) for f in files
)

Or query straight off the Hub with no download step (needs duckdb with an HF_TOKEN env var set, since this repo is private):

import duckdb
duckdb.sql("""
    SELECT year, avg(ai_score_mean) FROM 'hf://datasets/ksasse/government-ai-detection/scores_comments_*.parquet'
    GROUP BY year ORDER BY year
""")

Layout

Files mirror the pipeline's data/results/ directory. Each source's scores are split across several scores_{source}_{run-timestamp}_{job-id}.part{NNN}.parquet shards (one per detection job/batch) — glob scores_{source}_*.parquet to get all of a source's rows.

scores_bills_*.parquet          one row per scored bill
scores_speeches_*.parquet       one row per scored floor speech
scores_comments_*.parquet       one row per scored regulations.gov comment
scores_documents_*.parquet      one row per scored Federal Register document
position_homogeneity/stance_*.parquet   LLM-judged support/oppose/other stance per scored comment
robotic_rulemaking/comment_text_features.parquet   per-comment structural/style features (sentence count, citations, boilerplate markers, etc.)

scores_*.parquet schema

One row per scored document. Columns present (non-null) depend on source when read via load_dataset — or are simply absent from the file when read directly as Parquet:

column	present in	meaning
id	all	source-specific document id (e.g. govinfo package id, docket-comment id)
source	all	bills / speeches / comments / documents
year	all	publication year
date	speeches, comments, documents	full date, where available
n_words	all	word count of the scored text
n_chunks	all	number of 512-token chunks the doc was split into
ai_score_mean	all	mean EditLens AI-edit score across chunks, in [0, 1]
ai_score_max	all	max chunk score — most-AI-like chunk in the document
p_label_{0..3}_mean	all	mean per-label softmax probabilities (model-dependent label set)
model	all	HF model id used for scoring, e.g. pangram/editlens_roberta-large
congress, bill_type, version	bills	Congress number, bill type (hr/s/...), version code (ih=as-introduced)
chamber, speaker	speeches	House/Senate/extensions; matched speaker name
agency, docket	comments, documents	regulations.gov agency acronym and docket id
dup_count, text_sha1, organization	comments	exact-duplicate collapse count, text hash, commenter org (if signed)
doc_type	documents	Federal Register document type (Rule / Proposed Rule / Notice)

Labeling thresholds (HUMAN / MIXED / AI-GENERATED) are applied downstream — not baked into these files. No raw document text is included, only scores and metadata.

position_homogeneity/stance_*.parquet schema

One row per scored comment that got an LLM stance judgment: id, docket, agency, year, ai_use (bool, from the detector), ai_score_mean, stance (support / oppose / other, toward the docket's rule).

robotic_rulemaking/comment_text_features.parquet schema

One row per comment: id, n_words_txt, n_sent, n_para, plus binary/ count style markers used to test the "Robotic rulemaking" claims — narrative, number, stat, citation, evidence, letterform, listitem, heading, llm_tell.

Caveats

Dense legal/legislative boilerplate is out-of-domain for any AI detector, so absolute flag rates on documents/bills are not directly trustworthy — a pre-2022 baseline subtraction is the defensible statistic. Regulations.gov comments also can't distinguish "commenter used AI" from "form-letter campaign generated by AI." Full discussion in the main repo's DATA.md §5 (Known gaps). This is a working-data snapshot — file sets may grow as the pipeline runs further. For code and methodology, see the government-ai repo.