heron-ai-security/topic-selfread-yahoo-pilot

Data card: Yahoo topic self-read pilot

Dataset format: topic-selfread-v2
Build: pilot in runs/yahoo_v1/
Status: ready (release_ready: true)
Built: 2026-09-30 (UTC)

This card describes the dataset that was built, not a proposal. It is a 200-question pilot. It is not the full Yahoo Answers train set.

Summary

Each example is one Yahoo Answers question, the topic Yahoo assigned to it, one activation from Qwen/Qwen2.5-7B-Instruct taken before the model generates any tokens, and that model's own Yes/No for the question:

Does the input discuss {that topic}?

The topic name is supplied in the question. The activation is computed from the Yahoo question alone. The topic question is asked in a separate generation, and that parsed Yes/No is the ground truth. Yahoo's best answer is not part of either prompt.

Item	Value
Inputs	200
Samples	200, one question per input
Ground truth	self-check: 83 Yes, 112 No, 5 unparsed
Topics	10, 20 inputs each
Splits	160 train / 20 validation / 20 test
Activation	one float32 vector of length 3,584 per input
Layer	19 of 28 decoder blocks
Position	last token of the activation prompt
Self-check decode	greedy, bfloat16, KV cache on

The saved vector is the residual stream after 19 blocks. That state is hidden_states[19], the input to decoder block 19, taken at the last token of the chat-formatted Yahoo question. The topic question is not in that prompt.

What this dataset is for

The intended use is to test whether a residual-stream state, saved before generation, is enough to answer a topic question about the text that produced that state. A later reader receives only:

• the activation vector
• the topic question
• the Yes/No target

The reader does not receive the original question text, the topic tag, or the best answer. The target it receives is the parsed self-check. Rows whose reply did not parse are omitted. Training has a balanced view that picks a topic, then Yes or No, then a matching training row, with equal probability at each step. In this pilot every train topic has both a Yes and a No self-check.

This build does not train that reader and does not attach a LoRA adapter.

Source

Field	Value
Dataset	community-datasets/yahoo_answers_topics
Revision	6652a1e7c94f7260a0bfd0c9092dd48e2d536ea1
Split used	train
Official test split	downloaded and checksummed, not used for examples
License on the Hugging Face copy	unknown

The classification set was built by Xiang Zhang, Junbo Zhao, and Yann LeCun from the Yahoo! Answers corpus of 2007-10-25. It is the benchmark in Character-level Convolutional Networks for Text Classification, Advances in Neural Information Processing Systems 28 (2015). The original Yahoo corpus was distributed for approved non-commercial research under a Yahoo data-sharing agreement.

The full Yahoo train split has 1,400,000 questions, 140,000 in each class. This pilot keeps 20 eligible questions per class from the start of the locked train parquet, in file order. Once a class has 20 kept questions, later questions of that class are skipped. The scan stopped when every class had reached 20.

Preparation count	Value
Rows actually filtered	201
Rows skipped after that class was full	228
Eligible inputs	200
Exclusions	1

The single exclusion is train row index 184. Its top detected language was German (confidence 0.283), so it was dropped. Short English questions are kept. The source is already an English corpus, and a high English-confidence cutoff would have removed ordinary questions such as “Who won the world series?”.

84 of the 200 inputs have an empty question_content. Their text is the title only.

This is a prefix of the train file with a per-topic cap. It is not a random sample of all 1,400,000 training questions. Seed 42 is used for split assignment. It does not reshuffle the source.

Source files and checksums are in runs/yahoo_v1/locks/source.json.

Topics and labels

Yahoo assigns each question one class. That class is the only topic asked. There is no second annotator and no human review. Each input is one sample.

Index	Id	Name in the question	Inputs	Train	Validation	Test
0	society_culture	Society & Culture	20	16	2	2
1	science_mathematics	Science & Mathematics	20	16	2	2
2	health	Health	20	16	2	2
3	education_reference	Education & Reference	20	16	2	2
4	computers_internet	Computers & Internet	20	16	2	2
5	sports	Sports	20	16	2	2
6	business_finance	Business & Finance	20	16	2	2
7	entertainment_music	Entertainment & Music	20	16	2	2
8	family_relationships	Family & Relationships	20	16	2	2
9	politics_government	Politics & Government	20	16	2	2

The question text is Does the input discuss {name}?, using the display name of that input's Yahoo class.

topic is the Yahoo class that was asked. It is not the training label.

