---
language:
- en
license: apache-2.0
task_categories:
- other
tags:
- gemma
- titans
- activations
- hidden-states
- precomputed
size_categories:
- 100K<n<1M
---

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

Precomputed hidden state activations before layer 23 of [Gemma-3-1B-IT](https://huggingface.co/google/gemma-3-1b-it) for the [OpenWebText](https://huggingface.co/datasets/Skylion007/openwebtext) dataset, tokenized with sequence length 1024.

Designed for training a **[Titans](https://arxiv.org/abs/2501.00663)** 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](https://github.com/andrew-veriga/Titans_jax/blob/main/colabs/Precompute_Activations_Gemma3_GPU.ipynb) for full details.

Parquet conversion: [Convert_NPY_to_Parquet.ipynb](https://github.com/andrew-veriga/Titans_jax/blob/main/colabs/Convert_NPY_to_Parquet.ipynb)

## Loading the Dataset

### Standard (loads Parquet)

```python
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)

```python
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)

```python
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

```python
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](https://arxiv.org/abs/2501.00663) 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)