Update README.md

README.md

@@ -942,339 +942,10 @@ configs:
 
 This dataset contains the hidden state tensors of the [austindavis/chessGPT2](https://huggingface.co/austindavis/chessGPT2) model recorded during forward passes over the [lichess-uci-fens dataset](https://huggingface.co/datasets/austindavis/lichess-uci-fens/viewer/201301/train) (config: "201301"). 
 
-The generation script was called with:
+This dataset was generated using [prepare_hidden_states.py](https://huggingface.co/datasets/austindavis/chessgpt2-hiddenstates/blob/main/src/dataset_generation/prepare_hidden_states.py) using the following CLI arguments:
 ```sh
-python ~/git/chessold/dataset_generation/prepare_hidden_states.py record_activations data/activations-chessgpt2-fens 201301 austindavis/lichess-uci-fens train austindavis/chessgpt2
+cd src
+python dataset_generation/prepare_hidden_states.py record_activations data/activations-chessgpt2-fens 201301 austindavis/lichess-uci-fens train austindavis/chessgpt2
 ```
 
-The generation script is:
-```python
 
-import argparse
-import os
-import re
-from io import BufferedWriter
-from typing import List, Tuple
-
-import chess
-import datasets
-import numpy as np
-import pandas as pd
-import torch
-from tqdm.auto import tqdm
-from transformers import BatchEncoding, GPT2LMHeadModel, PreTrainedTokenizerFast
-
-from dataset_generation.command_pattern import AbstractCommand, CommandExecutor
-from modeling.chess_utils import uci_to_board
-
-torch._C._set_grad_enabled(False)
-
-FenString = str
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    executor = CommandExecutor(
-        {"record_activations": ActivationDatasetGenerator(), "push_to_hub": HubPusher()}
-    )
-
-    parser = executor.add_commands_to_argparser(parser)
-
-    args = parser.parse_args()
-
-    executor.execute_from_args(args, cfg=args)
-
-
-class HubPusher(AbstractCommand):
-    """Pushes hidden state vectors for given layer and phase to the Huggingface 🤗 Hub"""
-
-    split_name = "train"
-
-    def add_arguments(self, parser):
-        # fmt: off
-        parser.add_argument("data_dir", type=str,help="Directory where processed files are saved") 
-        parser.add_argument("ds_repo", type=str, help="Hf 🤗 repository to which dataset will be published") 
-        parser.add_argument("-l","--layer", type=int, required=False, help="The layer to process")
-        parser.add_argument("-p","--phase", type=int, required=False, help="The phase to process")
-        # fmt: on
-        return parser
-
-    def execute(self, cfg: argparse.Namespace):
-
-        assert cfg.layer is not None
-        assert cfg.phase is not None
-
-        out_dir = lambda L, P: os.path.join(cfg.data_dir, f"L{L}", f"P{P}")
-        file_path = lambda L, P: os.path.join(out_dir(L, P), f"dfs-L{L}-P{P}.csv")
-
-        csv_path = file_path(cfg.layer, cfg.phase)
-
-        ds = datasets.Dataset.from_csv(csv_path, num_proc=16)
-
-        def fix_pos_and_data(pos_str: str, data_str: str):
-            pos_int = int(re.search(r"\d+", pos_str).group())
-            data_str = data_str.replace("\n", " ").strip("[]")
-            try:
-                np_array = np.fromstring(data_str, sep=" ")
-            except ValueError as e:
-                print(f"Error parsing: {e}")
-            return {"pos": pos_int, "data": np_array}
-
-        ds = ds.map(fix_pos_and_data, input_columns=["pos", "data"], num_proc=16)
-
-        config_name = f"layer-{cfg.layer:02}-phase-{cfg.phase}"
-        print(f"Pushing {config_name} to hub")
-        ds.push_to_hub(cfg.ds_repo, config_name=config_name, split=self.split_name)
-
-
-class ActivationDatasetGenerator(AbstractCommand):
-    """Exports activations in CSV format for all layers and phases."""
-
-    cfg: argparse.Namespace
-
-    MOVE_PHASES = [
-        WHITE_FROM,
-        WHITE_TO,
-        WHITE_PROMOTION,
-        # BLACK_FROM,
-        # BLACK_TO,
-        # BLACK_PROMOTION,
-        SPECIAL,
-    ] = range(4)
-    N_PHASES = len(MOVE_PHASES) - 1  # When iterating skip the SPECIAL token
-    START_POS = -6  # only capture state of final 6 tokens from an encoding
-
-    N_LAYERS: int = None
-
-    def add_arguments(self, parser):
-        # fmt: off
-        parser.add_argument("data_dir", type=str, help="Directory where processed files are saved.") 
-        parser.add_argument("ds_config", type=str, help="Hf 🤗 dataset config name (e.g., '202301')") 
-        parser.add_argument("ds_repo", type=str, help="Hf 🤗 dataset repository name (e.g., 'user/repo')") 
-        parser.add_argument("ds_split", type=str, help="Hf 🤗 dataset split name (e.g. 'train')") 
-        parser.add_argument("model_checkpoint", type=str, help="local or Hf 🤗 model used to generate hidden state vectors")
-        parser.add_argument("--start_pos", type=int, default=-6, help="Number of steps from the end of the token sequence to process.")
-        # fmt: on
-        return parser
-
-    def execute(self, cfg: argparse.Namespace):
-
-        self.cfg = cfg
-
-        ########################
-        ## Load model & tokenizer
-        ########################
-
-        model = GPT2LMHeadModel.from_pretrained(cfg.model_checkpoint).train(False).to(torch.device("cuda"))
-
-        self.N_LAYERS = len(model.transformer.h) + 1
-        tokenizer: PreTrainedTokenizerFast = PreTrainedTokenizerFast.from_pretrained(cfg.model_checkpoint)
-
-        ########################
-        ## Load dataset and tokenize
-        ########################
-
-        dataset = (
-            datasets.load_dataset(cfg.ds_repo, name=cfg.ds_config, split=cfg.ds_split)
-            .map(
-                # token count estimate based on 3-phases per ply
-                lambda t: {"num_tokens": 1 + len(t.split()) * 3},
-                input_columns="Transcript",
-                num_proc=16,
-            )
-            .sort("num_tokens", reverse=True)
-            .filter(lambda num_tokens: num_tokens < 512, input_columns="num_tokens")
-        )
-
-        ########################
-        ## Prepare paths and BufferedWriters
-        ########################
-        out_dir = lambda L, P: os.path.join(cfg.data_dir, f"L{L}", f"P{P}")
-        file_path = lambda L, P: os.path.join(out_dir(L, P), f"dfs-L{L}-P{P}.csv")
-
-        for L in range(self.N_LAYERS):
-            for P in range(self.N_PHASES):
-                os.makedirs(out_dir(L, P), exist_ok=True)
-
-        writers: BufferedWriter = [
-            [open(file_path(L, P), "a") for L in range(self.N_LAYERS)] for P in range(self.N_PHASES)
-        ]
-
-        print_headers = True  # only once at the start
-        batch_size = 32
-        for batch_index in tqdm(range(0, len(dataset), batch_size)):
-
-            batch = dataset[batch_index : batch_index + batch_size]
-
-            ########################
-            ## Process Board state
-            ########################
-            # transcript = batch["Transcript"]
-            # fens = batch["Fens"]
-
-            encoding = tokenizer.batch_encode_plus(
-                batch["Transcript"],
-                padding=True,
-                truncation=True,
-                max_length=1024,
-                return_special_tokens_mask=True,
-                return_length=True,
-                return_attention_mask=True,
-                return_token_type_ids=True,
-                return_tensors="pt",
-            )
-
-            ########################
-            ## Process Hidden States
-            ########################
-            hidden_states_by_game = self.transcript_to_hidden_states(encoding, model)
-
-            num_tokens_per_game = encoding.attention_mask.sum(dim=-1)
-            seqn_start_pos_idx = num_tokens_per_game + cfg.start_pos
-
-            selected = torch.stack(
-                [
-                    hidden_states_by_game[i, :, seqn_start_pos_idx[i] : num_tokens_per_game[i]]
-                    for i in range(batch_size)  # TODO raises error on final batch
-                ]
-            )
-
-            ########################
-            ## Process Board States
-            ########################
-
-            phase_by_pos = [[i % 3 for i in range(t)] for t in num_tokens_per_game]
-            try:
-                fen_by_pos = [
-                    (
-                        ["rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"] * 3
-                        + [batch["Fens"][game][i // 3] for i in range(token_count - 3)]
-                    )
-                    for game, token_count in enumerate(num_tokens_per_game)
-                ]
-            except:
-                # We skip games (actually whole batch) if Fens does not contain the correct number of
-                # board states.
-                continue
-
-            fen_by_pos = [fen_by_pos[g][cfg.start_pos :] for g in range(batch_size)]
-            phase_by_pos = [phase_by_pos[g][cfg.start_pos :] for g in range(batch_size)]
-
-            ########################
-            ## Export/append to CSV
-            ########################
-            dfs = list(
-                map(
-                    self.records_to_df,
-                    selected,
-                    seqn_start_pos_idx,
-                    fen_by_pos,
-                    phase_by_pos,
-                    batch["Site"],
-                )
-            )
-            df = pd.concat(dfs)
-
-            for L in range(self.N_LAYERS):
-                for P in range(self.N_PHASES):
-                    LP_subset: pd.DataFrame = df[(df["layer"] == L) & (df["phase"] == P)]
-                    LP_subset.to_csv(writers[P][L], index=False, header=print_headers)
-            print_headers = False
-
-    def transcript_to_hidden_states(
-        self,
-        encoding: BatchEncoding,
-        model: GPT2LMHeadModel,
-    ) -> List[torch.Tensor]:
-        """
-        Converts a batch of uci transcripts into a list of hidden state tensors of
-        shape [batch_size, [n_layer, n_pos, d_model]]
-        """
-        # forward pass
-        outputs = model(**encoding.to("cuda"), output_hidden_states=True)
-
-        # stack hidden states
-        hidden_states = outputs.hidden_states
-        hidden_states = torch.stack(hidden_states, dim=1)
-
-        hidden_states = hidden_states.to("cpu")
-        return hidden_states
-
-    def hidden_states_to_records(
-        self, hidden_state_tensors: torch.Tensor, min_pos: int
-    ) -> Tuple[tuple, torch.Tensor]:
-        r"""Flattens the hidden state tensor into a list of tensors.
-        Iteration is like:
-            original[L,P] === records[P*9+L]
-
-        Example::
-
-            >>> indices, records = hidden_states_to_records(output)
-            >>> k = 15
-            >>> L, P = indices[k]
-            >>> print(f"L: {L}, P: {P}")
-            L: 6, P: 1
-            >>> print(sum(abs(records[k]-records[P*9+L])))
-            tensor(0.)
-            >>> print(sum(abs(output[L,P]-records[P*9+L])))
-            tensor(0.)
-        """
-
-        n_layer, n_pos, d_model = hidden_state_tensors.shape
-        records = hidden_state_tensors.permute(1, 0, 2).reshape(-1, d_model).unbind()
-        indices = [(L, P + min_pos) for P in range(n_pos) for L in range(n_layer)]
-        return indices, records
-
-    def trim_hidden_states(
-        self, hs: torch.Tensor, pos_start: int = -6, pos_end: int = None
-    ) -> Tuple[torch.Tensor, int]:
-        n_pos = hs.shape[1]
-        hs = hs[:, pos_start:]
-        return hs, n_pos + pos_start
-
-    def diff(self, x):
-        return x[1] - x[0]
-
-    def get_board_fens_by_pos(self, transcript: str, num_tokens: int):
-
-        board_stack: List[FenString] = uci_to_board(
-            transcript.lower(),
-            as_board_stack=True,
-            force=False,
-            verbose=False,
-            map_function=chess.Board.fen,
-        )
-
-        fens_by_pos: List[str] = [board_stack[0]]  # always include 1st board
-        phases_by_pos: List[int] = [self.SPECIAL]  # first phase is SPECIAL <|startoftext|> token
-
-        fens_by_pos += [board_stack[(i // 3)] for i in range(num_tokens - 1)]
-        phases_by_pos += [i % 3 for i in range(num_tokens - 1)]
-
-        return fens_by_pos, phases_by_pos
-
-    def records_to_df(
-        self,
-        hidden_states: torch.Tensor,
-        seqn_start_pos: Tuple[torch.Tensor],
-        fen_by_pos,
-        phase_by_pos,
-        site,
-    ):
-
-        n_layer, n_pos, d_model = hidden_states.shape
-        records: tuple[torch.Tensor] = hidden_states.permute(1, 0, 2).reshape(-1, d_model).unbind()
-        indices = [(L, P + seqn_start_pos) for P in range(n_pos) for L in range(n_layer)]
-
-        df = pd.DataFrame(indices, columns=["layer", "pos"])
-        n_layer = max(df["layer"]) + 1
-        df["phase"] = [phase_by_pos[i // n_layer] for i in range(len(phase_by_pos) * n_layer)]
-        df["site"] = [site] * len(df)
-        df["fen"] = [fen_by_pos[i // n_layer] for i in range(len(fen_by_pos) * n_layer)]
-        df["data"] = [r.numpy() for r in records]
-        return df
-
-
-if __name__ == "__main__":
-    main()
-```