twibiral/dataset_and_activations

Llama-3.1-8B base vs. MergeBench/Llama-3.1-8B_coding — paired activations (10% subsample)

Paired residual-stream activations for two models run over the same text, token for token, for crosscoder / model-diffing work. This is a uniform 10% sequence-level subsample of a larger internal capture; the layout matches the full capture exactly, so code written against this repo works unchanged on the full version.

Model 1	meta-llama/Llama-3.1-8B (base)
Model 2	MergeBench/Llama-3.1-8B_coding
Hook	output of model.layers[31] (decoder-layer output, i.e. the residual stream after block 31)
d_model	4096
dtype	bfloat16 (raw, stored as the 16-bit pattern)
Context length	512 tokens, all token positions kept
Sequences	19,551 (10% of 195,506)
Tokens (rows) per model	9,086,752
Size	74.4 GB per model, 148.9 GB total (46 shards each)

Both models share one token grid: the same tokenizer, the same sequences, the same sequence_ranges. Row i of model 1 and row i of model 2 are the same token position of the same text, which is what makes the pair usable for a crosscoder.

Text

Prompts are a mixed instruction/coding pool (WildChat regenerations, Tulu 3 SFT subsets, evol-codealpaca, personahub code, OpenThoughts, FLAN, …); responses were generated by the base model meta-llama/Llama-3.1-8B (sampling, T=0.7, top_p=0.9, repetition_penalty=1.3, max_new_tokens=512, seed 42). Both models were then run over that same text.

Each sequence is fed as:

### Prompt:
{prompt}

### Response:
{response}

prompts.jsonl holds one line per sequence, in the same order as the activation rows, with fields sample_id, global_sample_id, prompt, response, response_model and the assembled text.

The text in prompts.jsonl is the full, untruncated text — it is NOT what the models saw. Sequences were cut at 512 tokens, and 15,174 of 19,551 (77.6%) hit that cap, so for most rows the stored text runs past the end of the captured activations. Aligning text against rows character-by-character will drift.

tokens.pt is the ground truth: it gives the exact token id behind every activation row. Decode it to recover precisely the text that produced the activations:

from transformers import AutoTokenizer
tok = AutoTokenizer.from_pretrained("meta-llama/Llama-3.1-8B")
start, end = int(r[i]), int(r[i + 1])
tok.decode(tokens[start:end])          # exactly what the models were run on for sequence i

Layout

llama31_8b_base_vs_coding_10pct/
    prompts.jsonl                  # 19,551 lines, one per sequence, aligned with the rows
    selected_sequence_indices.npy  # indices into the full 195,506-sequence capture
    subset_metadata.json           # provenance + the full capture's run_config
    model_1__meta-llama__Llama-3.1-8B/
        tokens.pt                  # int64 [n_rows]      token id per row
        sequence_ranges.pt         # int64 [n_seq + 1]   row offsets; seq i is [r[i], r[i+1])
        model_layers_idx31_out/
            config.json            # total_size, shard_count, d_model, ...
            shard_0..45.memmap     # raw bfloat16, C-order, shape from the matching .meta
            shard_0..45.meta       # {"shape": [rows, 4096], "dtype": "torch.bfloat16"}
            mean.pt, std.pt, count.pt, M2.pt
    model_2__MergeBench__Llama-3.1-8B_coding/
        ...                        # same structure, same grid, same row count

mean.pt / std.pt / count.pt / M2.pt are the statistics of the FULL capture, copied unchanged rather than recomputed on the subset — they are the normalisation constants the crosscoders were trained with. Recompute them if you want subset-consistent statistics.

Loading

Shards are plain memmaps, so no special library is needed:

import json, numpy as np, torch

d = "llama31_8b_base_vs_coding_10pct/model_1__meta-llama__Llama-3.1-8B/model_layers_idx31_out"
meta = json.load(open(f"{d}/shard_0.meta"))
# bfloat16 has no numpy dtype: read the raw 16-bit pattern, then view it as bf16.
raw = np.memmap(f"{d}/shard_0.memmap", dtype=np.int16, mode="r", shape=tuple(meta["shape"]))
acts = torch.from_numpy(np.asarray(raw)).view(torch.bfloat16)   # [rows, 4096]

To get the rows of sequence i for both models:

r = torch.load("llama31_8b_base_vs_coding_10pct/model_1__meta-llama__Llama-3.1-8B/sequence_ranges.pt", weights_only=True)
start, end = int(r[i]), int(r[i + 1])   # same range in both model dirs

Shards are contiguous and in order, so global row n lives in the first shard whose cumulative row count exceeds n.

Subsampling

19,551 of 195,506 sequences, drawn uniformly without replacement, numpy default_rng seed 0, kept in ascending order. The identical selection is applied to both models, so the pairing is preserved. Rows are copied as raw bytes — the activations are bit-identical to the full capture, not re-encoded. selected_sequence_indices.npy maps each sequence back to its index in the full capture.

Caveats

• Responses are base-model samples with a repetition penalty, so the text is often low quality and repetitive. That is intentional — it is the distribution both models were probed on — but it makes this a poor corpus for anything other than diffing these two models.
• Sequences shorter than 512 tokens contribute fewer rows (row counts range from 24 to 512); use sequence_ranges.pt rather than assuming a fixed stride.
• Only layer 31 was captured.