# FineWeb Data Loading

## Downloading in Modal

Since Modal functions run in isolated containers, download data inside the function:

```python
def download_fineweb_data():
    """Download FineWeb tokenized data using huggingface_hub.

    Uses kjj0/fineweb100B-gpt2 dataset (publicly accessible, no auth required).
    Based on: https://github.com/KellerJordan/modded-nanogpt/blob/master/data/cached_fineweb100B.py
    """
    import os
    from huggingface_hub import hf_hub_download

    data_dir = "/tmp/data/fineweb100B"
    os.makedirs(data_dir, exist_ok=True)

    def get_file(fname):
        if not os.path.exists(os.path.join(data_dir, fname)):
            print(f"Downloading {fname}...")
            hf_hub_download(
                repo_id="kjj0/fineweb100B-gpt2",
                filename=fname,
                repo_type="dataset",
                local_dir=data_dir,
            )

    # Download validation shard
    get_file("fineweb_val_000000.bin")
    # Download first training shard (100M tokens)
    get_file("fineweb_train_000001.bin")

    print("Data download complete!")
    return data_dir
```

## Dataset Files

| File | Size | Content |
|------|------|---------|
| `fineweb_val_000000.bin` | ~200MB | Validation shard |
| `fineweb_train_000001.bin` | ~200MB | Training shard (~100M tokens) |

Files contain pre-tokenized data as uint16 arrays (GPT-2 tokenizer).

## Memory-Mapped Data Loading

Use memory-mapped files for efficient data loading:

```python
import numpy as np
import torch

class FineWebDataset:
    def __init__(self, data_dir, split="train", block_size=1024):
        self.block_size = block_size

        import os
        pattern = f"fineweb_{split}_"
        self.shards = sorted([
            os.path.join(data_dir, f)
            for f in os.listdir(data_dir)
            if f.startswith(pattern) and f.endswith(".bin")
        ])

        self.data = [np.memmap(s, dtype=np.uint16, mode="r") for s in self.shards]
        self.lengths = [len(d) for d in self.data]
        self.total_length = sum(self.lengths)

    def _get_tokens(self, global_idx, length):
        """Get tokens starting at global_idx across shards."""
        cumsum = 0
        for i, shard_len in enumerate(self.lengths):
            if global_idx < cumsum + shard_len:
                local_idx = global_idx - cumsum
                return np.array(self.data[i][local_idx:local_idx + length])
            cumsum += shard_len
        raise IndexError("Index out of range")

    def get_batch(self, batch_size, device="cuda"):
        max_start = self.total_length - self.block_size - 1
        starts = torch.randint(0, max_start, (batch_size,))

        x = torch.zeros(batch_size, self.block_size, dtype=torch.long)
        y = torch.zeros(batch_size, self.block_size, dtype=torch.long)

        for i, start in enumerate(starts):
            tokens = self._get_tokens(start.item(), self.block_size + 1)
            x[i] = torch.from_numpy(tokens[:-1].astype(np.int32))
            y[i] = torch.from_numpy(tokens[1:].astype(np.int32))

        return x.to(device), y.to(device)
```

## Usage

```python
# Create dataset
data_dir = download_fineweb_data()
train_dataset = FineWebDataset(data_dir, split="train", block_size=1024)
val_dataset = FineWebDataset(data_dir, split="val", block_size=1024)

# Get batch
x, y = train_dataset.get_batch(batch_size=32, device="cuda")
```

## Memory Efficiency

Memory-mapped files:
- Don't load entire dataset into RAM
- Load data on-demand as needed
- Allow training on datasets larger than available RAM
- Each shard is mapped independently