sae-lens 6.26.1__py3-none-any.whl → 6.28.1__py3-none-any.whl

sae_lens/synthetic/training.py

@@ -0,0 +1,145 @@
+from collections.abc import Iterator
+from pathlib import Path
+from typing import Any, Callable
+
+import torch
+
+from sae_lens.config import LoggingConfig, SAETrainerConfig
+from sae_lens.saes.sae import TrainingSAE
+from sae_lens.synthetic.activation_generator import ActivationGenerator
+from sae_lens.synthetic.feature_dictionary import FeatureDictionary
+from sae_lens.training.sae_trainer import SAETrainer, SaveCheckpointFn
+
+
+def train_toy_sae(
+    sae: TrainingSAE[Any],
+    feature_dict: FeatureDictionary,
+    activations_generator: ActivationGenerator,
+    training_samples: int = 10_000_000,
+    batch_size: int = 1024,
+    lr: float = 3e-4,
+    lr_warm_up_steps: int = 0,
+    lr_decay_steps: int = 0,
+    device: str | torch.device = "cpu",
+    n_snapshots: int = 0,
+    snapshot_fn: Callable[[SAETrainer[Any, Any]], None] | None = None,
+) -> None:
+    """
+    Train an SAE on synthetic activations from a feature dictionary.
+
+    This is a convenience function that sets up the training loop with
+    sensible defaults for small-scale synthetic data experiments.
+
+    Args:
+        sae: The TrainingSAE to train
+        feature_dict: The feature dictionary that maps feature activations to
+            hidden activations
+        activations_generator: Generator that produces feature activations
+        training_samples: Total number of training samples
+        batch_size: Batch size for training
+        lr: Learning rate
+        lr_warm_up_steps: Number of warmup steps for learning rate
+        lr_decay_steps: Number of steps over which to decay learning rate
+        device: Device to train on
+        n_snapshots: Number of snapshots to take during training. Snapshots are
+            evenly spaced throughout training.
+        snapshot_fn: Callback function called at each snapshot point. Receives
+            the SAETrainer instance, allowing access to the SAE, training step,
+            and other training state. Required if n_snapshots > 0.
+    """
+
+    device_str = str(device) if isinstance(device, torch.device) else device
+
+    # Create data iterator
+    data_iterator = SyntheticActivationIterator(
+        feature_dict=feature_dict,
+        activations_generator=activations_generator,
+        batch_size=batch_size,
+    )
+
+    # Create trainer config
+    trainer_cfg = SAETrainerConfig(
+        n_checkpoints=n_snapshots,
+        checkpoint_path=None,
+        save_final_checkpoint=False,
+        total_training_samples=training_samples,
+        device=device_str,
+        autocast=False,
+        lr=lr,
+        lr_end=lr,
+        lr_scheduler_name="constant",
+        lr_warm_up_steps=lr_warm_up_steps,
+        adam_beta1=0.9,
+        adam_beta2=0.999,
+        lr_decay_steps=lr_decay_steps,
+        n_restart_cycles=1,
+        train_batch_size_samples=batch_size,
+        dead_feature_window=1000,
+        feature_sampling_window=2000,
+        logger=LoggingConfig(
+            log_to_wandb=False,
+            # hacky way to disable evals, but works for now
+            eval_every_n_wandb_logs=2**31 - 1,
+        ),
+    )
+
+    def snapshot_wrapper(
+        snapshot_fn: Callable[[SAETrainer[Any, Any]], None] | None,
+    ) -> SaveCheckpointFn:
+        def save_checkpoint(checkpoint_path: Path | None) -> None:  # noqa: ARG001
+            if snapshot_fn is None:
+                raise ValueError("snapshot_fn must be provided to take snapshots")
+            snapshot_fn(trainer)
+
+        return save_checkpoint
+
+    # Create trainer and train
+    feature_dict.eval()
+    trainer = SAETrainer(
+        cfg=trainer_cfg,
+        sae=sae,
+        data_provider=data_iterator,
+        save_checkpoint_fn=snapshot_wrapper(snapshot_fn),
+    )
+
+    trainer.fit()
+
+
+class SyntheticActivationIterator(Iterator[torch.Tensor]):
+    """
+    An iterator that generates synthetic activations for SAE training.
+
+    This iterator wraps a FeatureDictionary and a function that generates
+    feature activations, producing hidden activations that can be used
+    to train an SAE.
+    """
+
+    def __init__(
+        self,
+        feature_dict: FeatureDictionary,
+        activations_generator: ActivationGenerator,
+        batch_size: int,
+    ):
+        """
+        Create a new SyntheticActivationIterator.
+
+        Args:
+            feature_dict: The feature dictionary to use for generating hidden activations
+            activations_generator: Generator that produces feature activations
+            batch_size: Number of samples per batch
+        """
+        self.feature_dict = feature_dict
+        self.activations_generator = activations_generator
+        self.batch_size = batch_size
+
+    @torch.no_grad()
+    def next_batch(self) -> torch.Tensor:
+        """Generate the next batch of hidden activations."""
+        features = self.activations_generator(self.batch_size)
+        return self.feature_dict(features)
+
+    def __iter__(self) -> "SyntheticActivationIterator":
+        return self
+
+    def __next__(self) -> torch.Tensor:
+        return self.next_batch()

