arrafmousa/qwen3-8b-thought-graphs-uf095

Qwen3-8B thought graphs: conflict-aware Union-Find, cosine 0.95

2,853 questions, 22,824 generated chains, eight chains per question. Each Parquet row is one question, with its full generated chains, ordered step lists, model and decoding metadata, expected and extracted answers, nullable correctness labels, and a directed cluster graph.

The drop, logiqav2, and mmlu_pro splits identify source datasets, not training/validation/test partitions. Keep all chains and steps of a question together when constructing machine-learning splits. Large uploads arrive in multiple commits. transfer_inventory.json lists the expected files and sizes; if a listed file is absent, publication is still in progress. Pin a complete repository commit for reproducible experiments.

Method

For each step, average the raw final-layer generation-time token states (4,096 dimensions), L2-normalize the resulting vector, and calculate cross-trace cosine similarities within that question. Process edges with similarity >= 0.95 from highest to lowest using Union-Find. Reject merges that would put two checkpoints from the same trace in a cluster. No projection and no GPT calls are used to assign these clusters. A cluster contains at most eight samples.

This is a selected unsupervised configuration, not a trained classifier. The winning hidden-state configurations were selected from a 2,774-configuration grid search. Config ID: 389c65cb427b1710. Union-Find is transitive: not every pair inside a resulting cluster is guaranteed to exceed the edge threshold.

The primary graph preserves the exact ML clustering rule. It does not apply the answer-equivalence override used in an earlier HTML viewer. Extracted final answers and correctness remain annotations; they do not influence clustering. Edges aggregate adjacent steps along the original traces. Collapsing steps can produce directed cycles; the output is not guaranteed to be a DAG. Follow each chain's ordered step list to recover its actual path.

Two explicitly different segmentation sources

• 100 golden questions: existing GPT-5-mini cognitive-step boundaries are retained (34 DROP, 33 LogiQA v2, 33 MMLU-Pro). Their golden semantic cluster labels are evaluation annotations, not clustering inputs.
• 2,753 remaining questions: existing deterministic local sentence splitting. No new GPT requests were made. Sentence boundaries are not equivalent to cognitive-step boundaries, so benchmark scores below must not be presented as measured accuracy on this remainder.

The per-record segmentation metadata identifies which procedure was used.

Clustering evaluation

These are selection-set estimates, not independent held-out generalization scores. The same 100 GPT-labeled questions were used to select the configurations. Each metric is computed per question, averaged within each source dataset, then averaged equally across the three datasets. Questions with more steps or merges therefore do not dominate the reported aggregate.

Metric	Equal-dataset macro
Exact pair F1	0.4948
Exact pair precision	0.4810
Exact pair recall	0.5243
B-cubed F1	0.6318
Pair balanced accuracy	0.7402
Pair accuracy (ACC)	0.9269

Pair metrics classify whether a pair of steps from different traces should share a golden cluster. ACC can be inflated by the many nonmatching pairs; exact pair F1 and balanced accuracy are more informative. These numbers concern clustering, not predicting whether a reasoning chain will fail. Historical selection estimates and per-source values are in evaluation/historical_selection_metrics.json. Export-time evaluation files provide the independently recomputed metrics for the exported golden records.

Generated-answer accuracy

These statistics are identical in both method repositories because generation and original answer verification are unchanged.

Split	Questions	Chains	Correct	Incorrect	Unscored	ACC among scored	Correct / all chains
drop	1000	8000	3711	2847	1442	56.59%	46.39%
logiqav2	1000	8000	3719	2922	1359	56.00%	46.49%
mmlu_pro	853	6824	2195	2227	2402	49.64%	32.17%

is_correct = null means unscored, not false. A parseable answer may still come from a length-limited generation; inspect finish_reason separately. The stored deterministic verifier can miss semantic equivalents (for example number words versus numerals in DROP), or extract an option from an unfinished MCQ trace. Labels are preserved as collected, not relabeled by a new judge. Pipe-separated DROP reference answers are the stored verifier alternatives.

Graph success rates, when present, count member traces with correct outcomes divided by members with a non-null score. These are retrospective annotations and must not be input features for an early-failure predictor on held-out traces. Neither golden IDs nor graph IDs are shared semantic labels across questions.

Load and inspect

Install datasets, huggingface_hub, pyarrow, safetensors, and numpy. Load only the lightweight structured records; the raw tensor collection is not downloaded by load_dataset.

