cotlab 0.8.0__py3-none-any.whl

cotlab/prompts/tcga.py

@@ -0,0 +1,168 @@
+"""TCGA Cancer Type Classification Prompt Strategy."""
+
+import json
+from typing import Any, Dict, Optional
+
+from ..core.base import BasePromptStrategy, StructuredOutputMixin
+from ..core.registry import Registry
+
+SYSTEM_ROLE = """You are an expert pathologist specializing in cancer classification.
+Your goal is to identify the specific TCGA Cancer Type Code (e.g., BRCA, LUAD) from the pathology report.
+Think rationally and explain your reasoning step-by-step."""
+
+SYSTEM_ROLE_CONTRARIAN = """You are a skeptical pathologist reviewing a cancer classification.
+Question obvious conclusions and consider alternate cancer type codes before deciding."""
+
+PROMPT_TEMPLATE = """Follow this structured reasoning on the attached pathology report:
+
+1. **Anatomic Site**: Identify the organ and specific site of the specimen.
+2. **Histological Findings**: Identify the specific tumor type, morphology, and grade described.
+3. **TCGA Code Selection**: Match the findings to one of the 32 valid TCGA codes.
+
+Valid Codes:
+ACC, BLCA, BRCA, CESC, CHOL, COAD, DLBC, ESCA, GBM, HNSC, KICH, KIRC, KIRP, LGG, LIHC, LUAD, LUSC, MESO, OV, PAAD, PCPG, PRAD, READ, SARC, SKCM, STAD, TGCT, THCA, THYM, UCEC, UCS, UVM
+
+Follow the format of these examples and give the output strictly in the json format.
+
+Example 1: Kidney Renal Clear Cell Carcinoma
+```json
+{{
+    "cancer_type": "KIRC",
+    "reasoning": "1. Site: Kidney (Left Upper Pole). 2. Findings: Renal cell carcinoma, conventional (clear cell) type, Fuhrman Grade II. 3. Code: Kidney Renal Clear Cell Carcinoma maps to KIRC."
+}}
+```
+
+Example 2: Breast Invasive Carcinoma
+```json
+{{
+    "cancer_type": "BRCA",
+    "reasoning": "1. Site: Breast. 2. Findings: Invasive ductal carcinoma. 3. Code: Breast Invasive Carcinoma maps to BRCA."
+}}
+```
+
+Pathology report:
+\"\"\"
+{report}
+\"\"\"
+
+Response:
+"""
+
+PROMPT_TEMPLATE_ANSWER_FIRST = """Review the pathology report and provide an immediate TCGA code.
+
+**Step 1 - Initial Code**: Based on your first read, state the single best TCGA code.
+**Step 2 - Evidence**: Justify the code with site and histology evidence.
+
+Valid Codes:
+ACC, BLCA, BRCA, CESC, CHOL, COAD, DLBC, ESCA, GBM, HNSC, KICH, KIRC, KIRP, LGG, LIHC, LUAD, LUSC, MESO, OV, PAAD, PCPG, PRAD, READ, SARC, SKCM, STAD, TGCT, THCA, THYM, UCEC, UCS, UVM
+
+Provide your response in JSON format. Follow the format of these two examples and give the output strictly in the json format.
+
+Example 1: Initial BRCA, then justification
+```json
+{{
+    "cancer_type": "BRCA",
+    "reasoning": "Initial code: BRCA. Site: Breast. Histology: Invasive ductal carcinoma. This maps to TCGA BRCA."
+}}
+```
+
+Example 2: Initial LUAD, then justification
+```json
+{{
+    "cancer_type": "LUAD",
+    "reasoning": "Initial code: LUAD. Site: Lung. Histology: Adenocarcinoma with glandular features. This maps to TCGA LUAD."
+}}
+```
+
+Pathology report:
+\"\"\"
+{report}
+\"\"\"
+
+Response:
+"""
+
+
+@Registry.register_prompt("tcga")
+class TCGAPromptStrategy(StructuredOutputMixin, BasePromptStrategy):
+    """
+    Structured JSON output for TCGA cancer type classification.
+    """
+
+    def __init__(
+        self,
+        name: str = "tcga",
+        system_role: Optional[str] = None,
+        few_shot: bool = True,
+        contrarian: bool = False,
+        answer_first: bool = False,
+        **kwargs,
+    ):
+        self._name = name
+        self.few_shot = few_shot
+        self.contrarian = contrarian
+        self.answer_first = answer_first
+        if system_role:
+            self.system_role = system_role
+        else:
+            self.system_role = SYSTEM_ROLE_CONTRARIAN if contrarian else SYSTEM_ROLE
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    def build_prompt(self, input_data: Dict[str, Any]) -> str:
+        """Build prompt with pathology report."""
+        report = input_data.get("text", input_data.get("report", ""))
+
+        template = PROMPT_TEMPLATE_ANSWER_FIRST if self.answer_first else PROMPT_TEMPLATE
+
+        if not self.few_shot:
+            template = self._remove_few_shot_examples(template)
+
+        prompt = template.format(report=report)
+        return prompt
+
+    def _remove_few_shot_examples(self, template: str) -> str:
+        import re
+
+        pattern = r"Example \d+:.*?```json.*?```"
+        cleaned = re.sub(pattern, "", template, flags=re.DOTALL)
+        return cleaned
+
+    def parse_response(self, response: str) -> Dict[str, Any]:
+        """Parse JSON response."""
+        try:
+            # Try to find JSON block
+            import re
+
+            json_match = re.search(r"```json\s*(.*?)\s*```", response, re.DOTALL)
+            if json_match:
+                json_str = json_match.group(1)
+            else:
+                # Try raw brace match
+                json_match = re.search(r'\{[^{}]*"cancer_type"[^{}]*\}', response, re.DOTALL)
+                if json_match:
+                    json_str = json_match.group(0)
+                else:
+                    json_str = response
+
+            parsed = json.loads(json_str)
+            return {
+                "answer": parsed.get("cancer_type", "UNKNOWN"),
+                "cancer_type": parsed.get("cancer_type"),
+                "reasoning": parsed.get("reasoning", ""),
+                "raw": response,
+                "parsed_json": parsed,
+            }
+        except Exception:
+            return {"answer": "ERROR", "raw": response, "parse_error": True}
+
+    def get_system_message(self) -> Optional[str]:
+        return self.system_role
+
+    def get_compatible_datasets(self) -> list[str]:
+        return ["tcga"]
+
+    def get_prediction_field(self) -> str:
+        return "cancer_type"