sae_lens/tokenization_and_batching.py

@@ -85,8 +85,8 @@ def concat_and_batch_sequences(
         for sequence in tokens_iterator:
             if (
                 begin_sequence_token_id is not None
-                and sequence[0] != begin_sequence_token_id
                 and len(sequence) >= context_size - 1
+                and sequence[0] != begin_sequence_token_id
             ):
                 begin_sequence_token_id_tensor = torch.tensor(
                     [begin_sequence_token_id],

sae_lens/training/activations_store.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import json
 import os
 import warnings
-from collections.abc import Generator, Iterator, Sequence
+from collections.abc import Generator, Iterator
 from pathlib import Path
 from typing import Any, Literal, cast
 
@@ -148,6 +148,7 @@ class ActivationsStore:
             exclude_special_tokens=exclude_special_tokens,
             disable_concat_sequences=cfg.disable_concat_sequences,
             sequence_separator_token=cfg.sequence_separator_token,
+            activations_mixing_fraction=cfg.activations_mixing_fraction,
         )
 
     @classmethod
@@ -222,6 +223,7 @@ class ActivationsStore:
         exclude_special_tokens: torch.Tensor | None = None,
         disable_concat_sequences: bool = False,
         sequence_separator_token: int | Literal["bos", "eos", "sep"] | None = "bos",
+        activations_mixing_fraction: float = 0.5,
     ):
         self.model = model
         if model_kwargs is None:
@@ -252,7 +254,6 @@ class ActivationsStore:
         self.context_size = context_size
         self.d_in = d_in
         self.n_batches_in_buffer = n_batches_in_buffer
-        self.half_buffer_size = n_batches_in_buffer // 2
         self.total_training_tokens = total_training_tokens
         self.store_batch_size_prompts = store_batch_size_prompts
         self.train_batch_size_tokens = train_batch_size_tokens
@@ -269,6 +270,7 @@ class ActivationsStore:
         self.sequence_separator_token: int | Literal["bos", "eos", "sep"] | None = (
             sequence_separator_token
         )
+        self.activations_mixing_fraction = activations_mixing_fraction
 
         self.n_dataset_processed = 0
 
@@ -535,18 +537,15 @@ class ActivationsStore:
 
         return stacked_activations
 
