mi-crow 0.1.1.post12__py3-none-any.whl

amber/store/store.py

@@ -0,0 +1,276 @@
+from __future__ import annotations
+
+import abc
+from pathlib import Path
+from typing import Dict, Any, List, Iterator
+
+import torch
+
+
+TensorMetadata = Dict[str, Dict[str, torch.Tensor]]
+
+
+class Store(abc.ABC):
+    """Abstract store optimized for tensor batches grouped by run_id.
+
+    This interface intentionally excludes generic bytes/JSON APIs.
+    Implementations should focus on efficient safetensors-backed IO.
+    
+    The store organizes data hierarchically:
+    - Runs: Top-level grouping by run_id
+    - Batches: Within each run, data is organized by batch_index
+    - Layers: Within each batch, tensors are organized by layer_signature
+    - Keys: Within each layer, tensors are identified by key (e.g., "activations")
+    """
+
+    def __init__(
+            self,
+            base_path: Path | str = "",
+            runs_prefix: str = "runs",
+            dataset_prefix: str = "datasets",
+            model_prefix: str = "models",
+    ):
+        """Initialize Store.
+        
+        Args:
+            base_path: Base directory path for the store
+            runs_prefix: Prefix for runs directory (default: "runs")
+            dataset_prefix: Prefix for datasets directory (default: "datasets")
+            model_prefix: Prefix for models directory (default: "models")
+        """
+        self.runs_prefix = runs_prefix
+        self.dataset_prefix = dataset_prefix
+        self.model_prefix = model_prefix
+        self.base_path = Path(base_path)
+
+    def _run_key(self, run_id: str) -> Path:
+        """Get path for a run directory.
+        
+        Args:
+            run_id: Run identifier
+            
+        Returns:
+            Path to run directory
+        """
+        return self.base_path / self.runs_prefix / run_id
+
+    def _run_batch_key(self, run_id: str, batch_index: int) -> Path:
+        """Get path for a batch directory within a run.
+        
+        Args:
+            run_id: Run identifier
+            batch_index: Batch index
+            
+        Returns:
+            Path to batch directory
+        """
+        return self._run_key(run_id) / f"batch_{batch_index}"
+
+    def _run_metadata_key(self, run_id: str) -> Path:
+        """Get path for run metadata file.
+        
+        Args:
+            run_id: Run identifier
+            
+        Returns:
+            Path to metadata JSON file
+        """
+        return self._run_key(run_id) / "meta.json"
+
+    @abc.abstractmethod
+    def put_run_batch(self, run_id: str, batch_index: int,
+                      tensors: List[torch.Tensor] | Dict[str, torch.Tensor]) -> str:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def get_run_batch(self, run_id: str, batch_index: int) -> List[torch.Tensor] | Dict[
+        str, torch.Tensor]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def list_run_batches(self, run_id: str) -> List[int]:
+        raise NotImplementedError
+
+    def iter_run_batches(self, run_id: str) -> Iterator[List[torch.Tensor] | Dict[str, torch.Tensor]]:
+        for idx in self.list_run_batches(run_id):
+            yield self.get_run_batch(run_id, idx)
+
+    def iter_run_batch_range(
+            self,
+            run_id: str,
+            *,
+            start: int = 0,
+            stop: int | None = None,
+            step: int = 1,
+    ) -> Iterator[List[torch.Tensor] | Dict[str, torch.Tensor]]:
+        """Iterate run batches for indices in range(start, stop, step).
+
+        If stop is None, it will be set to max(list_run_batches(run_id)) + 1 (or 0 if none).
+        Raises ValueError if step == 0 or start < 0.
+        """
+        if step == 0:
+            raise ValueError("step must not be 0")
+        if start < 0:
+            raise ValueError("start must be >= 0")
+        indices = self.list_run_batches(run_id)
+        if not indices:
+            return
+        max_idx = max(indices)
+        if stop is None:
+            stop = max_idx + 1
+        for idx in range(start, stop, step):
+            try:
+                yield self.get_run_batch(run_id, idx)
+            except FileNotFoundError:
+                continue
+
+    @abc.abstractmethod
+    def delete_run(self, run_id: str) -> None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def put_run_metadata(self, run_id: str, meta: Dict[str, Any]) -> str:
+        """Persist metadata for a run (e.g., dataset/model identifiers).
+
+        Args:
+            run_id: Run identifier
+            meta: Metadata dictionary to save (must be JSON-serializable)
+            
+        Returns:
+            String path/key where metadata was stored (e.g., "runs/{run_id}/meta.json")
+            
+        Raises:
+            ValueError: If run_id is invalid or meta is not JSON-serializable
+            OSError: If file system operations fail
+            
+        Note:
+            Implementations should store JSON at a stable location, e.g., runs/{run_id}/meta.json.
+        """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def get_run_metadata(self, run_id: str) -> Dict[str, Any]:
+        """Load metadata for a run.
+        
+        Args:
+            run_id: Run identifier
+            
+        Returns:
+            Metadata dictionary, or empty dict if not found
+            
+        Raises:
+            ValueError: If run_id is invalid
+            json.JSONDecodeError: If metadata file exists but contains invalid JSON
+        """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def put_detector_metadata(
+            self,
+            run_id: str,
+            batch_index: int,
+            metadata: Dict[str, Any],
+            tensor_metadata: TensorMetadata
+    ) -> str:
+        """Save detector metadata with separate JSON and tensor store.
+        
+        Args:
+            run_id: Run identifier
+            batch_index: Batch index (must be non-negative)
+            metadata: JSON-serializable metadata dictionary (aggregated from all detectors)
+            tensor_metadata: Dictionary mapping layer_signature to dict of tensor_key -> tensor
+                           (from all detectors)
+            
+        Returns:
+            Full path key used for store (e.g., "runs/{run_id}/batch_{batch_index}")
+            
+        Raises:
+            ValueError: If parameters are invalid or metadata is not JSON-serializable
+            OSError: If file system operations fail
+        """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def get_detector_metadata(
+            self,
+            run_id: str,
+            batch_index: int
+    ) -> tuple[Dict[str, Any], TensorMetadata]:
+        """Load detector metadata with separate JSON and tensor store.
+        
+        Args:
+            run_id: Run identifier
+            batch_index: Batch index
+            
+        Returns:
+            Tuple of (metadata dict, tensor_metadata dict). Returns empty dicts if not found.
+            
+        Raises:
+            ValueError: If parameters are invalid or metadata format is invalid
+            json.JSONDecodeError: If metadata file exists but contains invalid JSON
+            OSError: If tensor files exist but cannot be loaded
+        """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def get_detector_metadata_by_layer_by_key(
+            self,
+            run_id: str,
+            batch_index: int,
+            layer: str,
+            key: str
+    ) -> torch.Tensor:
+        """Get a specific tensor from detector metadata by layer and key.
+        
+        Args:
+            run_id: Run identifier
+            batch_index: Batch index
+            layer: Layer signature
+            key: Tensor key (e.g., "activations")
+            
+        Returns:
+            The requested tensor
+            
+        Raises:
+            ValueError: If parameters are invalid
+            FileNotFoundError: If the tensor doesn't exist
+            OSError: If tensor file exists but cannot be loaded
+        """
+        raise NotImplementedError
+
+    # --- Unified detector metadata for whole runs ---
+    @abc.abstractmethod
+    def put_run_detector_metadata(
+            self,
+            run_id: str,
+            metadata: Dict[str, Any],
+            tensor_metadata: TensorMetadata,
+    ) -> str:
+        """
+        Save detector metadata for a whole run in a unified location.
+
+        This differs from ``put_detector_metadata`` which organises data
+        per-batch under ``runs/{run_id}/batch_{batch_index}``.
+
+        ``put_run_detector_metadata`` instead stores everything under
+        ``runs/{run_id}/detectors``. Implementations are expected to
+        support being called multiple times for the same ``run_id`` and
+        append / aggregate new metadata rather than overwrite it.
+
+        Args:
+            run_id: Run identifier
+            metadata: JSON-serialisable metadata dictionary aggregated
+                from all detectors for the current chunk / batch.
+            tensor_metadata: Dictionary mapping layer_signature to dict
+                of tensor_key -> tensor (from all detectors).
+
+        Returns:
+            String path/key where metadata was stored
+            (e.g. ``runs/{run_id}/detectors``).
+
+        Raises:
+            ValueError: If parameters are invalid or metadata is not
+                JSON‑serialisable.
+            OSError: If file system operations fail.
+        """
+        raise NotImplementedError