cotlab/runner.py

@@ -0,0 +1,204 @@
+import argparse
+from datetime import datetime
+from pathlib import Path
+
+from hydra import compose, initialize
+from omegaconf import OmegaConf
+
+from cotlab.core import create_component
+from cotlab.logging import ExperimentLogger
+
+
+def _extract_backend_load_kwargs(cfg_backend) -> dict:
+    backend_cfg = OmegaConf.to_container(cfg_backend, resolve=True)
+    keys = [
+        "load_in_4bit",
+        "load_in_8bit",
+        "bnb_4bit_quant_type",
+        "bnb_4bit_compute_dtype",
+        "bnb_4bit_use_double_quant",
+    ]
+    return {key: backend_cfg.get(key) for key in keys if backend_cfg.get(key) is not None}
+
+
+def main():
+    # Parse CLI arguments
+    parser = argparse.ArgumentParser(description="Run CoTLab experiment batch")
+    parser.add_argument(
+        "--backend",
+        type=str,
+        default="vllm",
+        choices=["vllm", "transformers"],
+        help="Backend to use (default: vllm)",
+    )
+    parser.add_argument(
+        "--model",
+        type=str,
+        default="medgemma_27b_text_it",
+        help="Model config name (default: medgemma_27b_text_it)",
+    )
+    parser.add_argument(
+        "--format",
+        type=str,
+        default="plain",
+        choices=["plain", "json", "toon", "toml", "xml", "yaml", "markdown"],
+        help="Output format (default: plain)",
+    )
+    args = parser.parse_args()
+
+    backend_name = args.backend
+    model_name = args.model
+    output_format = args.format
+
+    # Setup base output directory with model name and format
+    timestamp = datetime.now().strftime("%Y-%m-%d/%H-%M-%S")
+    base_output_dir = Path(f"outputs/{timestamp}_{model_name}_{backend_name}_{output_format}")
+    base_output_dir.mkdir(parents=True, exist_ok=True)
+    print(f"Output directory: {base_output_dir}")
+
+    # Initialize Hydra
+    with initialize(version_base=None, config_path="../../conf"):
+        # 1. Load Backend & Model ONCE
+        print("=" * 60)
+        print(f"Initializing Backend ({backend_name}) and Model ({model_name})...")
+        print("=" * 60)
+
+        # Base config to load model
+        base_cfg = compose(
+            config_name="config",
+            overrides=[
+                f"backend={backend_name}",
+                f"model={model_name}",
+                "experiment=cot_faithfulness",  # Dummy
+                "dataset=pediatrics",  # Dummy
+                "prompt=chain_of_thought",  # Dummy
+            ],
+        )
+
+        backend = create_component(base_cfg.backend)
+        backend.load_model(base_cfg.model.name, **_extract_backend_load_kwargs(base_cfg.backend))
+        print("Backend initialized successfully.")
+
+        # Define Experiment Grid
+        grid = [
+            # 1. Main CoT Faithfulness Sweep
+            {
+                "experiment": "cot_faithfulness",
+                "datasets": ["pediatrics", "synthetic", "patching_pairs", "radiology"],
+                "prompts": [
+                    "chain_of_thought",
+                    "direct_answer",
+                    "sycophantic",
+                    "adversarial",
+                    "uncertainty",
+                    "expert_persona",
+                    "few_shot",
+                    "contrarian",
+                    "arrogance",
+                    "simple",
+                    "socratic",
+                    "no_instruction",
+                    "radiology",
+                ],
+            },
+            # 2. Classification Experiment (works for all specialties)
+            {"experiment": "classification", "datasets": ["radiology"], "prompts": ["radiology"]},
+        ]
+
+        total_jobs = sum(len(g["datasets"]) * len(g["prompts"]) for g in grid)
+        print(f"Starting execution of {total_jobs} jobs...")
+
+        job_idx = 0
+        for group in grid:
+            exp_name = group["experiment"]
+
+            for dataset_name in group["datasets"]:
+                for prompt_name in group["prompts"]:
+                    job_idx += 1
+                    print(
+                        f"\n[Job {job_idx}/{total_jobs}] exp={exp_name} dataset={dataset_name} prompt={prompt_name}"
+                    )
+
+                    # Create specific config override
+                    overrides = [
+                        f"backend={backend_name}",
+                        f"model={model_name}",
+                        f"experiment={exp_name}",
+                        f"dataset={dataset_name}",
+                        f"prompt={prompt_name}",
+                    ]
+
+                    # Add output format override if not plain
+                    if output_format != "plain":
+                        overrides.append(f"++prompt.output_format={output_format}")
+
+                    cfg = compose(config_name="config", overrides=overrides)
+
+                    # Instantiate Components for this run
+                    try:
+                        dataset = create_component(cfg.dataset)
+                        prompt_strategy = create_component(cfg.prompt)
+                        experiment = create_component(cfg.experiment)
+
+                        # Check prompt-dataset compatibility (prompt side)
+                        compatible_datasets = prompt_strategy.get_compatible_datasets()
+                        if (
+                            compatible_datasets is not None
+                            and dataset_name not in compatible_datasets
+                        ):
+                            print(f"  SKIPPED: {prompt_name} is not compatible with {dataset_name}")
+                            print(f"           (prompt only works with: {compatible_datasets})")
+                            continue
+
+                        # Check prompt-dataset compatibility (dataset side)
+                        compatible_prompts = dataset.get_compatible_prompts()
+                        if compatible_prompts is not None and prompt_name not in compatible_prompts:
+                            print(f"  SKIPPED: {dataset_name} is not compatible with {prompt_name}")
+                            print(f"           (dataset only works with: {compatible_prompts})")
+                            continue
+
+                        # Setup individual run logger
+                        run_name = f"{exp_name}_{dataset_name}_{prompt_name}"
+                        run_dir = base_output_dir / run_name
+                        run_dir.mkdir(exist_ok=True)
+
+                        logger = ExperimentLogger(str(run_dir))
+                        logger.log_config(cfg)
+
+                        # Run Experiment
+                        num_samples = OmegaConf.select(cfg, "experiment.num_samples", default=None)
+                        result = experiment.run(
+                            backend=backend,
+                            dataset=dataset,
+                            prompt_strategy=prompt_strategy,
+                            logger=logger,
+                            **(dict(num_samples=num_samples) if num_samples is not None else {}),
+                        )
+
+                        # Save results
+                        results_path = logger.save_results(result)
+                        print(f"Results saved: {results_path}")
+
+                        # Basic metrics print
+                        metrics_str = ", ".join(
+                            [
+                                f"{k}={v:.2f}" if isinstance(v, float) else f"{k}={v}"
+                                for k, v in result.metrics.items()
+                            ]
+                        )
+                        print(f"Metrics: {metrics_str}")
+
+                    except Exception as e:
+                        print(f"ERROR in job {job_idx}: {e}")
+                        import traceback
+
+                        traceback.print_exc()
+
+        print("\n" + "=" * 60)
+        print("All jobs completed.")
+        print(f"Results stored in: {base_output_dir}")
+        print("=" * 60)
+
+
+if __name__ == "__main__":
+    main()