The training label is the model's self-check, stored on the same input row:

Field	Meaning
self_check_raw	Text generated by Qwen
self_check_text	Yes, No, or empty when the reply did not start with either
self_check_label	1, 0, or null. Empty is not stored as No

Of the 200 generations, 83 parsed as Yes, 112 as No, and 5 did not parse. Those 5 replies start with an explanation rather than Yes or No. The reader omits them. Among the 195 parsed replies, 83 agree with the Yahoo class. Because every asked topic is the Yahoo class, agreement here means the model also answered Yes.

Topic	Yes	No	Unparsed
Society & Culture	5	14	1
Science & Mathematics	4	14	2
Health	15	5	0
Education & Reference	7	12	1
Computers & Internet	8	12	0
Sports	15	5	0
Business & Finance	7	13	0
Entertainment & Music	8	11	1
Family & Relationships	9	11	0
Politics & Government	5	15	0

How an input is built

The model reads the question, not the answer.

question_title.strip()

When question_content is nonempty:

question_title.strip() + "\n\n" + question_content.strip()

best_answer is stored aside in prepared/held_out_answers.jsonl so a leak check can see it. It is not copied into inputs.parquet, the rendered prompt, or the reader.

input_id is the SHA-256 of the exact constructed text. Duplicate detection would collapse whitespace-and-case matches and keep the earliest exact text, but this pilot has 200 distinct inputs and 200 groups. No near-duplicate group was formed. The grouping rules are still in the pipeline: exact normalized matches, identical question content of at least 50 words, and character 3–5-gram TF-IDF cosine of at least 0.90. Whole groups are assigned to one split.

Prompt length in this pilot, using the Qwen chat template below:

	Characters	Prompt tokens
Minimum	20	23
Median	89.5	39
Mean	121.8	48.0
Maximum	925	251

Inputs whose rendered prompt would exceed 1,024 tokens are excluded and are not truncated. None of the 200 kept inputs were over that limit.

A short kept example, train split, topic computers_internet, 23 tokens:

What is programming?

Its question is “Does the input discuss Computers & Internet?”.

Splits

Questions that come from one input stay in one split. Splits were assigned at group level with seed 42. Each group is represented by its positive topic. Groups were divided 80/20, and the 20% holdout was divided in half into validation and test.

Because every topic had 20 singleton groups, the split landed on:

Split	Inputs	Inputs per topic
Train	160	16
Validation	20	2
Test	20	2

Train self-checks are 67 Yes, 88 No, and 5 unparsed. Validation is 8 Yes and 12 No. Test is 8 Yes and 12 No. The balanced training sampler draws a topic uniformly, then Yes or No uniformly, then a training row whose parsed self-check matches. Empty cells raise an error instead of inventing examples. Every train topic in this pilot has both.

Activations

Field	Value
Model	Qwen/Qwen2.5-7B-Instruct
Model and tokenizer revision	a09a35458c702b33eeacc393d103063234e8bc28
Checkpoint dtype on disk	bfloat16
Computation	float16
Storage	float32
Device	MPS
Attention	eager
Batch size	1
Quantization	none
Adapter fingerprint	none
Generation	off
KV cache	off
Hidden size	3,584
Decoder layers	28
Captured index	19

completed_layers = ceil(2 * 28 / 3) = 19. The saved vector is the residual stream after 19 blocks, which is the input to decoder block 19 in zero-based indexing. A forward pre-hook on model.model.layers[19] matched hidden_states[19] on two short smoke inputs with maximum absolute difference 0.0. The backbone is run without vocabulary logits.

The prompt is the model’s native chat template with add_generation_prompt=True:

[
  {"role": "system", "content": "You are a helpful assistant."},
  {"role": "user", "content": "<constructed question text>"}
]

The saved position is the last token of that rendered prompt, including the assistant header. It is not the last word of the raw Yahoo text.

Each vector is detached, moved to CPU, cast to float32, and stored without normalization, pooling, or projection. All 200 vectors are in activations/shard-00000.safetensors with shape [200, 3584]. Row i of that matrix is the same row as row i of inputs.parquet. These vectors describe the unadapted checkpoint. A later LoRA run has to extract a new cache.

Observed extraction time on this machine: mean 0.35 seconds per vector, minimum 0.21, maximum 1.41. That is about 353 seconds per 1,000 new vectors, measured on this pilot only. After the smoke test, MPS had about 14.2 GB allocated.