amber/store/store_dataloader.py

@@ -0,0 +1,124 @@
+from typing import Optional, Iterator, TYPE_CHECKING
+
+import torch
+
+from amber.utils import get_logger
+
+logger = get_logger(__name__)
+
+if TYPE_CHECKING:
+    from amber.store.store import Store
+
+
+class StoreDataloader:
+    """
+    A reusable DataLoader-like class that can be iterated multiple times.
+
+    This is needed because overcomplete's train_sae iterates over the dataloader
+    once per epoch, so we need a dataloader that can be iterated multiple times.
+    """
+
+    def __init__(
+            self,
+            store: "Store",
+            run_id: str,
+            layer: str,
+            key: str = "activations",
+            batch_size: int = 32,
+            dtype: Optional[torch.dtype] = None,
+            device: Optional[torch.device] = None,
+            max_batches: Optional[int] = None,
+            logger_instance=None
+    ):
+        """
+        Initialize StoreDataloader.
+
+        Args:
+            store: Store instance containing activations
+            run_id: Run ID to iterate over
+            layer: Layer signature to load activations from
+            key: Tensor key to load (default: "activations")
+            batch_size: Mini-batch size
+            dtype: Optional dtype to cast activations to
+            device: Optional device to move tensors to
+            max_batches: Optional limit on number of batches per epoch
+            logger_instance: Optional logger instance for debug messages
+        """
+        self.store = store
+        self.run_id = run_id
+        self.layer = layer
+        self.key = key
+        self.batch_size = batch_size
+        self.dtype = dtype
+        self.device = device
+        self.max_batches = max_batches
+        self.logger = logger_instance or logger
+
+    def __iter__(self) -> Iterator[torch.Tensor]:
+        """
+        Create a new iterator for each epoch.
+
+        This allows the dataloader to be iterated multiple times,
+        which is required for multiple epochs.
+        """
+        batches_yielded = 0
+        
+        # Get list of batch indices
+        batch_indices = self.store.list_run_batches(self.run_id)
+        
+        for batch_index in batch_indices:
+            if self.max_batches is not None and batches_yielded >= self.max_batches:
+                break
+            
+            acts = None
+            try:
+                # Try to load from detector metadata first
+                acts = self.store.get_detector_metadata_by_layer_by_key(
+                    self.run_id,
+                    batch_index,
+                    self.layer,
+                    self.key
+                )
+            except FileNotFoundError:
+                # Fall back to traditional batch files
+                try:
+                    batch = self.store.get_run_batch(self.run_id, batch_index)
+                    if isinstance(batch, dict) and self.key in batch:
+                        acts = batch[self.key]
+                    elif isinstance(batch, dict) and "activations" in batch:
+                        # For backward compatibility, use "activations" if key not found
+                        acts = batch["activations"]
+                except Exception:
+                    pass
+            
+            if acts is None:
+                if self.logger.isEnabledFor(self.logger.level):
+                    self.logger.debug(
+                        f"Skipping batch {batch_index}: tensor not found "
+                        f"(run_id={self.run_id}, layer={self.layer}, key={self.key})"
+                    )
+                continue
+
+            # Ensure 2D [N, D]
+            if acts.dim() > 2:
+                d = acts.shape[-1]
+                acts = acts.view(-1, d)
+            elif acts.dim() == 1:
+                acts = acts.view(1, -1)
+            
+            # dtype handling
+            if self.dtype is not None:
+                acts = acts.to(self.dtype)
+            
+            # device handling
+            if self.device is not None:
+                acts = acts.to(self.device)
+
+            # Yield mini-batches
+            bs = max(1, int(self.batch_size))
+            n = acts.shape[0]
+            for start in range(0, n, bs):
+                if self.max_batches is not None and batches_yielded >= self.max_batches:
+                    return
+                yield acts[start:start + bs]
+                batches_yielded += 1