cotlab-0.8.0.dist-info/METADATA

@@ -0,0 +1,166 @@
+Metadata-Version: 2.4
+Name: cotlab
+Version: 0.8.0
+Summary: CoTLab - Chain of Thought Research Toolkit for LLMs
+Project-URL: Repository, https://github.com/huseyincavusbi/CoTLab
+Project-URL: Documentation, https://huseyincavusbi.github.io/CoTLab
+Project-URL: Issues, https://github.com/huseyincavusbi/CoTLab/issues
+Author-email: Huseyin Cavus <huseyincavus@proton.me>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: chain-of-thought,interpretability,llm,mechanistic-interpretability,medical-ai,probing
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Requires-Dist: accelerate>=0.27.0
+Requires-Dist: bitsandbytes>=0.46.1
+Requires-Dist: click>=8.1.0
+Requires-Dist: huggingface-hub>=0.20.0
+Requires-Dist: hydra-core>=1.3.0
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: omegaconf>=2.3.0
+Requires-Dist: pandas>=2.0.0
+Requires-Dist: protobuf>=3.20.0
+Requires-Dist: pyarrow>=14.0.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: safetensors>=0.4.0
+Requires-Dist: scikit-learn>=1.3.0
+Requires-Dist: torch>=2.1.0
+Requires-Dist: tqdm>=4.65.0
+Requires-Dist: transformers<5,>=4.56.0
+Requires-Dist: xmltodict>=0.13.0
+Provides-Extra: dev
+Requires-Dist: ipython>=8.0.0; extra == 'dev'
+Requires-Dist: jupyter>=1.0.0; extra == 'dev'
+Requires-Dist: mypy>=1.0.0; extra == 'dev'
+Requires-Dist: pre-commit>=3.0.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0.0; extra == 'dev'
+Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.4.4; extra == 'dev'
+Provides-Extra: vllm
+Requires-Dist: vllm>=0.6.0; extra == 'vllm'
+Description-Content-Type: text/markdown
+
+# CoTLab
+
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/huseyincavusbi/CoTLab)
+
+A research toolkit for investigating Chain of Thought (CoT) reasoning, faithfulness, and mechanistic interpretability in Large Language Models.
+
+## Features
+
+- Experiments for CoT faithfulness, patching, logit‑lens, steering, and probing
+- Diverse prompt strategies (CoT, direct, adversarial, contrarian, few‑shot, etc.)
+- Configurable models, datasets, and backends (vLLM + Transformers)
+- Auto‑detect layers/heads at runtime
+- Hydra config for easy composition and multiruns
+----
+- Project overview (DeepWiki): https://deepwiki.com/huseyincavusbi/CoTLab/1-overview
+- Official docs: https://huseyincavusbi.github.io/CoTLab/
+---
+## Installation
+
+```bash
+git clone https://github.com/huseyincavusbi/CoTLab.git
+cd CoTLab
+uv venv cotlab --python 3.11
+source cotlab/bin/activate
+uv pip install -e ".[dev]"
+
+# GPU Setup:
+# NVIDIA: uv pip install vllm
+# AMD ROCm: ./scripts/cotlab-rocm.sh (uses Docker)
+
+# AMD ROCm (Transformers backend): install ROCm PyTorch wheels
+# uv pip install --reinstall --index-url https://download.pytorch.org/whl/rocm6.4 torch torchvision torchaudio
+
+# Apple Silicon: requires Python 3.12 and vllm-metal plugin
+# See docs/getting-started/installation.md for Metal setup instructions
+```
+
+See [Installation Docs](docs/getting-started/installation.md) for detailed GPU setup.
+
+## Backend Compatibility
+
+CoTLab supports two inference backends with different strengths:
+
+### 1. vLLM Backend (High Performance)
+Best for large-scale generation experiments.
+- **Supported Experiments**: `cot_faithfulness`, `radiology`
+- **Supported Models**: All text-only models (e.g., `gemma_270m`, `medgemma_27b_text_it`)
+- **Limitation**: Does NOT support activation patching or internal state access.
+- **Note**: Gemma 3 multimodal models (e.g., `medgemma_4b_it`) are currently incompatible with vLLM 0.12.0 due to architecture detection issues. Use `transformers` backend for these.
+
+### 2. Transformers Backend (Full Access)
+Best for mechanistic interpretability and activation patching.
+- **Supported Experiments**: ALL experiments.
+- **Supported Models**: ALL models.
+- **Limitation**: Slower.
+
+To switch backends:
+```bash
+# Use vLLM (fast generation)
+python -m cotlab.main backend=vllm ...
+
+# Use Transformers (activation access)
+python -m cotlab.main backend=transformers ...
+```
+
+## Quick Start
+
+```bash
+# Run logit lens on MedGemma
+python -m cotlab.main experiment=logit_lens model=medgemma_4b
+
+# Find sycophancy heads
+python -m cotlab.main experiment=sycophancy_heads model=medgemma_4b
+
+# Test CoT ablation on pediatrics dataset
+python -m cotlab.main experiment=cot_ablation dataset=pediatrics
+
+# Compare prompt strategies
+python -m cotlab.main -m prompt=chain_of_thought,direct_answer,sycophantic
+```
+
+## Supported Models
+
+CoTLab ships config files for some models, but in principle it supports any model
+that the selected backend can load. Mechanistic experiments can still fail for
+models with unusual architectures.
+
+You can add a model config file for more control over hyperparameters, but you
+can also run any experiment by passing a Hugging Face model name directly.
+
+```bash
+# Use a built-in model config
+python -m cotlab.main model=medgemma_4b
+
+# Or pass any HF model name directly
+python -m cotlab.main model.name=google/gemma-3-270m
+```
+
+If you prefer, you can pre-create model configs with `cotlab-template`, but
+this is optional because CoTLab can auto-generate model configs when running
+with `model=org/repo-id`.
+
+## Configuration
+
+All configs auto-detect layers/heads at runtime. Override via CLI:
+
+```bash
+python -m cotlab.main \
+    model=medgemma_4b \
+    dataset=pediatrics \
+    prompt=chain_of_thought \
+    experiment.top_k=10
+```
+
+## License
+
+MIT

