veriga/openwebtext-gemma3-tokenized-1024-activations-layer23

OpenWebText — Gemma-3-1B Hidden State Activations (Layer 23)

Precomputed hidden state activations before layer 23 of Gemma-3-1B-IT for the OpenWebText dataset, tokenized with sequence length 1024.

Designed for training a Titans memory layer that replaces layer 23 of Gemma 3.

Dataset Structure

Each example contains the inputs to layer 23:

Field	Shape	Dtype	Description
activations	(1024, 1152)	float32	Hidden state activations (cast from bfloat16)
mask	(1024,)	int32	Attention mask (1=real token, 0=pad)
tokens	(1024,)	int32	Token IDs

• Total examples: ~71,744
• Examples per NPY shard: 64
• Examples per Parquet file: 640 (10 NPY shards)
• Sequence length: 1024
• Hidden dimension: 1152 (Gemma-3-1B embed_dim)
• Source model: google/gemma-3-1b-it
• Source dataset: veriga/openwebtext-gemma3-tokenized-1024

Files

Format	Files	Location
Parquet (recommended)	113 files	data/train-NNNNNN-NNNNNN.parquet
NPY (original)	3363 files	shard_NNNNNN.npy, shard_NNNNNN_masks.npy, shard_NNNNNN_tokens.npy

Parquet files use ZSTD compression (level 3) and store activations as a flat fixed_size_list<float32>[1179648] (reshape to 1024 × 1152 after loading).

How It Was Created

Activations were computed using a truncated forward pass through the first 23 Gemma 3 transformer layers:

1. Load OpenWebText tokens from veriga/openwebtext-gemma3-tokenized-1024
2. Pad/truncate to 1024 tokens, generate attention masks
3. Forward pass through layers 0–22 of Gemma-3-1B-IT
4. Apply attention mask: hidden * mask[:, :, None] (zero out padding positions)
5. Save as .npy shards in bfloat16

See the precomputation notebook for full details.

Parquet conversion: Convert_NPY_to_Parquet.ipynb

Loading the Dataset

Standard (loads Parquet)

from datasets import load_dataset

ds = load_dataset("veriga/openwebtext-gemma3-tokenized-1024-activations-layer23", split="train")

example = ds[0]
activations = example["activations"]  # list of 1179648 floats
mask = example["mask"]                # list of 1024 ints
tokens = example["tokens"]            # list of 1024 ints

# Reshape activations
import numpy as np
act = np.array(activations, dtype=np.float32).reshape(1024, 1152)

Streaming (recommended — no download)

ds = load_dataset(
    "veriga/openwebtext-gemma3-tokenized-1024-activations-layer23",
    split="train",
    streaming=True
)

import numpy as np
for example in ds:
    act = np.array(example["activations"], dtype=np.float32).reshape(1024, 1152)
    mask = np.array(example["mask"])
    tokens = np.array(example["tokens"])
    # Use for Titans training...

Direct Parquet access (no HF datasets)

import pyarrow.parquet as pq
import numpy as np

# From HuggingFace Hub
from huggingface_hub import hf_hub_download
path = hf_hub_download(
    repo_id="veriga/openwebtext-gemma3-tokenized-1024-activations-layer23",
    filename="data/train-000000-000009.parquet",
    repo_type="dataset",
)

table = pq.read_table(path)
row = table.slice(0, 1).to_pydict()
act = np.array(row["activations"][0], dtype=np.float32).reshape(1024, 1152)
mask = np.array(row["mask"][0])
tokens = np.array(row["tokens"][0])

Original NPY files

import jax.numpy as jnp  # or use ml_dtypes for np.load with bfloat16
import numpy as np

activations = np.array(jnp.load("shard_000000.npy"), dtype=np.float32)  # (64, 1024, 1152)
mask = np.load("shard_000000_masks.npy")                                  # (64, 1024)
tokens = np.load("shard_000000_tokens.npy")                                # (64, 1024)

Use Case: Titans Memory Layer

This dataset provides inputs for training a Titans long-term memory module that replaces layer 23 of Gemma 3. The precomputed activations allow training the memory layer independently without running the full model forward pass through the first 22 layers.

Notes

• Original activations stored in bfloat16 (NPY); Parquet cast to float32
• Padding positions in activations are zeroed out via attention mask multiplication
• The first token in each sequence is the BOS token (ID=2)