amber/utils.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+import logging
+import os
+import random
+from typing import Optional
+
+import numpy as np
+import torch
+
+
+def set_seed(seed: int, deterministic: bool = True) -> None:
+    """Set seeds for python, numpy, and torch.
+
+    Args:
+        seed: Seed value.
+        deterministic: If True, tries to make torch deterministic where possible.
+    """
+    random.seed(seed)
+    os.environ["PYTHONHASHSEED"] = str(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+    if deterministic:
+        torch.use_deterministic_algorithms(True, warn_only=True)
+        torch.backends.cudnn.deterministic = True  # type: ignore[attr-defined]
+        torch.backends.cudnn.benchmark = False  # type: ignore[attr-defined]
+
+
+def get_logger(name: str = "amber", level: int | str = logging.INFO) -> logging.Logger:
+    """Get a configured logger with a simple format. Idempotent."""
+    logger = logging.getLogger(name)
+    if isinstance(level, str):
+        level = logging.getLevelName(level)
+    logger.setLevel(level)
+    if not logger.handlers:
+        handler = logging.StreamHandler()
+        fmt = logging.Formatter("%(asctime)s [%(levelname)s] %(name)s: %(message)s")
+        handler.setFormatter(fmt)
+        logger.addHandler(handler)
+        # Allow propagation so pytest's caplog can capture logs
+        logger.propagate = True
+    else:
+        # Even if a handler exists (e.g., configured by the app), ensure propagation is enabled
+        logger.propagate = True
+    return logger

mi_crow-0.1.1.post12.dist-info/METADATA

@@ -0,0 +1,124 @@
+Metadata-Version: 2.4
+Name: mi-crow
+Version: 0.1.1.post12
+Summary: Engineer Thesis: Explaining and modifying LLM responses using SAE and concepts.
+Author-email: Hubert Kowalski <your.email@example.com>, Adam Kaniasty <adam.kaniasty@gmail.com>
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: accelerate>=1.10.1
+Requires-Dist: datasets>=4.0.0
+Requires-Dist: notebook>=7.4.7
+Requires-Dist: overcomplete
+Requires-Dist: pre-commit>=4.3.0
+Requires-Dist: setuptools-scm>=8
+Requires-Dist: torch>=2.8.0
+Requires-Dist: tqdm>=4.67.1
+Requires-Dist: transformers>=4.56.1
+Requires-Dist: safetensors>=0.4.5
+Requires-Dist: wandb>=0.22.1
+Requires-Dist: pytest>=8.4.2
+Requires-Dist: pytest-xdist>=3.8.0
+Requires-Dist: seaborn>=0.13.2
+Provides-Extra: dev
+Requires-Dist: pre-commit>=4.3.0; extra == "dev"
+Requires-Dist: ruff>=0.13.2; extra == "dev"
+Requires-Dist: setuptools-scm>=8; extra == "dev"
+Requires-Dist: wheel>=0.45.1; extra == "dev"
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=5.0.0; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: mkdocs>=1.6; extra == "docs"
+Requires-Dist: mkdocs-material>=9.5; extra == "docs"
+Requires-Dist: mkdocstrings[python]>=0.26; extra == "docs"
+Requires-Dist: mkdocs-section-index>=0.3; extra == "docs"
+Requires-Dist: mkdocs-redirects>=1.2; extra == "docs"
+Requires-Dist: mkdocs-literate-nav>=0.6; extra == "docs"
+Requires-Dist: mkdocs-gen-files>=0.5; extra == "docs"
+Requires-Dist: mike>=2.1; extra == "docs"
+
+![CI](https://github.com/AdamKaniasty/Inzynierka/actions/workflows/tests.yml/badge.svg?branch=main)
+[![Docs](https://img.shields.io/badge/docs-gh--pages-blue)](https://adamkaniasty.github.io/Inzynierka/)
+
+## Running Tests
+
+The project uses pytest for testing. Tests are organized into unit tests and end-to-end tests.
+
+### Running All Tests
+
+```bash
+pytest
+```
+
+### Running Specific Test Suites
+
+Run only unit tests:
+```bash
+pytest --unit -q
+```
+
+Run only end-to-end tests:
+```bash
+pytest --e2e -q
+```
+
+You can also use pytest markers:
+```bash
+pytest -m unit -q
+pytest -m e2e -q
+```
+
+Or specify the test directory directly:
+```bash
+pytest tests/unit -q
+pytest tests/e2e -q
+```
+
+### Test Coverage
+
+The test suite is configured to require at least 85% code coverage. Coverage reports are generated in both terminal and XML formats.
+
+## Backend (FastAPI) quickstart
+
+Install server-only dependencies (kept out of the core library) with uv:
+```bash
+uv sync --group server
+```
+
+Run the API:
+```bash
+uv run --group server uvicorn server.main:app --reload
+```
+
+Smoke-test the server endpoints:
+```bash
+uv run --group server pytest tests/server/test_api.py --cov=server --cov-fail-under=0
+```
+
+### SAE API usage
+
+- Configure artifact location (optional): `export SERVER_ARTIFACT_BASE_PATH=/path/to/amber_artifacts` (defaults to `~/.cache/amber_server`)
+- Load a model: `curl -X POST http://localhost:8000/models/load -H "Content-Type: application/json" -d '{"model_id":"bielik"}'`
+- Save activations from dataset (stored in `LocalStore` under `activations/<model>/<run_id>`):
+  - HF dataset: `{"dataset":{"type":"hf","name":"ag_news","split":"train","text_field":"text"}}`
+  - Local files: `{"dataset":{"type":"local","paths":["/path/to/file.txt"]}}`
+  - Example: `curl -X POST http://localhost:8000/sae/activations/save -H "Content-Type: application/json" -d '{"model_id":"bielik","layers":["dummy_root"],"dataset":{"type":"local","paths":["/tmp/data.txt"]},"sample_limit":100,"batch_size":4,"shard_size":64}'` → returns a manifest path, run_id, token counts, and batch metadata.
+- List activation runs: `curl "http://localhost:8000/sae/activations?model_id=bielik"`
+- Start SAE training (async job, uses `SaeTrainer`): `curl -X POST http://localhost:8000/sae/train -H "Content-Type: application/json" -d '{"model_id":"bielik","activations_path":"/path/to/manifest.json","layer":"<layer_name>","sae_class":"TopKSae","hyperparams":{"epochs":1,"batch_size":256}}'` → returns `job_id`
+- Check job status: `curl http://localhost:8000/sae/train/status/<job_id>` (returns `sae_id`, `sae_path`, `metadata_path`, progress, and logs)
+- Cancel a job (best-effort): `curl -X POST http://localhost:8000/sae/train/cancel/<job_id>`
+- Load an SAE: `curl -X POST http://localhost:8000/sae/load -H "Content-Type: application/json" -d '{"model_id":"bielik","sae_path":"/path/to/sae.json"}'`
+- List SAEs: `curl "http://localhost:8000/sae/saes?model_id=bielik"`
+- Run SAE inference (optionally save top texts and apply concept config): `curl -X POST http://localhost:8000/sae/infer -H "Content-Type: application/json" -d '{"model_id":"bielik","sae_id":"<sae_id>","save_top_texts":true,"top_k_neurons":5,"concept_config_path":"/path/to/concepts.json","inputs":[{"prompt":"hi"}]}'` → returns outputs, top neuron summary, sae metadata, and saved top-texts path when requested.
+- Per-token latents: add `"return_token_latents": true` (default off) to include top-k neuron activations per token.
+- List concepts: `curl "http://localhost:8000/sae/concepts?model_id=bielik&sae_id=<sae_id>"`
+- Load concepts from a file (validated against SAE latents): `curl -X POST http://localhost:8000/sae/concepts/load -H "Content-Type: application/json" -d '{"model_id":"bielik","sae_id":"<sae_id>","source_path":"/path/to/concepts.json"}'`
+- Manipulate concepts (saves a config file for inference-time scaling): `curl -X POST http://localhost:8000/sae/concepts/manipulate -H "Content-Type: application/json" -d '{"model_id":"bielik","sae_id":"<sae_id>","edits":{"0":1.2}}'`
+- List concept configs: `curl "http://localhost:8000/sae/concepts/configs?model_id=bielik&sae_id=<sae_id>"`
+- Preview concept config (validate without saving): `curl -X POST http://localhost:8000/sae/concepts/preview -H "Content-Type: application/json" -d '{"model_id":"bielik","sae_id":"<sae_id>","edits":{"0":1.2}}'`
+- Delete activation run or SAE (requires API key if set): `curl -X DELETE "http://localhost:8000/sae/activations/<run_id>?model_id=bielik" -H "X-API-Key: <key>"` and `curl -X DELETE "http://localhost:8000/sae/saes/<sae_id>?model_id=bielik" -H "X-API-Key: <key>"`
+- Health/metrics summary: `curl http://localhost:8000/health/metrics` (in-memory job counts; no persistence, no auth)
+
+Notes:
+- Job manager is in-memory/lightweight: jobs disappear on process restart; idempotency is best-effort via payload key.
+- Training/inference currently run in-process threads; add your own resource guards when running heavy models.
+- Optional API key protection: set `SERVER_API_KEY=<value>` to require `X-API-Key` on protected endpoints (delete).

mi_crow-0.1.1.post12.dist-info/RECORD

@@ -0,0 +1,51 @@
+amber/__init__.py,sha256=5nh0D8qvFgOhBEQj00Rm06T1iY5VcSiifAg9SoY1LLA,483
+amber/utils.py,sha256=oER2LA_alUjaIk_xCAyP2V54ywjqsg00I4KvitYnJPc,1547
+amber/datasets/__init__.py,sha256=zhqgbm5zMBsRbmPNfjlYNJwGWOLuCNf5jEj0P8aopRU,341
+amber/datasets/base_dataset.py,sha256=X2wt3GdjgAOY24_vOqrD5gVFxGplSRMCb69CoQtj0xw,22508
+amber/datasets/classification_dataset.py,sha256=x_ZQ4dMzoY3Nn8V1I01xvzJK_IcHcDcm8dIxYeXzV5g,21700
+amber/datasets/loading_strategy.py,sha256=17VM3Td8lqDllGIx9DHI6WiXmSKKQHDHbfe4ZeM8ATA,1206
+amber/datasets/text_dataset.py,sha256=ly0GHCS28Rg5ZluaafjavhcbvSD9-6ryovd_Y1ZIMms,16775
+amber/hooks/__init__.py,sha256=9H08ZVoTK6TzYJXjEP2aqdHfoyLfdXvg6eOv3K1zNps,679
+amber/hooks/controller.py,sha256=hc8FrrDosFYLrEGsEZmx1KsJ77F4p_gMKcF2WzHiURY,6057
+amber/hooks/detector.py,sha256=5drJFrdrjseVjRNT-cq-U8XCt8AXV04YY2YrkQz4eFk,3110
+amber/hooks/hook.py,sha256=-Qi-GJqRuIskXMuHUzp9_ESbbZi5tLSAFMWoBmrP3io,7540
+amber/hooks/utils.py,sha256=wtsrjsMt-bXR3NshkwyZmfLre3IE3S4E5EoKppQrYOo,2022
+amber/hooks/implementations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+amber/hooks/implementations/function_controller.py,sha256=66FFx_7sU7b0_FFQFFkAOqQm3aGsiyIRuZ64hIv-0w8,3088
+amber/hooks/implementations/layer_activation_detector.py,sha256=bzoW6V8NNDNgRASs1YN_1TjEXaK3ahoNWiZ-ODfjB6I,3161
+amber/hooks/implementations/model_input_detector.py,sha256=cYRVfyBEHi-1qg6F-4Q0vKEae6gYtq_3g1j3rOOCQdA,10074
+amber/hooks/implementations/model_output_detector.py,sha256=iN-twt7Chc9ODmj-iei7_Ah7GqvE-knTVWi4C9kNye4,4879
+amber/language_model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+amber/language_model/activations.py,sha256=7VRDlCM-IctF1ee0H68_Dd7xeXHyUSQe1SOPb28Ej18,16971
+amber/language_model/context.py,sha256=koslpikCcu9Svsopboa1wd7Fv0R2-4sI2whOCvVWvT8,1118
+amber/language_model/contracts.py,sha256=6ij7rzJcpSAKgYx-fiefg0Fi8TsFugaM5IlihEm_2VM,268
+amber/language_model/hook_metadata.py,sha256=9Xyfiu4ekCZj79zG4gZfLk-850AO2iKDE24FDXe7q7s,1392
+amber/language_model/inference.py,sha256=l8BASS8E9B4VWJHucEqF_G_zqOzlKeG4KEvGameBbMw,19068
+amber/language_model/initialization.py,sha256=hfrKdI_fsmaxk0p9q4wN7EFxq_lSXs8BXGlxwKJ21Qw,3698
+amber/language_model/language_model.py,sha256=MXoaXYbNBUxHw4sxtWkVFLbXiw9tFEx9GI78sCiESuQ,13943
+amber/language_model/layers.py,sha256=Ob7QZl8i236ALLklY9o_xtjDZSt6FD8sqdmFy_YLgN0,15906
+amber/language_model/persistence.py,sha256=i2ibDH1OABM5-ZNNLh7h4rOYWPsg3aaeYhmB_xWYDZw,5867
+amber/language_model/tokenizer.py,sha256=9eKNOHvUjIJhJbj7M-tN7jWU5lWhOeCY_cssa4exQ1g,7377
+amber/language_model/utils.py,sha256=5Y7scRvvudUjKDV8QPhC3HAc2S-dCuqbm6xEjRr0fRM,2630
+amber/mechanistic/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+amber/mechanistic/sae/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+amber/mechanistic/sae/autoencoder_context.py,sha256=cn0mv9COqT3jNcvXBfce70ankVEmw9kNE3Mu-knugoc,945
+amber/mechanistic/sae/sae.py,sha256=ha6rXGsOXE59E_ohTH0vJh6M4rQh3Xw0GfmCkSgeYS4,6035
+amber/mechanistic/sae/sae_trainer.py,sha256=GMrPz9SpSuANA0tJt3IkyIOOqVr2k7apE0w4CqL92gM,26311
+amber/mechanistic/sae/concepts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+amber/mechanistic/sae/concepts/autoencoder_concepts.py,sha256=dTB9v5zK5lcKc4_zbYtWoCy8fA6ycj1-FJid4-7hQ04,14371
+amber/mechanistic/sae/concepts/concept_dictionary.py,sha256=9px845gODuufW2koym-5426q0ijdpxvS7avH1vu8-Ls,7671
+amber/mechanistic/sae/concepts/concept_models.py,sha256=HGyPoMSmj8CAg9joIa6fV_FfWAY2XN4LFPIkNQiJWbY,133
+amber/mechanistic/sae/concepts/input_tracker.py,sha256=81FrOv9AAC7ejhryOWDTZ7Hlt3B2WoANx-wiO0KLr24,1886
+amber/mechanistic/sae/modules/__init__.py,sha256=xpoz0HtPWoJD4dPj1qHaxtXDr7J0ERn30CX3m1dz21s,239
+amber/mechanistic/sae/modules/l1_sae.py,sha256=_BebvpB9iUCTDjSiYNzDBM4l9sU_wadAdypwXaSb4ww,15352
+amber/mechanistic/sae/modules/topk_sae.py,sha256=GQA8hYb6Fw7U1e5ExZjzZBjAZRhGk-VwqqYREVCQ_u8,17275
+amber/mechanistic/sae/training/wandb_logger.py,sha256=d3vVBIQrnsJurX5HNVu7OYW4DqNgv18UZDpV8ddfN9k,8554
+amber/store/__init__.py,sha256=UW4Hqyu-_qgnZ-gN_mk97OaWSrlPERcNi5YjnXMKeOU,119
+amber/store/local_store.py,sha256=1pJbizZKrzNt_IQFnCFYjApPXs9ot-G1H8adeR7Qi50,17214
+amber/store/store.py,sha256=VuDe9Git0glND3TTHh0zhDJNxdQY3dCp0cURhApYQbU,9334
+amber/store/store_dataloader.py,sha256=QyYHSgOos8e-yzaEE_rySSVlGKaRNybURSDCgNrTIVM,4337
+mi_crow-0.1.1.post12.dist-info/METADATA,sha256=1_SPBcnK8j_scOIWwnPqQGjlUpNnXxGGtvkYRZHeDQ8,6580
+mi_crow-0.1.1.post12.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mi_crow-0.1.1.post12.dist-info/top_level.txt,sha256=FNP1x_ePvcW9Jsr7J9gCBARdDC-gqxIYtWF6HGNxtnI,6
+mi_crow-0.1.1.post12.dist-info/RECORD,,

mi_crow-0.1.1.post12.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

mi_crow-0.1.1.post12.dist-info/top_level.txt

@@ -0,0 +1 @@
+amber