-    def _load_buffer_from_cached(
+    def _load_raw_llm_batch_from_cached(
         self,
-        total_size: int,
-        context_size: int,
-        d_in: int,
         raise_on_epoch_end: bool,
     ) -> tuple[
         torch.Tensor,
         torch.Tensor | None,
     ]:
         """
-        Loads `total_size` activations from `cached_activation_dataset`
+        Loads a batch of activations from `cached_activation_dataset`
 
         The dataset has columns for each hook_name,
         each containing activations of shape (context_size, d_in).
@@ -554,6 +553,10 @@ class ActivationsStore:
         raises StopIteration
         """
         assert self.cached_activation_dataset is not None
+        context_size = self.context_size
+        batch_size = self.store_batch_size_prompts
+        d_in = self.d_in
+
         # In future, could be a list of multiple hook names
         if self.hook_name not in self.cached_activation_dataset.column_names:
             raise ValueError(
@@ -561,138 +564,100 @@ class ActivationsStore:
                 f"got {self.cached_activation_dataset.column_names}."
             )
 
-        if self.current_row_idx > len(self.cached_activation_dataset) - total_size:
+        if self.current_row_idx > len(self.cached_activation_dataset) - batch_size:
             self.current_row_idx = 0
             if raise_on_epoch_end:
                 raise StopIteration
 
-        new_buffer = []
         ds_slice = self.cached_activation_dataset[
-            self.current_row_idx : self.current_row_idx + total_size
+            self.current_row_idx : self.current_row_idx + batch_size
         ]
         # Load activations for each hook.
         # Usually faster to first slice dataset then pick column
-        new_buffer = ds_slice[self.hook_name]
-        if new_buffer.shape != (total_size, context_size, d_in):
+        acts_buffer = ds_slice[self.hook_name]
+        if acts_buffer.shape != (batch_size, context_size, d_in):
             raise ValueError(
-                f"new_buffer has shape {new_buffer.shape}, "
-                f"but expected ({total_size}, {context_size}, {d_in})."
+                f"acts_buffer has shape {acts_buffer.shape}, "
+                f"but expected ({batch_size}, {context_size}, {d_in})."
             )
 
-        self.current_row_idx += total_size
-        acts_buffer = new_buffer.reshape(total_size * context_size, d_in)
+        self.current_row_idx += batch_size
+        acts_buffer = acts_buffer.reshape(batch_size * context_size, d_in)
 
         if "token_ids" not in self.cached_activation_dataset.column_names:
             return acts_buffer, None
 
         token_ids_buffer = ds_slice["token_ids"]
-        if token_ids_buffer.shape != (total_size, context_size):
+        if token_ids_buffer.shape != (batch_size, context_size):
             raise ValueError(
                 f"token_ids_buffer has shape {token_ids_buffer.shape}, "
-                f"but expected ({total_size}, {context_size})."
+                f"but expected ({batch_size}, {context_size})."
             )
-        token_ids_buffer = token_ids_buffer.reshape(total_size * context_size)
+        token_ids_buffer = token_ids_buffer.reshape(batch_size * context_size)
         return acts_buffer, token_ids_buffer
 
     @torch.no_grad()
-    def get_raw_buffer(
+    def get_raw_llm_batch(
         self,
-        n_batches_in_buffer: int,
         raise_on_epoch_end: bool = False,
-        shuffle: bool = True,
     ) -> tuple[torch.Tensor, torch.Tensor | None]:
         """
-        Loads the next n_batches_in_buffer batches of activations into a tensor and returns it.
+        Loads the next batch of activations from the LLM and returns it.
 
-        The primary purpose here is maintaining a shuffling buffer.
+        If raise_on_epoch_end is True, when the dataset is exhausted it will
+        automatically refill the dataset and then raise a StopIteration so that
+        the caller has a chance to react.
 
-        If raise_on_epoch_end is True, when the dataset it exhausted it will automatically refill the dataset and then raise a StopIteration so that the caller has a chance to react.
+        Returns:
+            Tuple of (activations, token_ids) where activations has shape
+            (batch_size * context_size, d_in) and token_ids has shape
+            (batch_size * context_size,).
         """
-        context_size = self.context_size
-        batch_size = self.store_batch_size_prompts
         d_in = self.d_in
-        total_size = batch_size * n_batches_in_buffer
 
         if self.cached_activation_dataset is not None:
-            return self._load_buffer_from_cached(
-                total_size, context_size, d_in, raise_on_epoch_end
-            )
+            return self._load_raw_llm_batch_from_cached(raise_on_epoch_end)
 
-        refill_iterator = range(0, total_size, batch_size)
-        # Initialize empty tensor buffer of the maximum required size with an additional dimension for layers
-        new_buffer_activations = torch.zeros(
-            (total_size, self.training_context_size, d_in),
-            dtype=self.dtype,  # type: ignore
-            device=self.device,
-        )
-        new_buffer_token_ids = torch.zeros(
-            (total_size, self.training_context_size),
-            dtype=torch.long,
-            device=self.device,
+        # move batch toks to gpu for model
+        batch_tokens = self.get_batch_tokens(raise_at_epoch_end=raise_on_epoch_end).to(
+            _get_model_device(self.model)
         )
+        activations = self.get_activations(batch_tokens).to(self.device)
 
-        for refill_batch_idx_start in tqdm(
-            refill_iterator, leave=False, desc="Refilling buffer"
-        ):
-            # move batch toks to gpu for model
-            refill_batch_tokens = self.get_batch_tokens(
-                raise_at_epoch_end=raise_on_epoch_end
-            ).to(_get_model_device(self.model))
-            refill_activations = self.get_activations(refill_batch_tokens)
-            # move acts back to cpu
-            refill_activations.to(self.device)
-            new_buffer_activations[
-                refill_batch_idx_start : refill_batch_idx_start + batch_size, ...
-            ] = refill_activations
-
-            # handle seqpos_slice, this is done for activations in get_activations
-            refill_batch_tokens = refill_batch_tokens[:, slice(*self.seqpos_slice)]
-            new_buffer_token_ids[
-                refill_batch_idx_start : refill_batch_idx_start + batch_size, ...
-            ] = refill_batch_tokens
-
-        new_buffer_activations = new_buffer_activations.reshape(-1, d_in)
-        new_buffer_token_ids = new_buffer_token_ids.reshape(-1)
-        if shuffle:
-            new_buffer_activations, new_buffer_token_ids = permute_together(
-                [new_buffer_activations, new_buffer_token_ids]
-            )
+        # handle seqpos_slice, this is done for activations in get_activations
+        batch_tokens = batch_tokens[:, slice(*self.seqpos_slice)]
 
-        return (
-            new_buffer_activations,
-            new_buffer_token_ids,
-        )
+        # reshape from (batch, context, d_in) to (batch * context, d_in)
+        activations = activations.reshape(-1, d_in)
+        token_ids = batch_tokens.reshape(-1)
 
-    def get_filtered_buffer(
+        return activations, token_ids
+
+    def get_filtered_llm_batch(
         self,
-        n_batches_in_buffer: int,
         raise_on_epoch_end: bool = False,
-        shuffle: bool = True,
     ) -> torch.Tensor:
+        """
+        Get a batch of LLM activations with special tokens filtered out.
+        """
         return _filter_buffer_acts(
-            self.get_raw_buffer(
-                n_batches_in_buffer=n_batches_in_buffer,
-                raise_on_epoch_end=raise_on_epoch_end,
-                shuffle=shuffle,
-            ),
+            self.get_raw_llm_batch(raise_on_epoch_end=raise_on_epoch_end),
             self.exclude_special_tokens,
         )
 
     def _iterate_filtered_activations(self) -> Generator[torch.Tensor, None, None]:
         """
-        Iterate over the filtered tokens in the buffer.
+        Iterate over filtered LLM activation batches.
         """
         while True:
             try:
-                yield self.get_filtered_buffer(
-                    self.half_buffer_size, raise_on_epoch_end=True
-                )
+                yield self.get_filtered_llm_batch(raise_on_epoch_end=True)
             except StopIteration:
                 warnings.warn(
                     "All samples in the training dataset have been exhausted, beginning new epoch."
                 )
                 try:
-                    yield self.get_filtered_buffer(self.half_buffer_size)
+                    yield self.get_filtered_llm_batch()
                 except StopIteration:
                     raise ValueError(
                         "Unable to fill buffer after starting new epoch. Dataset may be too small."
@@ -708,6 +673,7 @@ class ActivationsStore:
             buffer_size=self.n_batches_in_buffer * self.training_context_size,
             batch_size=self.train_batch_size_tokens,
             activations_loader=self._iterate_filtered_activations(),
+            mix_fraction=self.activations_mixing_fraction,
         )
 
     def next_batch(self) -> torch.Tensor:
@@ -823,9 +789,3 @@ def _filter_buffer_acts(
 
     mask = torch.isin(tokens, exclude_tokens)
     return activations[~mask]
-
-
-def permute_together(tensors: Sequence[torch.Tensor]) -> tuple[torch.Tensor, ...]:
-    """Permute tensors together."""
-    permutation = torch.randperm(tensors[0].shape[0])
-    return tuple(t[permutation] for t in tensors)

sae_lens/training/mixing_buffer.py

@@ -8,15 +8,19 @@ def mixing_buffer(
     buffer_size: int,
     batch_size: int,
     activations_loader: Iterator[torch.Tensor],
+    mix_fraction: float = 0.5,
 ) -> Iterator[torch.Tensor]:
     """
     A generator that maintains a mix of old and new activations for better training.
-    It stores half of the activations and mixes them with new ones to create batches.
+    It keeps a portion of activations and mixes them with new ones to create batches.
 
     Args:
-        buffer_size: Total size of the buffer (will store buffer_size/2 activations)
+        buffer_size: Total size of the buffer
         batch_size: Size of batches to return
         activations_loader: Iterator providing new activations
+        mix_fraction: Fraction of buffer to keep for mixing (default 0.5).
+                      Higher values mean more temporal mixing but slower throughput.
+                      If 0, no shuffling occurs (passthrough mode).
 
     Yields:
         Batches of activations of shape (batch_size, *activation_dims)
@@ -24,6 +28,8 @@ def mixing_buffer(
 
     if buffer_size < batch_size:
         raise ValueError("Buffer size must be greater than or equal to batch size")
+    if not 0 <= mix_fraction <= 1:
+        raise ValueError("mix_fraction must be in [0, 1]")
 
     storage_buffer: torch.Tensor | None = None
 
@@ -35,10 +41,13 @@ def mixing_buffer(
         )
 
         if storage_buffer.shape[0] >= buffer_size:
-            # Shuffle
-            storage_buffer = storage_buffer[torch.randperm(storage_buffer.shape[0])]
+            if mix_fraction > 0:
+                storage_buffer = storage_buffer[torch.randperm(storage_buffer.shape[0])]
 
-            num_serving_batches = max(1, storage_buffer.shape[0] // (2 * batch_size))
+            # Keep a fixed amount for mixing, serve the rest
+            keep_for_mixing = int(buffer_size * mix_fraction)
+            num_to_serve = storage_buffer.shape[0] - keep_for_mixing
+            num_serving_batches = max(1, num_to_serve // batch_size)
             serving_cutoff = num_serving_batches * batch_size
             serving_buffer = storage_buffer[:serving_cutoff]
             storage_buffer = storage_buffer[serving_cutoff:]

sae_lens/training/sae_trainer.py

@@ -55,7 +55,7 @@ Evaluator = Callable[[T_TRAINING_SAE, DataProvider, ActivationScaler], dict[str,
 
 class SAETrainer(Generic[T_TRAINING_SAE, T_TRAINING_SAE_CONFIG]):
     """
-    Core SAE class used for inference. For training, see TrainingSAE.
+    Trainer for Sparse Autoencoder (SAE) models.
     """
 
     data_provider: DataProvider

sae_lens/util.py

@@ -95,8 +95,10 @@ def get_special_token_ids(tokenizer: PreTrainedTokenizerBase) -> list[int]:
     return list(special_tokens)
 
 
-def str_to_dtype(dtype: str) -> torch.dtype:
+def str_to_dtype(dtype: str | torch.dtype) -> torch.dtype:
     """Convert a string to a torch.dtype."""
+    if isinstance(dtype, torch.dtype):
+        return dtype
     if dtype not in DTYPE_MAP:
         raise ValueError(
             f"Invalid dtype: {dtype}. Must be one of {list(DTYPE_MAP.keys())}"
@@ -111,3 +113,26 @@ def dtype_to_str(dtype: torch.dtype) -> str:
             f"Invalid dtype: {dtype}. Must be one of {list(DTYPE_TO_STR.keys())}"
         )
     return DTYPE_TO_STR[dtype]
+
+
+def cosine_similarities(
+    mat1: torch.Tensor, mat2: torch.Tensor | None = None
+) -> torch.Tensor:
+    """
+    Compute cosine similarities between each row of mat1 and each row of mat2.
+
+    Args:
+        mat1: Tensor of shape [n1, d]
+        mat2: Tensor of shape [n2, d]. If not provided, mat1 = mat2
+
+    Returns:
+        Tensor of shape [n1, n2] with cosine similarities
+    """
+    if mat2 is None:
+        mat2 = mat1
+    # Clamp norm to 1e-8 to prevent division by zero. This threshold is chosen
+    # to be small enough to not affect normal vectors but large enough to avoid
+    # numerical instability. Zero vectors will effectively map to zero similarity.
+    mat1_normed = mat1 / mat1.norm(dim=1, keepdim=True).clamp(min=1e-8)
+    mat2_normed = mat2 / mat2.norm(dim=1, keepdim=True).clamp(min=1e-8)
+    return mat1_normed @ mat2_normed.T

{sae_lens-6.26.1.dist-info → sae_lens-6.28.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sae-lens
-Version: 6.26.1
+Version: 6.28.1
 Summary: Training and Analyzing Sparse Autoencoders (SAEs)
 License: MIT
 License-File: LICENSE
@@ -77,6 +77,8 @@ The new v6 update is a major refactor to SAELens and changes the way training co
   [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://githubtocolab.com/decoderesearch/SAELens/blob/main/tutorials/logits_lens_with_features.ipynb)
 - [Training a Sparse Autoencoder](tutorials/training_a_sparse_autoencoder.ipynb)
   [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://githubtocolab.com/decoderesearch/SAELens/blob/main/tutorials/training_a_sparse_autoencoder.ipynb)
+- [Training SAEs on Synthetic Data](tutorials/training_saes_on_synthetic_data.ipynb)
+  [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://githubtocolab.com/decoderesearch/SAELens/blob/main/tutorials/training_saes_on_synthetic_data.ipynb)
 
 ## Join the Slack!
 

sae_lens-6.28.1.dist-info/RECORD

@@ -0,0 +1,52 @@
+sae_lens/__init__.py,sha256=S-AS72IxkvKO-wItRQjuyczikDxmfDaUgXRSfu5PU-o,4788
+sae_lens/analysis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sae_lens/analysis/hooked_sae_transformer.py,sha256=dQRgGVwce8XwylL2AzJE7l9elhtMRFCs2hdUj-Qyy4g,14038
+sae_lens/analysis/neuronpedia_integration.py,sha256=Gx1W7hUBEuMoasNcnOnZ1wmqbXDd1pSZ1nqKEya1HQc,4962
+sae_lens/cache_activations_runner.py,sha256=TjqNWIc46Nw09jHWFjzQzgzG5wdu_87Ahe-iFjI5_0Q,13117
+sae_lens/config.py,sha256=sseYcRMsAyopj8FICup1RGTXjFxzAithZ2OH7OpQV3Y,30839
+sae_lens/constants.py,sha256=CM-h9AjZNAl2aP7hVpKk7YsFHpu-_Lfhhmq2d5qPEVc,887
+sae_lens/evals.py,sha256=P0NUsJeGzYxFBiVKhbPzd72IFKY4gH40HHlEZ3jEAmg,39598
+sae_lens/llm_sae_training_runner.py,sha256=M7BK55gSFYu2qFQKABHX3c8i46P1LfODCeyHFzGGuqU,15196
+sae_lens/load_model.py,sha256=C8AMykctj6H7tz_xRwB06-EXj6TfW64PtSJZR5Jxn1Y,8649
+sae_lens/loading/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sae_lens/loading/pretrained_sae_loaders.py,sha256=hHMlew1u6zVlbzvS9S_SfUPnAG0_OAjjIcjoUTIUZrU,63657
+sae_lens/loading/pretrained_saes_directory.py,sha256=1at_aQbD8WFywchQCKuwfP-yvCq_Z2aUYrpKDnSN5Nc,4283
+sae_lens/pretokenize_runner.py,sha256=amJwIz3CKi2s2wNQn-10E7eAV7VFhNqtFDNTeTkwEI8,7133
+sae_lens/pretrained_saes.yaml,sha256=Hn8jXwZ7V6QQxzgu41LFEP-LAzuDxwYL5vhoar-pPX8,1509922
+sae_lens/registry.py,sha256=nhy7BPSudSATqW4lo9H_k3Na7sfGHmAf9v-3wpnLL_o,1490
+sae_lens/saes/__init__.py,sha256=SBqPaP6Gl5uPFwHlumAZATC4Wd26xKIYLAAAo4MSa5Q,2200
+sae_lens/saes/batchtopk_sae.py,sha256=x4EbgZl0GUickRPcCmtKNGS2Ra3Uy1Z1OtF2FnrSabQ,5422
+sae_lens/saes/gated_sae.py,sha256=V_2ZNlV4gRD-rX5JSx1xqY7idT8ChfdQ5yxWDdu_6hg,8826
+sae_lens/saes/jumprelu_sae.py,sha256=miiF-xI_yXdV9EkKjwAbU9zSMsx9KtKCz5YdXEzkN8g,13313
+sae_lens/saes/matching_pursuit_sae.py,sha256=08_G9p1YMLnE5qZVCPp6gll-iG6nHRbMMASf4_bkFt8,13207
+sae_lens/saes/matryoshka_batchtopk_sae.py,sha256=Qr6htt1HHOuO9FXI9hyaPSnGFIiJG-v7y1t1CEmkFzM,5995
+sae_lens/saes/sae.py,sha256=xRmgiLuaFlDCv8SyLbL-5TwdrWHpNLqSGe8mC1L6WcI,40942
+sae_lens/saes/standard_sae.py,sha256=_hldNZkFPAf9VGrxouR1-tN8T2OEk8IkWBcXoatrC1o,5749
+sae_lens/saes/temporal_sae.py,sha256=83Ap4mYGfdN3sKdPF8nKjhdXph3-7E2QuLobqJ_YuoM,13273
+sae_lens/saes/topk_sae.py,sha256=vrMRPrCQR1o8G_kXqY_EAoGZARupkQNFB2dNZVLsusE,21073
+sae_lens/saes/transcoder.py,sha256=CTpJs8ASOK06npih7gZHygZuxqTR7HICWlOYfTiKjI4,13501
+sae_lens/synthetic/__init__.py,sha256=FGUasB6fLPXRFCcrtKfL7vCKDOWebZ5Rx5F9QNJZklI,2875
+sae_lens/synthetic/activation_generator.py,sha256=thWGTwRmhu0K8m66WfJUajHmuIPHkwV4_HjmG0dL3G8,7638
+sae_lens/synthetic/correlation.py,sha256=odr-S5h6c2U-bepwrAQeMfV1iBF_cnnQzqw7zapEXZ4,6056
+sae_lens/synthetic/evals.py,sha256=Nhi314ZnRgLfhBj-3tm_zzI-pGyFTcwllDXbIpPFXeU,4584
+sae_lens/synthetic/feature_dictionary.py,sha256=2A9wqdT1KejRLuIoFWdoiWdDtaHHgIluaKsHGizsVxI,4864
+sae_lens/synthetic/firing_probabilities.py,sha256=yclz1pWl5gE1r8LAxFvzQS88Lxwk5-3r8BCX9HLVejA,3370
+sae_lens/synthetic/hierarchy.py,sha256=dlQdPnnG3VzQDB3QOaqSXwoH8Ij2ioxmTlZg1lXHaRQ,11754
+sae_lens/synthetic/initialization.py,sha256=orMGW-786wRDHIS2W7bEH0HmlVFQ4g2z4bnnwdv5w4s,1386
+sae_lens/synthetic/plotting.py,sha256=5lFrej1QOkGAcImFNo5-o-8mI_rUVqvEI57KzUQPPtQ,8208
+sae_lens/synthetic/training.py,sha256=Bg6NYxdzifq_8g-dJQSZ_z_TXDdGRtEi7tqNDb-gCVc,4986
+sae_lens/tokenization_and_batching.py,sha256=uoHtAs9z3XqG0Fh-iQVYVlrbyB_E3kFFhrKU30BosCo,5438
+sae_lens/training/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sae_lens/training/activation_scaler.py,sha256=FzNfgBplLWmyiSlZ6TUvE-nur3lOiGTrlvC97ys8S24,1973
+sae_lens/training/activations_store.py,sha256=kp4-6R4rTJUSt-g-Ifg5B1h7iIe7jZj-XQSKDvDpQMI,32187
+sae_lens/training/mixing_buffer.py,sha256=1Z-S2CcQXMWGxRZJFnXeZFxbZcALkO_fP6VO37XdJQQ,2519
+sae_lens/training/optim.py,sha256=bJpqqcK4enkcPvQAJkeH4Ci1LUOlfjIMTv6-IlaAbRA,5588
+sae_lens/training/sae_trainer.py,sha256=iiGrNwmiX0xSHnJit0lH66yQzB6q8Fww1WNJZbTSBGY,17579
+sae_lens/training/types.py,sha256=1FpLx_Doda9vZpmfm-x1e8wGBYpyhe9Kpb_JuM5nIFM,90
+sae_lens/training/upload_saes_to_huggingface.py,sha256=r_WzI1zLtGZ5TzAxuG3xa_8T09j3zXJrWd_vzPsPGkQ,4469
+sae_lens/tutorial/tsea.py,sha256=fd1am_XXsf2KMbByDapJo-2qlxduKaa62Z2qcQZ3QKU,18145
+sae_lens/util.py,sha256=oIMoeyEP2IzcPFmRbKUzOAycgEyMcOasGeO_BGVZbc4,4846
+sae_lens-6.28.1.dist-info/METADATA,sha256=OdPVG1dwWoLGqiutKkAJGazfBLLbYQLBUbs_3h58BKg,5633
+sae_lens-6.28.1.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+sae_lens-6.28.1.dist-info/licenses/LICENSE,sha256=DW6e-hDosiu4CfW0-imI57sV1I5f9UEslpviNQcOAKs,1069
+sae_lens-6.28.1.dist-info/RECORD,,

sae_lens-6.26.1.dist-info/RECORD

@@ -1,42 +0,0 @@
-sae_lens/__init__.py,sha256=zRp1nmb41W1Pt1rvlKvRWw73UxjGyz1iHAzH9_X6_WQ,4725
-sae_lens/analysis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sae_lens/analysis/hooked_sae_transformer.py,sha256=dQRgGVwce8XwylL2AzJE7l9elhtMRFCs2hdUj-Qyy4g,14038
-sae_lens/analysis/neuronpedia_integration.py,sha256=Gx1W7hUBEuMoasNcnOnZ1wmqbXDd1pSZ1nqKEya1HQc,4962
-sae_lens/cache_activations_runner.py,sha256=Lvlz-k5-3XxVRtUdC4b1CiKyx5s0ckLa8GDGv9_kcxs,12566
-sae_lens/config.py,sha256=C982bUELhGHcfTwzeMTtXIf2hPtc946thYpUyctLiBo,30516
-sae_lens/constants.py,sha256=CM-h9AjZNAl2aP7hVpKk7YsFHpu-_Lfhhmq2d5qPEVc,887
-sae_lens/evals.py,sha256=P0NUsJeGzYxFBiVKhbPzd72IFKY4gH40HHlEZ3jEAmg,39598
-sae_lens/llm_sae_training_runner.py,sha256=M7BK55gSFYu2qFQKABHX3c8i46P1LfODCeyHFzGGuqU,15196
-sae_lens/load_model.py,sha256=C8AMykctj6H7tz_xRwB06-EXj6TfW64PtSJZR5Jxn1Y,8649
-sae_lens/loading/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sae_lens/loading/pretrained_sae_loaders.py,sha256=hq-dhxsEdUmlAnZEiZBqX7lNyQQwZ6KXmXZWpzAc5FY,63638
-sae_lens/loading/pretrained_saes_directory.py,sha256=hejNfLUepYCSGPalRfQwxxCEUqMMUPsn1tufwvwct5k,3820
-sae_lens/pretokenize_runner.py,sha256=amJwIz3CKi2s2wNQn-10E7eAV7VFhNqtFDNTeTkwEI8,7133
-sae_lens/pretrained_saes.yaml,sha256=Hn8jXwZ7V6QQxzgu41LFEP-LAzuDxwYL5vhoar-pPX8,1509922
-sae_lens/registry.py,sha256=nhy7BPSudSATqW4lo9H_k3Na7sfGHmAf9v-3wpnLL_o,1490
-sae_lens/saes/__init__.py,sha256=SBqPaP6Gl5uPFwHlumAZATC4Wd26xKIYLAAAo4MSa5Q,2200
-sae_lens/saes/batchtopk_sae.py,sha256=x4EbgZl0GUickRPcCmtKNGS2Ra3Uy1Z1OtF2FnrSabQ,5422
-sae_lens/saes/gated_sae.py,sha256=mHnmw-RD7hqIbP9_EBj3p2SK0OqQIkZivdOKRygeRgw,8825
-sae_lens/saes/jumprelu_sae.py,sha256=udjGHp3WTABQSL2Qq57j-bINWX61GCmo68EmdjMOXoo,13310
-sae_lens/saes/matching_pursuit_sae.py,sha256=08_G9p1YMLnE5qZVCPp6gll-iG6nHRbMMASf4_bkFt8,13207
-sae_lens/saes/matryoshka_batchtopk_sae.py,sha256=Qr6htt1HHOuO9FXI9hyaPSnGFIiJG-v7y1t1CEmkFzM,5995
-sae_lens/saes/sae.py,sha256=fzXv8lwHskSxsf8hm_wlKPkpq50iafmBjBNQzwZ6a00,40050
-sae_lens/saes/standard_sae.py,sha256=nEVETwAmRD2tyX7ESIic1fij48gAq1Dh7s_GQ2fqCZ4,5747
-sae_lens/saes/temporal_sae.py,sha256=DsecivcHWId-MTuJpQbz8OhqtmGhZACxJauYZGHo0Ok,13272
-sae_lens/saes/topk_sae.py,sha256=vrMRPrCQR1o8G_kXqY_EAoGZARupkQNFB2dNZVLsusE,21073
-sae_lens/saes/transcoder.py,sha256=CTpJs8ASOK06npih7gZHygZuxqTR7HICWlOYfTiKjI4,13501
-sae_lens/tokenization_and_batching.py,sha256=D_o7cXvRqhT89H3wNzoRymNALNE6eHojBWLdXOUwUGE,5438
-sae_lens/training/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sae_lens/training/activation_scaler.py,sha256=FzNfgBplLWmyiSlZ6TUvE-nur3lOiGTrlvC97ys8S24,1973
-sae_lens/training/activations_store.py,sha256=rQadexm2BiwK7_MZIPlRkcKSqabi3iuOTC-R8aJchS8,33778
-sae_lens/training/mixing_buffer.py,sha256=vDpYG5ZE70szDvBsRKcNHEES3h_WTKJ16qDYk5jPOVA,2015
-sae_lens/training/optim.py,sha256=bJpqqcK4enkcPvQAJkeH4Ci1LUOlfjIMTv6-IlaAbRA,5588
-sae_lens/training/sae_trainer.py,sha256=zhkabyIKxI_tZTV3_kwz6zMrHZ95Ecr97krmwc-9ffs,17600
-sae_lens/training/types.py,sha256=1FpLx_Doda9vZpmfm-x1e8wGBYpyhe9Kpb_JuM5nIFM,90
-sae_lens/training/upload_saes_to_huggingface.py,sha256=r_WzI1zLtGZ5TzAxuG3xa_8T09j3zXJrWd_vzPsPGkQ,4469
-sae_lens/tutorial/tsea.py,sha256=fd1am_XXsf2KMbByDapJo-2qlxduKaa62Z2qcQZ3QKU,18145
-sae_lens/util.py,sha256=spkcmQUsjVYFn5H2032nQYr1CKGVnv3tAdfIpY59-Mg,3919
-sae_lens-6.26.1.dist-info/METADATA,sha256=yoE6CFgQ9L5SLzI3Zgr8H8CfUBgSimihGyEIvKd8TW8,5361
-sae_lens-6.26.1.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-sae_lens-6.26.1.dist-info/licenses/LICENSE,sha256=DW6e-hDosiu4CfW0-imI57sV1I5f9UEslpviNQcOAKs,1069
-sae_lens-6.26.1.dist-info/RECORD,,