Create prepare_hidden_states.py

src/dataset_generation/prepare_hidden_states.py

@@ -0,0 +1,349 @@
+"""
+Creates probe training datasets. Output is saved as a csv in the folder `activations/L#/P#` where L and P represent the phase.
+
+
+Example Usage to generate an activation dataset:
+```
+python dataset_generation/prepare_hidden_states.py record_activations data/activations-chessgpt2 201301 austindavis/lichess-uci train austindavis/chessgpt2
+```
+
+Example usage to push local activation dataset to huggingface:
+
+```
+for P in (seq 0 2)
+    for L in (seq 0 12)
+        echo Layer $L Phase $P;
+        python dataset_generation/prepare_hidden_states.py push_to_hub data/activations-chessgpt2 austindavis/chessgpt2-hiddenstates -l $L -p $P;
+    end
+end
+```
+
+"""
+
+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()