The layer convention follows the residual-state insertion code in Heron-AI-Security/computation-aware at commit 47c4ea2b211fd6012a8f75beed7a66d91a947919.

Self-check

The ground truth is a second forward pass. It does not reuse the activation prompt. The user message is the Yahoo text, then Does the input discuss {name}?, then Answer Yes or No. Generation is greedy (do_sample false), at most 8 new tokens, on the same Qwen revision. Float16 decoding on MPS inserted ! between words, so those strings were not kept. The 200 stored replies were decoded in bfloat16 with the KV cache on. Mean time was 2.12 seconds per reply, minimum 0.58, maximum 4.56.

Each input row carries self_check_raw, self_check_text, and self_check_label.

Files

Path	Contents
inputs.parquet	200 questions, the asked topic question, and the self-check label
activations/shard-00000.safetensors	200 vectors, shape [200, 3584], float32, same row order as inputs.parquet

Package versions used for the real extraction: torch 2.10.0, transformers 5.3.0, tokenizers 0.22.2, datasets 3.6.0, safetensors 0.7.0, pyarrow 23.0.1, numpy 2.4.3, huggingface_hub 1.7.1.

Input row

input_id, text, question_title, question_content, topic, question,
sources_json, group_id, split, activation_key,
self_check_raw, self_check_text, self_check_label

topic is the Yahoo class. question is Does the input discuss {name}? for that class. self_check_text / self_check_label are the ground truth.

Reader example

from topic_selfread.loader import BalancedTrainingView, ReaderData
import random

train = ReaderData("runs/yahoo_v1", "train")
example = BalancedTrainingView(train).sample(random.Random(42))
# example["activation"], example["question"], example["target"]

Validation and test use ReaderData directly, so they keep the self-check frequencies of those splits. Unparsed rows are left out of every split.

People and content

The text was written by Yahoo Answers users in 2007. Topics include health, family, politics, and relationships. Questions can describe personal situations. This build does not add demographic labels, does not filter for sensitive content, and does not review the text by hand. The best answer, which may also contain personal or advice content, is held out of the model input and the reader.

Qwen’s weights are not in this dataset. They are loaded separately and are under the Apache License 2.0.

Validation

validate reported no structural errors and no coverage gaps.

Checked properties include:

• Every input id is the SHA-256 of its preserved text.
• Every input has exactly one positive topic, and that topic matches the source field.
• Every input has one question, for that Yahoo topic, in the same split.
• The question row's Yahoo label is Yes. The training label is the parsed self-check, and an unparsed reply stays null.
• No source record stored in the input table contains best_answer.
• Held-out answers of at least 40 characters do not appear in the preserved text or the rendered prompt.
• Groups do not cross splits.
• Every question reloads a finite float32 vector of shape [3584] with a nonzero norm.
• The smoke test ran on the real Qwen checkpoint, on MPS, in float16, with eager attention.

Limitations

• The pilot is the first part of the train parquet until each topic has 20 kept rows. Rates in the full 1,400,000-row train split can differ.
• The pilot asks only the Yahoo class for each input. A No self-check means the model did not answer Yes for that class. It is not a label for one of the other nine names.
• The official Yahoo test split is unused. Validation and test here are slices of the Yahoo train split.
• Activations are tied to this tokenizer revision, this chat template, layer 19, and the unadapted checkpoint. Changing any cache-key field requires a new extraction. The self-check replies are tied to greedy bfloat16 decoding of this same revision.
• The balanced training view changes the Yes/No rate a training loop sees. Reported validation and test frequencies are the unweighted self-check counts above.
• Five self-checks did not parse and are not reader targets.
• The dataset is for studying activations. It is not a benchmark of Qwen’s generated answers, and it is not a medical, legal, or advice corpus.

Reproduction

From topic_selfread_dataset/:

PYTHONPATH=src python -m topic_selfread prepare configs/pilot.yaml
PYTHONPATH=src python -m topic_selfread split configs/pilot.yaml
PYTHONPATH=src python -m topic_selfread extract configs/pilot.yaml
PYTHONPATH=src python -m topic_selfread self_check configs/pilot.yaml
PYTHONPATH=src python -m topic_selfread validate configs/pilot.yaml

configs/full.yaml points at the same runs/yahoo_v1 directory with no row cap. Running it would add the rest of the Yahoo train split and would require new activations for every new input. That full build has not been run.