from datasets import load_dataset

repo = "arrafmousa/qwen3-8b-thought-graphs-uf095"
ds = load_dataset(repo)
print(ds)  # drop=1000, logiqav2=1000, mmlu_pro=853
question = ds["drop"][0]
print(question["question"])
chain = question["chains"][0]
print(chain["generated_text"])
print(chain["steps"][0])
print(chain["graph_path"])
print(question["nodes"][0])
print(question["edges"][:2])

For streaming, use load_dataset(repo, split="drop", streaming=True). Each chain has its original text and ordered step records. The graph carries cluster membership and directed transitions; use step IDs to connect the views. The exact Arrow schema is included below, so nested identifiers and tensor references can be inspected without guessing.

Hidden representations and token mappings

Both repositories include the same original captured token tensors and indexes:

• hidden_states/<split>/*.safetensors: original FP16 layer-36 token vectors; approximately 144.3 GB combined. No model inference is repeated.
• token_index/<split>/*.parquet: token IDs, decoded token pieces, token positions, tensor keys, tensor rows, layer and answer-token indicators. Tensor paths are rewritten to this repository's portable layout.
• step_states/<split>/*.safetensors: derived step-mean and checkpoint-last vectors, with references from the structured step records.

Download only files referenced by the question/step you need, using hf_hub_download(repo, filename, repo_type="dataset"). For example, to inspect an index and load one captured vector:

import pandas as pd
from huggingface_hub import hf_hub_download, list_repo_files
from safetensors.numpy import load_file

index_name = next(
    p for p in sorted(list_repo_files(repo, repo_type="dataset"))
    if p.startswith("token_index/drop/") and p.endswith(".parquet")
)
index = pd.read_parquet(hf_hub_download(repo, index_name, repo_type="dataset"))
row = index.sort_values(["sample_index", "token_position"]).iloc[0]
tensor_file = hf_hub_download(
    repo, row["hidden_state_chunk"], repo_type="dataset"
)
vector = load_file(tensor_file)[row["tensor_key"]][int(row["row"])]
print(vector.shape, vector.dtype)  # (4096,), float16

To load the last-checkpoint and step-mean representations for a specific step:

step = chain["steps"][0]
states = load_file(hf_hub_download(
    repo, step["step_representation_file"], repo_type="dataset"
))
row_number = step["step_representation_row"]
last_state = states[step["last_key"]][row_number]
step_mean = states[step["step_mean_key"]][row_number]

Never use tensor row number as token order. Sort by token_position; use row only for indexing the tensor. Character offsets refer to stored generated text; token-piece decoding can differ around Unicode byte-fallback sequences. The export aligns those boundaries and records the checkpoint mapping. Character and token intervals are half-open: [start, end).

The collection hook captured the last-position final-layer activation at each generation forward pass and associated it with the token emitted at that step. These are generation-time predictive states, not a fresh teacher-forced post-token re-encoding. In particular, the first predictive state comes from prefill. This convention is preserved, not silently shifted.

Model and provenance

• Generator: Qwen/Qwen3-8B.
• Stored model and tokenizer revision: main; a pinned commit SHA was not recorded, so exact weight revision reproducibility is limited.
• Sampling: temperature 0.7, top-p 0.95, top-k 50, sampling enabled, maximum 1,000 new tokens. Seeds and generation parameters are retained per chain.
• MMLU-Pro includes 853 completed question groups from an intended 1,000-question run; missing groups are not fabricated.
• Repository data, tensor indexes, and step-state files are reconstructable without access to the original local directory.
• No credentials, environment files, machine logs, or local configuration snapshots are distributed.

Licensing and attribution

This is a derived research collection, not a claim of a new blanket license over the underlying questions. Source terms continue to apply:

Source	Upstream	Upstream card license
DROP, validation questions	ucinlp/drop	CC-BY-SA-4.0
LogiQA 2.0	datatune/LogiQA2.0	MIT
MMLU-Pro, test questions	TIGER-Lab/MMLU-Pro	MIT in HF card

Copies of the upstream cards, including their author/citation information, are provided in licenses/. DROP adaptations must retain attribution and applicable share-alike requirements (license). The MMLU-Pro GitHub repository currently has an Apache-2.0 LICENSE whereas its HF card says MIT; this discrepancy is recorded rather than silently resolved. Consult upstream terms before redistribution. Generated traces and graph annotations are additions by this experiment; they do not remove source rights. Upstream cards reflect retrieval-time metadata, not a pinned original download.

Questions or generated text can contain sensitive benchmark subject matter and incorrect claims. Outputs are for research, not authoritative advice.

Exact nested schema

schema_version: string
question_id: string
dataset: string
source_question_id: string
question: string
reference_answer: string
model_id: string
model_revision: string
tokenizer_revision: string
raw_capture: struct<dtype: string, layer: int64, hidden_dimension: int64, semantics: string>
  child 0, dtype: string
  child 1, layer: int64
  child 2, hidden_dimension: int64
  child 3, semantics: string
segmentation_method: string
is_golden: bool
clustering: struct<algorithm: string, representation: string, threshold_mode: string, threshold_value: double, u (... 15 chars omitted)
  child 0, algorithm: string
  child 1, representation: string
  child 2, threshold_mode: string
  child 3, threshold_value: double
  child 4, uses_gold: bool
chains: list<element: struct<chain_id: int64, trace_index: int64, deterministic_seed: int64, prompt: string, (... 976 chars omitted)
  child 0, element: struct<chain_id: int64, trace_index: int64, deterministic_seed: int64, prompt: string, generated_tex (... 961 chars omitted)
      child 0, chain_id: int64
      child 1, trace_index: int64
      child 2, deterministic_seed: int64
      child 3, prompt: string
      child 4, generated_text: string
      child 5, generated_token_ids: list<element: int64>
          child 0, element: int64
      child 6, generated_token_count: int64
      child 7, raw_final_answer: string
      child 8, parsed_final_answer: string
      child 9, final_answer_text: string
      child 10, expected_answer: string
      child 11, is_correct: bool
      child 12, finish_reason: string
      child 13, generation_parameters: string
      child 14, source_metadata_json: string
      child 15, raw_tensor_file: string
      child 16, raw_tensor_key: string
      child 17, token_index_file: string
      child 18, steps: list<element: struct<step_id: string, trace_index: int64, step_position: int64, char_start: int64, c (... 451 chars omitted)
          child 0, element: struct<step_id: string, trace_index: int64, step_position: int64, char_start: int64, char_end: int64 (... 436 chars omitted)
              child 0, step_id: string
              child 1, trace_index: int64
              child 2, step_position: int64
              child 3, char_start: int64
              child 4, char_end: int64
              child 5, text: string
              child 6, source_sentence_ids: list<element: string>
                  child 0, element: string
              child 7, gold_cluster: int64
              child 8, cluster_id: int64
              child 9, is_terminal: bool
              child 10, final_answer: string
              child 11, token_start: int64
              child 12, token_end: int64
              child 13, boundary_overshoot: int64
              child 14, tensor_rows: list<element: int64>
                  child 0, element: int64
              child 15, layer: int64
              child 16, token_index_file: string
              child 17, raw_tensor_file: string
              child 18, raw_tensor_key: string
              child 19, step_representation_file: string
              child 20, step_mean_key: string
              child 21, last_key: string
              child 22, step_representation_row: int64
      child 19, graph_path: list<element: int64>
          child 0, element: int64
nodes: list<element: struct<cluster_id: int64, member_step_ids: list<element: string>, member_chain_ids: li (... 186 chars omitted)
  child 0, element: struct<cluster_id: int64, member_step_ids: list<element: string>, member_chain_ids: list<element: in (... 171 chars omitted)
      child 0, cluster_id: int64
      child 1, member_step_ids: list<element: string>
          child 0, element: string
      child 2, member_chain_ids: list<element: int64>
          child 0, element: int64
      child 3, sample_count: int64
      child 4, scored_count: int64
      child 5, correct_count: int64
      child 6, success_rate: double
      child 7, terminal_step_ids: list<element: string>
          child 0, element: string
      child 8, final_answers: list<element: string>
          child 0, element: string
edges: list<element: struct<source: int64, target: int64, transition_count: int64, trace_indices: list<elem (... 93 chars omitted)
  child 0, element: struct<source: int64, target: int64, transition_count: int64, trace_indices: list<element: int64>, s (... 78 chars omitted)
      child 0, source: int64
      child 1, target: int64
      child 2, transition_count: int64
      child 3, trace_indices: list<element: int64>
          child 0, element: int64
      child 4, source_step_ids: list<element: string>
          child 0, element: string
      child 5, target_step_ids: list<element: string>
          child 0, element: string