Add upload script

upload_script.py

@@ -0,0 +1,385 @@
+"""
+Taken and adapated from Alan Cooney's
+https://github.com/ai-safety-foundation/sparse_autoencoder/tree/main/sparse_autoencoder.
+"""
+
+import subprocess
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from typing import TypedDict
+
+from datasets import (
+    Dataset,
+    DatasetDict,
+    VerificationMode,
+    load_dataset,
+)
+from huggingface_hub import HfApi
+from jaxtyping import Int
+from pydantic import PositiveInt, validate_call
+from torch import Tensor
+from transformers import AutoTokenizer, PreTrainedTokenizerBase
+
+
+class GenericTextDataBatch(TypedDict):
+    """Generic Text Dataset Batch.
+
+    Assumes the dataset provides a 'text' field with a list of strings.
+    """
+
+    text: list[str]
+    meta: list[dict[str, dict[str, str]]]  # Optional, depending on the dataset structure.
+
+
+TokenizedPrompt = list[int]
+"""A tokenized prompt."""
+
+
+class TokenizedPrompts(TypedDict):
+    """Tokenized prompts."""
+
+    input_ids: list[TokenizedPrompt]
+
+
+class TorchTokenizedPrompts(TypedDict):
+    """Tokenized prompts prepared for PyTorch."""
+
+    input_ids: Int[Tensor, "batch pos vocab"]
+
+
+class TextDataset:
+    """Generic Text Dataset for any text-based dataset from Hugging Face."""
+
+    tokenizer: PreTrainedTokenizerBase
+
+    def preprocess(
+        self,
+        source_batch: GenericTextDataBatch,
+        *,
+        context_size: int,
+    ) -> TokenizedPrompts:
+        """Preprocess a batch of prompts.
+
+        Tokenizes a batch of text data and packs into context_size samples. An eos token is added
+        to the end of each document after tokenization.
+
+        Args:
+            source_batch: A batch of source data, including 'text' with a list of strings.
+            context_size: Context size for tokenized prompts.
+
+        Returns:
+            Tokenized prompts.
+        """
+        prompts: list[str] = source_batch["text"]
+
+        tokenized_prompts = self.tokenizer(prompts, truncation=False, padding=False)
+
+        all_tokens = []
+        for document_tokens in tokenized_prompts[self._dataset_column_name]:  # type: ignore
+            all_tokens.extend(document_tokens + [self.tokenizer.eos_token_id])
+        # Ignore incomplete chunks
+        chunks = [
+            all_tokens[i : i + context_size]
+            for i in range(0, len(all_tokens), context_size)
+            if len(all_tokens[i : i + context_size]) == context_size
+        ]
+
+        return {"input_ids": chunks}
+
+    @validate_call(config={"arbitrary_types_allowed": True})
+    def __init__(
+        self,
+        dataset_path: str,
+        tokenizer: PreTrainedTokenizerBase,
+        context_size: PositiveInt = 256,
+        load_revision: str = "main",
+        dataset_dir: str | None = None,
+        dataset_files: str | Sequence[str] | Mapping[str, str | Sequence[str]] | None = None,
+        dataset_split: str | None = None,
+        dataset_column_name: str = "input_ids",
+        n_processes_preprocessing: PositiveInt | None = None,
+        preprocess_batch_size: PositiveInt = 1000,
+    ):
+        """Initialize a generic text dataset from Hugging Face.
+
+        Args:
+            dataset_path: Path to the dataset on Hugging Face (e.g. `'monology/pile-uncopyright'`).
+            tokenizer: Tokenizer to process text data.
+            context_size: The context size to use when returning a list of tokenized prompts.
+                *Towards Monosemanticity: Decomposing Language Models With Dictionary Learning* used
+                a context size of 250.
+            load_revision: The commit hash or branch name to download from the source dataset.
+            dataset_dir: Defining the `data_dir` of the dataset configuration.
+            dataset_files: Path(s) to source data file(s).
+            dataset_split: Dataset split (e.g., 'train'). If None, process all splits.
+            dataset_column_name: The column name for the prompts.
+            n_processes_preprocessing: Number of processes to use for preprocessing.
+            preprocess_batch_size: Batch size for preprocessing (tokenizing prompts).
+        """
+        self.tokenizer = tokenizer
+
+        self.context_size = context_size
+        self._dataset_column_name = dataset_column_name
+
+        # Load the dataset
+        dataset = load_dataset(
+            dataset_path,
+            revision=load_revision,
+            streaming=False,  # We need to pre-download the dataset to upload it to the hub.
+            split=dataset_split,
+            data_dir=dataset_dir,
+            data_files=dataset_files,
+            verification_mode=VerificationMode.NO_CHECKS,  # As it fails when data_files is set
+        )
+        # If split is not None, will return a Dataset instance. Convert to DatasetDict.
+        if isinstance(dataset, Dataset):
+            assert dataset_split is not None
+            dataset = DatasetDict({dataset_split: dataset})
+        assert isinstance(dataset, DatasetDict)
+
+        for split in dataset:
+            print(f"Processing split: {split}")
+            # Setup preprocessing (we remove all columns except for input ids)
+            remove_columns: list[str] = list(next(iter(dataset[split])).keys())  # type: ignore
+            if "input_ids" in remove_columns:
+                remove_columns.remove("input_ids")
+
+            # Tokenize and chunk the prompts
+            mapped_dataset = dataset[split].map(
+                self.preprocess,
+                batched=True,
+                batch_size=preprocess_batch_size,
+                fn_kwargs={"context_size": context_size},
+                remove_columns=remove_columns,
+                num_proc=n_processes_preprocessing,
+            )
+            dataset[split] = mapped_dataset.shuffle()
+
+        self.dataset = dataset
+
+    @validate_call
+    def push_to_hugging_face_hub(
+        self,
+        repo_id: str,
+        commit_message: str = "Upload preprocessed dataset using sparse_autoencoder.",
+        max_shard_size: str = "500MB",
+        revision: str = "main",
+        *,
+        private: bool = False,
+    ) -> None:
+        """Share preprocessed dataset to Hugging Face hub.
+
+        Motivation:
+            Pre-processing a dataset can be time-consuming, so it is useful to be able to share the
+            pre-processed dataset with others. This function allows you to do that by pushing the
+            pre-processed dataset to the Hugging Face hub.
+
+        Warning:
+            You must be logged into HuggingFace (e.g with `huggingface-cli login` from the terminal)
+            to use this.
+
+        Warning:
+            This will only work if the dataset is not streamed (i.e. if `pre_download=True` when
+            initializing the dataset).
+
+        Args:
+            repo_id: Hugging Face repo ID to save the dataset to (e.g. `username/dataset_name`).
+            commit_message: Commit message.
+            max_shard_size: Maximum shard size (e.g. `'500MB'`).
+            revision: Branch to push to.
+            private: Whether to save the dataset privately.
+        """
+        self.dataset.push_to_hub(
+            repo_id=repo_id,
+            commit_message=commit_message,
+            max_shard_size=max_shard_size,
+            private=private,
+            revision=revision,
+        )
+
+
+@dataclass
+class DatasetToPreprocess:
+    """Dataset to preprocess info."""
+
+    source_path: str
+    """Source path from HF (e.g. `roneneldan/TinyStories`)."""
+
+    tokenizer_name: str
+    """HF tokenizer name (e.g. `gpt2`)."""
+
+    load_revision: str = "main"
+    """Commit hash or branch name to download from the source dataset."""
+
+    data_dir: str | None = None
+    """Data directory to download from the source dataset."""
+
+    data_files: list[str] | None = None
+    """Data files to download from the source dataset."""
+
+    hugging_face_username: str = "apollo-research"
+    """HF username for the upload."""
+
+    private: bool = False
+    """Whether the HF dataset should be private or public."""
+
+    context_size: int = 2048
+    """Number of tokens in a single sample. gpt2 uses 1024, pythia uses 2048."""
+
+    split: str | None = None
+    """Dataset split to download from the source dataset. If None, process all splits."""
+
+    @property
+    def source_alias(self) -> str:
+        """Create a source alias for the destination dataset name.
+
+        Returns:
+            The modified source path as source alias.
+        """
+        return self.source_path.replace("/", "-")
+
+    @property
+    def tokenizer_alias(self) -> str:
+        """Create a tokenizer alias for the destination dataset name.
+
+        Returns:
+            The modified tokenizer name as tokenizer alias.
+        """
+        return self.tokenizer_name.replace("/", "-")
+
+    @property
+    def destination_repo_name(self) -> str:
+        """Destination repo name.
+
+        Returns:
+            The destination repo name.
+        """
+        split_str = f"{self.split}-" if self.split else ""
+        return f"{self.source_alias}-{split_str}tokenizer-{self.tokenizer_alias}"
+
+    @property
+    def destination_repo_id(self) -> str:
+        """Destination repo ID.
+
+        Returns:
+            The destination repo ID.
+        """
+        return f"{self.hugging_face_username}/{self.destination_repo_name}"
+
+
+def upload_datasets(datasets_to_preprocess: list[DatasetToPreprocess]) -> None:
+    """Upload datasets to HF.
+
+    Warning:
+        Assumes you have already created the corresponding repos on HF.
+
+    Args:
+        datasets_to_preprocess: List of datasets to preprocess.
+
+    Raises:
+        ValueError: If the repo doesn't exist.
+    """
+    repositories_updating = [dataset.destination_repo_id for dataset in datasets_to_preprocess]
+    print("Updating repositories:\n" "\n".join(repositories_updating))
+
+    for dataset in datasets_to_preprocess:
+        print("Processing dataset: ", dataset.source_path)
+
+        # Preprocess
+        tokenizer = AutoTokenizer.from_pretrained(dataset.tokenizer_name)
+        text_dataset = TextDataset(
+            dataset_path=dataset.source_path,
+            tokenizer=tokenizer,
+            dataset_files=dataset.data_files,
+            dataset_dir=dataset.data_dir,
+            dataset_split=dataset.split,
+            context_size=dataset.context_size,
+            load_revision=dataset.load_revision,
+        )
+        # size_in_bytes and info gives info about the whole dataset regardless of the split index,
+        # so we just get the first split.
+        split = next(iter(text_dataset.dataset))
+        print("Dataset info:")
+        print(f"Size: {text_dataset.dataset[split].size_in_bytes / 1e9:.2f} GB")  # type: ignore
+        print("Info: ", text_dataset.dataset[split].info)
+
+        # Upload
+        text_dataset.push_to_hugging_face_hub(
+            repo_id=dataset.destination_repo_id, private=dataset.private
+        )
+        # Also upload the current file to the repo for reproducibility and transparency
+        api = HfApi()
+        api.upload_file(
+            path_or_fileobj=__file__,
+            path_in_repo="upload_script.py",
+            repo_id=dataset.destination_repo_id,
+            repo_type="dataset",
+            commit_message="Add upload script",
+        )
+
+
+if __name__ == "__main__":
+    # Check that the user is signed in to huggingface-cli
+    try:
+        result = subprocess.run(
+            ["huggingface-cli", "whoami"], check=True, capture_output=True, text=True
+        )
+        if "Not logged in" in result.stdout:
+            print("Please sign in to huggingface-cli using `huggingface-cli login`.")
+            raise Exception("You are not logged in to huggingface-cli.")
+    except subprocess.CalledProcessError:
+        print("An error occurred while checking the login status.")
+        raise
+
+    datasets: list[DatasetToPreprocess] = [
+        DatasetToPreprocess(
+            source_path="roneneldan/TinyStories",
+            # Paper says gpt-neo tokenizer, and e.g. EleutherAI/gpt-neo-125M uses the same tokenizer
+            # as gpt2. They also suggest using gpt2 in (https://github.com/EleutherAI/gpt-neo).
+            tokenizer_name="gpt2",
+            hugging_face_username="apollo-research",
+            context_size=512,
+        ),
+        DatasetToPreprocess(
+            source_path="Skylion007/openwebtext",
+            tokenizer_name="gpt2",
+            hugging_face_username="apollo-research",
+            context_size=1024,
+        ),
+        DatasetToPreprocess(
+            source_path="Skylion007/openwebtext",
+            tokenizer_name="EleutherAI/gpt-neox-20b",
+            hugging_face_username="apollo-research",
+            context_size=2048,
+        ),
+        DatasetToPreprocess(
+            source_path="monology/pile-uncopyrighted",
+            tokenizer_name="gpt2",
+            hugging_face_username="apollo-research",
+            context_size=1024,
+            # Get just the first few (each file is 11GB so this should be enough for a large dataset)
+            data_files=[
+                "train/00.jsonl.zst",
+                "train/01.jsonl.zst",
+                "train/02.jsonl.zst",
+                "train/03.jsonl.zst",
+                "train/04.jsonl.zst",
+            ],
+        ),
+        DatasetToPreprocess(
+            source_path="monology/pile-uncopyrighted",
+            tokenizer_name="EleutherAI/gpt-neox-20b",
+            hugging_face_username="apollo-research",
+            private=False,
+            context_size=2048,
+            data_files=[
+                "train/00.jsonl.zst",
+                "train/01.jsonl.zst",
+                "train/02.jsonl.zst",
+                "train/03.jsonl.zst",
+                "train/04.jsonl.zst",
+            ],
+        ),
+    ]
+
+    upload_datasets(datasets)