cotlab-0.8.0.dist-info/RECORD

@@ -0,0 +1,65 @@
+cotlab/__init__.py,sha256=y--3rgqeSRBO5vMnx92B_HaS8QIzNlb_6sC5XDE29gs,73
+cotlab/analyse_experiments.py,sha256=1fWqdBKRTgkJO1gREuXvQgO-tYErcEWqLS-TWdQzCO4,12790
+cotlab/cli.py,sha256=b1jLJXmoAlrsz2jL5koMH4eIREXihDOROAitylc3REo,2431
+cotlab/main.py,sha256=vXVHgwqccd0dy1M5upvT9oZciXHkK0kcg58hoinn0gY,11169
+cotlab/runner.py,sha256=Dg5eT4xzsIYNqmJkZ4dY_307YbON_1gCGfF7lbCile4,7898
+cotlab/analysis/__init__.py,sha256=tHoElnfh3Q4nw0J9pQltjhXuxpAfF1vkqW59WRotCY4,263
+cotlab/analysis/cot_parser.py,sha256=ly4pmjWWZZATJeMwvX7XDagSEACA2qnPt8Y0LRQRHX0,7008
+cotlab/analysis/faithfulness_metrics.py,sha256=MpdRBvP0UglQa6poyY4RTi0XtU98I7spbdD9yppvsek,6261
+cotlab/backends/__init__.py,sha256=tPcnXB7TC6HWSgjmch9Dms_d1txe_dyithqv6C99Gy0,370
+cotlab/backends/base.py,sha256=Issi9EJi0HeVfRhaPtQ4hbjOXtJKDAdxbeAp_e2ljXw,1973
+cotlab/backends/transformers_backend.py,sha256=_rQzbhW2rmqHJVOSTm6uzjMtBm14qFDe1zt_UtTbkfU,11377
+cotlab/backends/vllm_backend.py,sha256=PRlD_KrcFciU94fo0GcWgvZfWIj7OxZcoGwHaLmCHro,7374
+cotlab/core/__init__.py,sha256=39XD_yL9RGoNAY6hn_jIXbU8hIhbsvT6P_tAcLl0fbg,669
+cotlab/core/base.py,sha256=TpGy7DnQPTn4pwJYnF0_4mRdjxT3iaz3b4TM7hK6jFU,24254
+cotlab/core/config.py,sha256=_GP5JOPDNQmCsTZc6ELA86PspxhrDRtqCUSFQKUHios,2149
+cotlab/core/registry.py,sha256=Deg-O9cY5nsAfUZ8xxO8kH6tiSCK3TLEaZ4KOOdtXME,1618
+cotlab/datasets/__init__.py,sha256=wcEZZDOYaPdqE0RRXfeaQIzRzMfC9iExmWn0jGkoNAE,932
+cotlab/datasets/loaders.py,sha256=Wp854_UM52tXjYYU0ZTvBgNWQhdRp-Srcj46O5c8tlo,61236
+cotlab/experiment/__init__.py,sha256=aPnVcJ8pkjwQ1m1ZOgqVnIPEun57W80O9-lU_tXioWU,11323
+cotlab/experiments/__init__.py,sha256=72CoKW05xzr6NZhpDYVF6DWO7XPN3v7ARNEoOINZIBU,1737
+cotlab/experiments/activation_compare.py,sha256=DjNOAySg5boOWsgfnvue_rmINq-VOGdVJfIYKSCRb2s,11736
+cotlab/experiments/activation_patching.py,sha256=Pwv4nTVvtu8qCufWnJdSkexPR_LSWhdFLwwStcmMemQ,44682
+cotlab/experiments/attention_analysis.py,sha256=kPj_MoVqnosR1jW-z32B2Ugu7vcP4GJ9w7dTd9t9GUM,40220
+cotlab/experiments/classification.py,sha256=VzoS0ePmdwEJiU44lxm9LD7vwTgA0k2UABA-oJ1a2vc,8634
+cotlab/experiments/composite_shift_detector.py,sha256=AM6Nb0pFvyE8wSn8INs0WmYTxMTJl0zAWJIEKM0dbTA,21326
+cotlab/experiments/cot_ablation.py,sha256=GG5y4qSCSp4Kyoqvs9_UYkNLAIUwPQObGBkHa0PK7fI,10297
+cotlab/experiments/cot_faithfulness.py,sha256=HXmE6vX4BYcDf6kzCRA0VhVwBbiupyOSDYkfmfrqxHk,7117
+cotlab/experiments/cot_heads.py,sha256=9il1Ebll18_id30OGqBk76bxp4uzaEjo4wP62cN6UYs,7555
+cotlab/experiments/full_layer_cot.py,sha256=Xoq13GubsUptIKXx6OmKkIw7NDt0h8bJGlvIXbuMG8c,8194
+cotlab/experiments/full_layer_patching.py,sha256=H42W_z7k0ytTp-2MR1fieLT-YA7N-0543InVAtPu1Fs,8344
+cotlab/experiments/h_neuron_analysis.py,sha256=kltUXGtgb42m_Ml-cm918Ae_AZJBLgRmidjofaGsqLQ,29465
+cotlab/experiments/logit_lens.py,sha256=FE7-u3n1JPiNZONtFss2ZeTpOCio7Qe1yXIHQQ0GyZw,17654
+cotlab/experiments/multi_head_cot.py,sha256=v5pPKS0c57Vk5tWp1wl5X_0Ghcrycedwb-k1A2TVRvY,7802
+cotlab/experiments/multi_head_patching.py,sha256=-8_1lt64lUyNs74lvgZ7_4yabAl90akyg1ltJ5UKjVU,8478
+cotlab/experiments/probing_classifier.py,sha256=TYqjVXpk9ZRJfLZ-R4BJnEPPM5mEA7f6APe0RjGt5Bk,14835
+cotlab/experiments/residual_norm_ood.py,sha256=oWiElDgIG7TkYxzIo9etRkMHtTSwOI6gJ8eTsi00_po,16384
+cotlab/experiments/sae_feature_analysis.py,sha256=maY6wQsMTy_E4JvFLfNr3LMX1DvT7cCtml4fvATm6I4,27976
+cotlab/experiments/steering_vectors.py,sha256=lVRT0FyvzpeEMJg_4LlsFNQvNUNVW8AjANwDr7LiKqI,8800
+cotlab/experiments/sycophancy_heads.py,sha256=5NmeAk3U3sr4tR5XsAjHZa_TyBL8sGmPTwwnqPk-NHI,8152
+cotlab/logging/__init__.py,sha256=6d0OSqKkzpfHdKlfnKVQqRBkCziXqnX2PecNtzLlmZI,97
+cotlab/logging/json_logger.py,sha256=ERDTa6oV-ArKKO26tQexnG077dgLH71uQjt_EjArHDg,5015
+cotlab/patching/__init__.py,sha256=mXvfO_hJ6dygEeGW-xcouUDpc79DP48rBBDS25ETMrc,542
+cotlab/patching/cache.py,sha256=o402BKEKuNoAz6NKxuo06H3iO65V7vz0HIl0-PozFxI,4547
+cotlab/patching/hooks.py,sha256=Q_Pz78vwKf846adbzJTO1SBWIQQeSCdG7EbpmZOtB3k,20951
+cotlab/patching/interventions.py,sha256=g4y1ni5MWTwxDqHOtT-awwCFSBNh85Laz1PczOBwV4o,2678
+cotlab/patching/patcher.py,sha256=nJqkx8erhP4Npj4iZRsIxc42T8zwtekj4X8t5BbNADU,15697
+cotlab/patching/sae.py,sha256=7XvR8LjQY9MYVUJkZLgGEn38_3qnmp0Y3uWCSQnXdwY,6847
+cotlab/prompts/__init__.py,sha256=axogCx7Ce1upJC53MB5xms1zM7cPMIDIljsDVun6MjM,1278
+cotlab/prompts/cardiology.py,sha256=-fGvhY56q2QXMdLW7QEPDymQUbpZJXjbfHuyWmAlufQ,15698
+cotlab/prompts/histopathology.py,sha256=DfQmljd4Mig2G5loGqiwaGU0tHZw3NIaSn9zCcyPvck,9107
+cotlab/prompts/length_matched_strategies.py,sha256=fnGmWy8uOkSlyWTakY0jJ_9nKg9GCCsSAiDZsibVwsY,4883
+cotlab/prompts/mcq.py,sha256=tkLM8ac8L93mOBQKIfpmBXOSszrhzvvXkLZ4E33p4Mg,8279
+cotlab/prompts/neurology.py,sha256=_h9cozOCHDLaG4n3RVLS3Re305zAV7rTPTtNXnONA5o,14782
+cotlab/prompts/oncology.py,sha256=OmBWSOUJTwVXDPD998vV440EoYbeWCbtzDthiBXXR1s,14807
+cotlab/prompts/plab.py,sha256=w1-xluqTmzjXHgnhW1XNU7MAhab8vQuiKichwIogwM0,5894
+cotlab/prompts/pubhealthbench.py,sha256=XaGYMrjUfSMrfohK1xXegxcog1oeQwSS6O-3-0nSia4,3011
+cotlab/prompts/pubmedqa.py,sha256=S7Ru94gAtl7dmSCzk5IwJxXcMemHahyPablRRFS0zIg,6983
+cotlab/prompts/radiology.py,sha256=KLHeuD2ayWMOvNDJ2pUy_1iPLWjNBDDscCDPRVuS1W8,18007
+cotlab/prompts/strategies.py,sha256=TdJNPbJqPeL9l9y2Q8wQMBgWAUKIJUokzyGcWoVKu7U,31295
+cotlab/prompts/tcga.py,sha256=lieql237kCaSoa-hyvOfpVNmmoXYGfK1KnwYKNZhtPQ,5633
+cotlab-0.8.0.dist-info/METADATA,sha256=NisTk2jRQ9wMO5d3DG_pOL0j7BqSThKPBFhCM-NDtL0,5751
+cotlab-0.8.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+cotlab-0.8.0.dist-info/entry_points.txt,sha256=GHChdvu9KbueSjPgUwDWZOvFTmUxKJnhPY1SC0pWRQE,77
+cotlab-0.8.0.dist-info/licenses/LICENSE,sha256=DKx8N2g6-am9PRrJHYm35-nlhNA-3tcdr5IHRj_1HyA,1078
+cotlab-0.8.0.dist-info/RECORD,,

cotlab-0.8.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

cotlab-0.8.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+cotlab = cotlab.main:main
+cotlab-template = cotlab.cli:cli

cotlab-0.8.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-2026 Hüseyin Çavuş
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.