Initial deployment: Antibody non-specificity predictor

- ESM-1v (650M) + Logistic Regression
- Trained on Boughter dataset
- Pydantic v2 validation
- Gradio 5.x UI

README.md

@@ -1,12 +1,67 @@
 ---
-title: Antibody Predictor
-emoji: 🐨
-colorFrom: pink
-colorTo: indigo
+title: Antibody Non-Specificity Predictor
+emoji: 🧬
+colorFrom: blue
+colorTo: green
 sdk: gradio
-sdk_version: 6.0.0
-app_file: app.py
+sdk_version: "5.0.0"
+app_file: spaces/app.py
 pinned: false
+license: mit
+tags:
+  - antibody
+  - protein
+  - ESM
+  - gradio
+  - polyreactivity
+  - machine-learning
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🧬 Antibody Non-Specificity Predictor
+
+Predict antibody polyreactivity (non-specificity) from Variable Heavy (VH) or Variable Light (VL) sequences using ESM-1v protein language models.
+
+## Model
+
+- **Architecture:** ESM-1v (650M parameters) + Logistic Regression
+- **Training Data:** Boughter dataset (914 antibodies, ELISA polyreactivity)
+- **Methodology:** Sakhnini et al. (2025) - Prediction of Antibody Non-Specificity using PLMs
+
+## Usage
+
+1. Paste your antibody VH or VL amino acid sequence
+2. Click "🔬 Predict Non-Specificity"
+3. Get prediction (specific vs non-specific) + probability
+
+## Supported Input
+
+- **Valid characters:** Standard amino acids (ACDEFGHIKLMNPQRSTVWY)
+- **Max length:** 2000 amino acids
+- **Auto-cleaning:** Lowercase automatically converted to uppercase
+
+## Examples
+
+The app includes example sequences:
+- Standard VH (128aa)
+- Standard VL (107aa)
+- Short VH (Herceptin-like)
+
+## Citation
+
+If you use this tool in your research, please cite:
+
+```bibtex
+@article{sakhnini2025antibody,
+  title={Prediction of Antibody Non-Specificity using Protein Language Models},
+  author={Sakhnini, et al.},
+  year={2025}
+}
+```
+
+## Repository
+
+Full source code: [antibody_training_pipeline_ESM](https://github.com/The-Obstacle-Is-The-Way/antibody_training_pipeline_ESM)
+
+## License
+
+MIT License - See repository for details

app.py

@@ -0,0 +1,152 @@
+"""
+Hugging Face Spaces Gradio App for Antibody Non-Specificity Prediction
+
+Simplified deployment version (no Hydra, no complex dependencies).
+Works on HF Spaces free CPU tier.
+
+Local app (src/antibody_training_esm/cli/app.py) remains unchanged.
+"""
+
+import logging
+import os
+
+import gradio as gr
+import torch
+from pydantic import ValidationError
+
+from antibody_training_esm.core.prediction import Predictor
+from antibody_training_esm.models.prediction import PredictionRequest
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# HF Spaces environment detection
+IS_HF_SPACE = os.getenv("SPACE_ID") is not None
+
+# Model path (either local or downloaded from HF Hub)
+MODEL_PATH = os.getenv(
+    "MODEL_PATH", "experiments/checkpoints/esm1v/logreg/boughter_vh_esm1v_logreg.pkl"
+)
+
+# ESM model name
+MODEL_NAME = "facebook/esm1v_t33_650M_UR90S_1"
+
+# Force CPU for HF Spaces free tier
+DEVICE = "cpu"
+
+# Load model globally (HF Spaces best practice)
+logger.info(f"Loading model from {MODEL_PATH}...")
+predictor = Predictor(
+    model_name=MODEL_NAME, classifier_path=MODEL_PATH, device=DEVICE, config_path=None
+)
+
+# Warm up model
+try:
+    logger.info("Warming up model...")
+    predictor.predict_single("QVQL")
+    logger.info("Model ready!")
+except Exception as e:
+    logger.warning(f"Warmup failed (non-fatal): {e}")
+
+
+def predict_sequence(sequence: str) -> tuple[str, str]:
+    """
+    Prediction function for Gradio interface.
+
+    Args:
+        sequence: Antibody amino acid sequence
+
+    Returns:
+        Tuple of (prediction, probability)
+    """
+    try:
+        # Validate with Pydantic
+        request = PredictionRequest(sequence=sequence)
+
+        # Log request
+        logger.info(f"Processing sequence: length={len(request.sequence)}")
+
+        # Predict
+        result = predictor.predict_single(request)
+
+        # Format probability
+        prob_percent = f"{result.probability:.1%}"
+
+        return result.prediction, prob_percent
+
+    except ValidationError as e:
+        # User-friendly error message
+        error_msg = e.errors()[0]["msg"]
+        raise gr.Error(error_msg) from e
+    except torch.cuda.OutOfMemoryError as e:
+        logger.error("GPU OOM during inference")
+        raise gr.Error(
+            "Server overloaded (GPU OOM). Please try again in a moment."
+        ) from e
+    except Exception as e:
+        logger.exception("Unexpected prediction failure")
+        raise gr.Error(f"Prediction failed: {str(e)}") from e
+
+
+# Example sequences
+examples = [
+    [
+        "QVQLVQSGAEVKKPGASVKVSCKASGYTFTSYNMHWVRQAPGQGLEWMGGIYPGDSDTRYSPSFQGQVTISADKSISTAYLQWSSLKASDTAMYYCARSTYYGGDWYFNVWGQGTLVTVSS"
+    ],  # Standard VH
+    [
+        "DIQMTQSPSSLSASVGDRVTITCRASQSISSYLNWYQQKPGKAPKLLIYAASSLQSGVPSRFSGSGSGTDFTLTISSLQPEDFATYYCQQSYSTPLTFGGGTKVEIK"
+    ],  # Standard VL
+    [
+        "EVQLVESGGGLVQPGGSLRLSCAASGFNIKDTYIHWVRQAPGKGLEWVARIYPTNGYTRYADSVKGRFTISADTSKNTAYLQMNSLRAEDTAVYYCARSWGQGTLVTVSS"
+    ],  # Short VH
+]
+
+# Create Gradio interface
+iface = gr.Interface(
+    fn=predict_sequence,
+    inputs=gr.TextArea(
+        lines=7,
+        max_lines=20,
+        max_length=2000,
+        label="Antibody Sequence (VH or VL)",
+        placeholder="Paste amino acid sequence here (e.g., QVQL...)",
+        info="Supported characters: Standard amino acids (ACDEFGHIKLMNPQRSTVWY).",
+        show_copy_button=True,
+    ),
+    outputs=[
+        gr.Textbox(label="Prediction", show_copy_button=True),
+        gr.Textbox(label="Probability of Non-Specificity", show_copy_button=True),
+    ],
+    title="🧬 Antibody Non-Specificity Predictor",
+    description=(
+        "Predict antibody polyreactivity (non-specificity) from Variable Heavy (VH) "
+        "or Variable Light (VL) sequences using ESM-1v protein language models.\n\n"
+        "**Model:** ESM-1v (650M parameters) + Logistic Regression\n"
+        "**Training:** Boughter dataset (914 antibodies, ELISA polyreactivity)\n"
+        "**Citation:** Sakhnini et al. (2025) - Prediction of Antibody Non-Specificity using PLMs"
+    ),
+    article=(
+        f"**Model:** {MODEL_NAME}\n"
+        f"**Device:** {DEVICE}\n"
+        f"**Environment:** {'Hugging Face Spaces' if IS_HF_SPACE else 'Local'}"
+    ),
+    examples=examples,
+    cache_examples=False,  # Don't cache on HF Spaces (saves disk)
+    flagging_mode="never",
+    analytics_enabled=False,
+    submit_btn="🔬 Predict Non-Specificity",
+    clear_btn="🗑️ Clear",
+)
+
+# Enable queue for concurrency
+iface.queue(default_concurrency_limit=2, max_size=10)
+
+# Launch app
+if __name__ == "__main__":
+    iface.launch(
+        server_name="0.0.0.0",  # Required for HF Spaces
+        server_port=7860,
+        share=False,
+        show_api=False,  # No public REST API
+    )

experiments/checkpoints/esm1v/logreg/boughter_vh_esm1v_logreg.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d4f77cadfd0ccf3a12c24ce142a91c82b4481d5153a0af662ac4b05a78ef6670
+size 11314

pyproject.toml

@@ -0,0 +1,215 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/antibody_training_esm"]
+include = [
+    "src/antibody_training_esm/conf/**/*.yaml",
+    "src/antibody_training_esm/conf/**/*.py",
+]
+
+[tool.hatch.build.targets.sdist]
+# Source distribution must include all source files + configs
+include = [
+    "src/antibody_training_esm/**/*.py",
+    "src/antibody_training_esm/conf/**/*.yaml",
+    "tests/**/*.py",
+    "README.md",
+    "pyproject.toml",
+    "LICENSE",
+]
+
+[project]
+name = "antibody-training-esm"
+version = "0.7.0"
+description = "Professional antibody training pipeline using ESM protein language models"
+license = {text = "Apache-2.0"}
+requires-python = ">=3.12"
+dependencies = [
+    "authlib>=1.6.5",
+    "biopython>=1.80",
+    "brotli>=1.2.0",
+    "datasets>=4.2.0",
+    "h2>=4.3.0",
+    "hydra-core>=1.3.2",
+    "jupyterlab>=4.4.9",
+    "matplotlib>=3.7.0",
+    "more-itertools",
+    "numpy>=1.24.0",
+    "pandas>=2.0.0",
+    "plotly",
+    "pyparsing>=3.0.0",
+    "PyYAML>=6.0.0",
+    "riot_na",
+    "scikit-learn>=1.3.0",
+    "scipy>=1.10.0",
+    "seaborn>=0.12.0",
+    "torch>=2.6.0",
+    "tqdm>=4.65.0",
+    "transformers>=4.30.0",
+    "xgboost>=2.0.0",
+    "gradio>=4.0.0",
+]
+
+[project.optional-dependencies]
+validation = [
+    "pydantic>=2.10.0",           # Stable v2 release
+    "pydantic-settings>=2.6.0",   # For future config management
+    "pandera>=0.20.0",            # Phase 3: Data Integrity
+]
+dev = [
+    # Testing
+    "pytest>=8.3.0",
+    "pytest-cov>=6.0.0",
+    "pytest-xdist>=3.6.0",
+    "pytest-sugar>=1.0.0",
+
+    # Linting & Formatting
+    "ruff>=0.8.0",
+
+    # Type Checking
+    "mypy>=1.13.0",
+    "pandas-stubs>=2.2.0",
+
+    # Security
+    "bandit[toml]>=1.7.0",
+
+    # Pre-commit
+    "pre-commit>=4.0.0",
+
+    # Documentation
+    "mkdocs>=1.6.0",
+    "mkdocs-material>=9.5.0",
+    "mkdocstrings[python]>=0.26.0",
+    "mkdocs-gen-files>=0.5.0",
+    "mkdocs-literate-nav>=0.6.0",
+    "mkdocs-section-index>=0.3.0",
+    "pymdown-extensions>=10.0.0",
+]
+
+[project.scripts]
+# Point directly to Hydra-decorated function to enable config group overrides
+# (antibody-train model=esm2_650m classifier=xgboost now works correctly)
+antibody-train = "antibody_training_esm.core.trainer:main"
+antibody-test = "antibody_training_esm.cli.test:main"
+antibody-preprocess = "antibody_training_esm.cli.preprocess:main"
+antibody-predict = "antibody_training_esm.cli.predict:main"
+antibody-app = "antibody_training_esm.cli.app:main"
+
+[tool.ruff]
+target-version = "py312"
+line-length = 88
+
+[tool.ruff.lint]
+select = [
+    "E",    # pycodestyle errors
+    "W",    # pycodestyle warnings
+    "F",    # pyflakes
+    "I",    # isort
+    "B",    # flake8-bugbear
+    "C4",   # flake8-comprehensions
+    "UP",   # pyupgrade
+    "ARG",  # flake8-unused-arguments
+    "SIM",  # flake8-simplify
+]
+ignore = [
+    "E501",  # line too long (handled by formatter)
+]
+
+[tool.ruff.lint.per-file-ignores]
+"__init__.py" = ["F401"]
+"tests/**/*" = ["ARG"]
+"experiments/**/*" = ["ALL"]
+"reference_repos/**/*" = ["ALL"]
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+
+[tool.mypy]
+python_version = "3.12"
+warn_return_any = true
+warn_unused_configs = true
+disallow_untyped_defs = true
+ignore_missing_imports = true
+exclude = [
+    "experiments/",
+    "reference_repos/",
+    "site/",  # MkDocs generated documentation
+    "tests/unit/cli/test_train.py",  # Legacy CLI tests (deprecated)
+]
+
+[tool.pytest.ini_options]
+# Pytest Configuration (canonical source - pytest.ini deleted for single source of truth)
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+python_classes = ["Test*"]
+python_functions = ["test_*"]
+addopts = [
+    # Output formatting
+    "-v",
+    "--tb=short",
+    "--strict-markers",
+    "-ra",
+    # Coverage reporting
+    "--cov=src/antibody_training_esm",
+    "--cov-report=html",
+    "--cov-report=term-missing",
+    # Performance
+    "--maxfail=10",
+]
+markers = [
+    "unit: Unit tests (fast, no I/O) - Core business logic",
+    "integration: Integration tests (medium speed, some I/O) - Component interactions",
+    "e2e: End-to-end tests (slow, full pipeline) - Full workflows",
+    "slow: Tests that take >1s to run",
+    "gpu: Tests that require GPU (skip in CI with: -m 'not gpu')",
+    "legacy: Legacy tests for backward compatibility (deprecated, will be removed)",
+]
+filterwarnings = [
+    # sklearn deprecation warnings
+    "ignore:.*__sklearn_tags__.*:DeprecationWarning:sklearn.utils._tags",
+    # sklearn convergence warnings (expected with small test datasets)
+    "ignore:.*lbfgs failed to converge.*:sklearn.exceptions.ConvergenceWarning",
+    "ignore:.*lbfgs failed to converge.*:UserWarning:sklearn.linear_model._logistic",
+    # sklearn scoring warnings (expected when testing edge cases)
+    "ignore:.*Scoring failed.*:UserWarning:sklearn.model_selection._validation",
+    # sklearn undefined metric warnings (expected with edge case test data)
+    "ignore:.*Precision is ill-defined.*:sklearn.exceptions.UndefinedMetricWarning",
+    "ignore:.*Precision is ill-defined.*:UserWarning:sklearn.metrics._classification",
+    # pytest collection warnings (TestConfig is a dataclass, not a test class)
+    "ignore:.*cannot collect test class.*TestConfig.*:pytest.PytestCollectionWarning",
+    # General deprecation warnings
+    "ignore::DeprecationWarning",
+    "ignore::PendingDeprecationWarning",
+]
+
+[tool.coverage.run]
+source = ["src"]
+omit = [
+    "tests/*",
+    "experiments/*",
+    "reference_repos/*",
+    "**/__pycache__/*",
+    ".venv/*",
+    "**/conftest.py",
+]
+branch = true
+
+[tool.coverage.report]
+precision = 2
+exclude_lines = [
+    "pragma: no cover",
+    "def __repr__",
+    "raise AssertionError",
+    "raise NotImplementedError",
+    "if __name__ == .__main__.:",
+    "if TYPE_CHECKING:",
+]
+
+[dependency-groups]
+dev = [
+    "openpyxl>=3.1.5",
+    "types-pyyaml>=6.0.12.20250915",
+]

requirements.txt

@@ -0,0 +1,28 @@
+# Hugging Face Spaces Requirements
+# Minimal dependencies for antibody prediction demo
+
+# Core ML
+torch>=2.0.0
+transformers>=4.30.0
+scikit-learn>=1.3.0
+scipy>=1.10.0
+joblib>=1.3.0
+
+# Data handling
+pandas>=2.0.0
+numpy>=1.24.0
+
+# Configuration
+omegaconf>=2.3.0
+
+# Validation
+pydantic>=2.0.0
+
+# Gradio UI
+gradio>=5.0.0
+
+# Progress bars
+tqdm>=4.65.0
+
+# Install local package (antibody_training_esm)
+.

src/antibody_training_esm/cli/__init__.py

@@ -0,0 +1,10 @@
+"""
+CLI Module
+
+Professional command-line interfaces for antibody training pipeline:
+- antibody-train: Model training
+- antibody-test: Model evaluation
+- antibody-preprocess: Dataset preprocessing
+"""
+
+__all__ = []

src/antibody_training_esm/cli/app.py

@@ -0,0 +1,197 @@
+"""
+This module contains the Gradio app for the antibody non-specificity prediction pipeline.
+"""
+
+import logging
+import platform
+from pathlib import Path
+
+import gradio as gr
+import hydra
+import torch
+from omegaconf import DictConfig
+from pydantic import ValidationError
+
+from antibody_training_esm.core.prediction import Predictor
+from antibody_training_esm.models.prediction import PredictionRequest
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+
+def launch_gradio_app(cfg: DictConfig) -> None:
+    """
+    Launches the Gradio web UI for antibody prediction.
+
+    This function sets up a Gradio interface that allows users to input an
+    antibody sequence and receive a prediction for its non-specificity.
+
+    Args:
+        cfg: The Hydra configuration object.
+    """
+    # Set log level from config
+    logging.basicConfig(
+        level=getattr(logging, cfg.gradio.log_level.upper(), logging.INFO)
+    )
+
+    # Robust Device & Threading Configuration
+    # -------------------------------------------------------------------------
+    # 1. Determine the optimal device for inference
+    #    - Prefer CUDA if available (Linux/Windows GPU boxes)
+    #    - Force CPU on macOS if MPS is detected to avoid Gradio+MPS SegFaults
+    #    - Default to configured value otherwise
+    device = cfg.model.get("device", "cpu")
+
+    if platform.system() == "Darwin" and device == "mps":
+        logger.warning(
+            "macOS detected. Forcing CPU for Gradio app stability (MPS workaround)."
+        )
+        device = "cpu"
+
+    # 2. Configure Threading to prevent OpenMP SegFaults on macOS
+    #    - On macOS/CPU, PyTorch's OpenMP runtime can crash inside Gradio threads.
+    #    - We restrict it to 1 thread to ensure stability.
+    #    - Linux/CUDA systems remain untouched and can use full parallelism.
+    if platform.system() == "Darwin" and device == "cpu":
+        logger.warning(
+            "macOS/CPU detected. Setting torch.set_num_threads(1) to prevent OpenMP crashes."
+        )
+        torch.set_num_threads(1)
+
+    if cfg.classifier.path is None:
+        raise ValueError(
+            "Classifier path must be specified via command-line override:\n"
+            "  classifier.path=experiments/checkpoints/esm1v/logreg/boughter_vh_esm1v_logreg.pkl"
+        )
+    classifier_path = Path(cfg.classifier.path)
+    if not classifier_path.exists():
+        raise FileNotFoundError(
+            f"Classifier file not found at {classifier_path}. "
+            "Train a model (e.g., `make train`) or download a published checkpoint first."
+        )
+
+    # Instantiate the predictor
+    config_path = getattr(cfg.classifier, "config_path", None)
+    predictor = Predictor(
+        model_name=cfg.model.name,
+        classifier_path=cfg.classifier.path,
+        device=device,
+        config_path=config_path,
+    )
+
+    # Warm-up: Run a dummy prediction to load the model into memory eagerly
+    try:
+        logger.info("Warming up model with dummy prediction...")
+        predictor.predict_single("QVQL")
+        logger.info("Model warmed up and ready.")
+    except Exception as e:
+        logger.warning(f"Model warm-up failed (non-fatal): {e}")
+
+    def predict_sequence(sequence: str) -> tuple[str, str]:
+        """
+        Prediction function for the Gradio interface.
+
+        Args:
+            sequence: The antibody sequence to predict.
+
+        Returns:
+            A tuple containing the prediction string and the formatted probability.
+        """
+        try:
+            # Validate with Pydantic (replaces old validate_input)
+            request = PredictionRequest(sequence=sequence)
+
+            # Log request (observability)
+            logger.info(f"Processing: length={len(request.sequence)}")
+
+            # Predict (returns PydanticResult)
+            result = predictor.predict_single(request)
+
+            # Format probability
+            prob_percent = f"{result.probability:.1%}"
+
+            return result.prediction, prob_percent
+
+        except ValidationError as e:
+            # Extract first error message for user-friendly display
+            error_msg = e.errors()[0]["msg"]
+            raise gr.Error(error_msg) from e
+        except torch.cuda.OutOfMemoryError as e:
+            logger.error("GPU OOM during inference")
+            raise gr.Error(
+                "Server overloaded (GPU OOM). Please try again in a moment."
+            ) from e
+        except Exception as e:
+            logger.exception("Unexpected prediction failure")
+            raise gr.Error(f"Prediction failed: {str(e)}") from e
+
+    # Example sequences (Diverse set)
+    examples = [
+        [
+            "QVQLVQSGAEVKKPGASVKVSCKASGYTFTSYNMHWVRQAPGQGLEWMGGIYPGDSDTRYSPSFQGQVTISADKSISTAYLQWSSLKASDTAMYYCARSTYYGGDWYFNVWGQGTLVTVSS"
+        ],  # Standard VH
+        [
+            "DIQMTQSPSSLSASVGDRVTITCRASQSISSYLNWYQQKPGKAPKLLIYAASSLQSGVPSRFSGSGSGTDFTLTISSLQPEDFATYYCQQSYSTPLTFGGGTKVEIK"
+        ],  # Standard VL
+        [
+            "EVQLVESGGGLVQPGGSLRLSCAASGFNIKDTYIHWVRQAPGKGLEWVARIYPTNGYTRYADSVKGRFTISADTSKNTAYLQMNSLRAEDTAVYYCARSWGQGTLVTVSS"
+        ],  # Short VH (Herceptin-like)
+    ]
+
+    # Create the Gradio interface
+    iface = gr.Interface(
+        fn=predict_sequence,
+        inputs=gr.TextArea(
+            lines=7,
+            max_lines=20,
+            max_length=2000,
+            label="Antibody Sequence (VH or VL)",
+            placeholder="Paste amino acid sequence here (e.g., QVQL...)",
+            info="Supported characters: Standard amino acids (ACDEFGHIKLMNPQRSTVWY).",
+            show_copy_button=True,
+        ),
+        outputs=[
+            gr.Textbox(label="Prediction", show_copy_button=True),
+            gr.Textbox(label="Probability of Non-Specificity", show_copy_button=True),
+        ],
+        title="Antibody Non-Specificity Predictor",
+        description=(
+            "Enter an antibody Variable Heavy (VH) or Variable Light (VL) sequence "
+            "to predict its non-specificity (polyreactivity)."
+        ),
+        article=f"Model: {cfg.model.name} | Device: {device}",
+        examples=examples,
+        cache_examples=True,
+        flagging_mode="never",
+        analytics_enabled=False,
+        submit_btn="Predict Non-Specificity",
+    )
+
+    # Enable queueing for concurrency management
+    """
+    Queue Configuration:
+    - concurrency_limit: Based on available VRAM (approx 3GB per ESM-1v inference).
+    - max_size: Prevents unbounded queue growth under load.
+    """
+    iface.queue(
+        default_concurrency_limit=cfg.gradio.queue.concurrency_limit,
+        max_size=cfg.gradio.queue.max_size,
+    )
+
+    # Launch the app with hardened settings
+    iface.launch(
+        server_name=cfg.gradio.server_name,
+        server_port=cfg.gradio.server_port,
+        share=cfg.gradio.share,
+        show_api=False,
+    )
+
+
+@hydra.main(config_path="../conf", config_name="predict", version_base=None)
+def main(cfg: DictConfig) -> None:
+    """Main function to run the Gradio app."""
+    launch_gradio_app(cfg)
+
+
+if __name__ == "__main__":
+    main()

src/antibody_training_esm/cli/predict.py

@@ -0,0 +1,116 @@
+import sys
+from pathlib import Path
+from typing import cast
+
+import hydra
+import pandas as pd
+from omegaconf import DictConfig
+from pydantic import ValidationError
+
+from antibody_training_esm.core.config import SEQUENCE_PREVIEW_LENGTH
+from antibody_training_esm.core.prediction import Predictor, run_prediction
+from antibody_training_esm.models.prediction import AssayType, PredictionRequest
+
+
+def predict_sequence_cli(
+    sequence: str, threshold: float, assay_type: AssayType | None, cfg: DictConfig
+) -> None:
+    """CLI prediction with Pydantic validation."""
+    config_path = getattr(cfg.classifier, "config_path", None)
+
+    # Instantiate predictor (loading model)
+    try:
+        predictor = Predictor(
+            model_name=cfg.model.name,
+            classifier_path=cfg.classifier.path,
+            config_path=config_path,
+        )
+    except Exception as e:
+        print(f"Error loading model: {e}")
+        sys.exit(1)
+
+    try:
+        request = PredictionRequest(
+            sequence=sequence,
+            threshold=threshold,
+            assay_type=assay_type,
+        )
+        result = predictor.predict_single(request)
+
+        # Print formatted output
+        print(
+            f"Sequence: {result.sequence[:SEQUENCE_PREVIEW_LENGTH]}..."
+            if len(result.sequence) > SEQUENCE_PREVIEW_LENGTH
+            else f"Sequence: {result.sequence}"
+        )
+        print(f"Prediction: {result.prediction}")
+        print(f"Probability: {result.probability:.2%}")
+
+    except ValidationError as e:
+        print("❌ Validation Error:")
+        for error in e.errors():
+            # loc is a tuple, e.g. ('sequence',)
+            loc = error["loc"][0] if error["loc"] else "root"
+            print(f"  - {loc}: {error['msg']}")
+        sys.exit(1)
+
+
+@hydra.main(config_path="../conf", config_name="predict", version_base=None)
+def main(cfg: DictConfig) -> None:
+    """Main function to run the prediction CLI."""
+
+    # Check for single sequence prediction mode
+    sequence = getattr(cfg, "sequence", None)
+    if sequence:
+        threshold = getattr(cfg, "threshold", 0.5)
+        assay_type = cast(AssayType | None, getattr(cfg, "assay_type", None))
+        predict_sequence_cli(sequence, threshold, assay_type, cfg)
+        return
+
+    # Validate required arguments for batch mode
+    if cfg.input_file is None:
+        raise ValueError(
+            "Input file must be specified via command-line override: `input_file=...`"
+        )
+
+    if cfg.classifier.path is None:
+        raise ValueError(
+            "Classifier path must be specified via command-line override:\n"
+            "  classifier.path=experiments/checkpoints/esm1v/logreg/boughter_vh_esm1v_logreg.pkl\n"
+            "  # OR for production models (.npz):\n"
+            "  classifier.path=experiments/.../model.npz classifier.config_path=.../model_config.json\n"
+            "\nExample usage:\n"
+            "  uv run antibody-predict \\\n"
+            "      input_file=data/test.csv \\\n"
+            "      output_file=predictions.csv \\\n"
+            "      classifier.path=path/to/model.pkl"
+        )
+    classifier_path = Path(cfg.classifier.path)
+    if not classifier_path.exists():
+        raise FileNotFoundError(
+            f"Classifier file not found at {classifier_path}. "
+            "Train a model (e.g., `make train`) or download a published checkpoint first."
+        )
+
+    try:
+        # Load input data
+        input_df = pd.read_csv(cfg.input_file)
+
+        # Run prediction
+        output_df = run_prediction(input_df, cfg)
+
+        # Save output data
+        output_df.to_csv(cfg.output_file, index=False)
+
+        print(f"Predictions saved to {cfg.output_file}")
+
+    except FileNotFoundError:
+        print(f"Error: Input file not found at {cfg.input_file}")
+        exit(1)
+    except Exception as e:
+        print(f"An error occurred: {e}")
+        exit(1)
+
+
+if __name__ == "__main__":
+    main()

src/antibody_training_esm/cli/preprocess.py

@@ -0,0 +1,84 @@
+"""
+Preprocessing CLI
+
+Professional command-line interface for dataset preprocessing.
+"""
+
+import argparse
+import sys
+
+
+def main() -> int:
+    """
+    Main entry point for preprocessing CLI.
+
+    This CLI does NOT run preprocessing - it only provides guidance on which
+    preprocessing scripts to use. Preprocessing is handled by specialized
+    scripts that are the Single Source of Truth (SSOT).
+    """
+    parser = argparse.ArgumentParser(
+        description="Antibody dataset preprocessing guidance",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+NOTE: This CLI does NOT run preprocessing. It provides guidance on which
+preprocessing scripts to use. Each dataset has unique requirements and the
+scripts maintain bit-for-bit parity with published methods.
+        """,
+    )
+
+    parser.add_argument(
+        "--dataset",
+        "-d",
+        type=str,
+        required=True,
+        choices=["jain", "harvey", "shehata", "boughter"],
+        help="Dataset to get preprocessing guidance for",
+    )
+
+    args = parser.parse_args()
+
+    try:
+        print("\n⚠️  The 'antibody-preprocess' CLI is not implemented")
+        print(
+            "\nDataset preprocessing is handled by specialized scripts, not this CLI."
+        )
+        print(
+            "These scripts are the authoritative source of truth for data transformation."
+        )
+        print(f"\nFor {args.dataset} dataset, use:")
+
+        script_paths = {
+            "jain": "preprocessing/jain/step2_preprocess_p5e_s2.py",
+            "harvey": "preprocessing/harvey/step2_extract_fragments.py",
+            "shehata": "preprocessing/shehata/step2_extract_fragments.py",
+            "boughter": "preprocessing/boughter/stage2_stage3_annotation_qc.py",
+        }
+
+        script = script_paths.get(args.dataset)
+        if script:
+            print(f"  python {script}")
+
+        print("\nWhy use scripts instead of this CLI?")
+        print("  • Scripts are Single Source of Truth (SSOT) for preprocessing")
+        print(
+            "  • Each dataset has unique requirements (DNA translation, PSR thresholds, etc.)"
+        )
+        print("  • Scripts maintain bit-for-bit parity with published methods")
+        print("  • CLI is for loading preprocessed data, not creating it")
+
+        print("\nFor more information:")
+        print("  • See src/antibody_training_esm/datasets/README.md")
+        print("  • See docs/boughter/boughter_data_sources.md (dataset-specific)")
+
+        return 0
+
+    except KeyboardInterrupt:
+        print("\n❌ Error: Interrupted by user", file=sys.stderr)
+        return 1
+    except Exception as e:
+        print(f"\n❌ Error: {e}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

src/antibody_training_esm/cli/test.py

@@ -0,0 +1,155 @@
+#!/usr/bin/env python3
+"""
+Test CLI for Antibody Classification Pipeline
+
+Professional command-line interface for testing trained antibody classifiers:
+1. Load trained models from pickle files
+2. Evaluate on test datasets with performance metrics
+3. Generate confusion matrices and comprehensive logging
+
+Usage:
+    antibody-test --model experiments/checkpoints/antibody_classifier.pkl --data sample_data.csv
+    antibody-test --config test_config.yaml
+    antibody-test --model m1.pkl m2.pkl --data d1.csv d2.csv
+"""
+
+import argparse
+import sys
+
+from antibody_training_esm.cli.testing.config import (
+    TestConfig,
+    create_sample_test_config,
+    load_config_file,
+)
+from antibody_training_esm.cli.testing.tester import ModelTester
+
+
+def main() -> int:
+    """Main entry point for antibody-test CLI"""
+    parser = argparse.ArgumentParser(
+        description="Testing for antibody classification models",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+    # Test single model on single dataset (auto-detects threshold from dataset name)
+    antibody-test --model experiments/checkpoints/antibody_classifier.pkl --data sample_data.csv
+
+    # Test on PSR dataset with auto-detected threshold (0.5495 for Harvey/Shehata)
+    antibody-test --model model.pkl --data data/test/harvey/fragments/VHH_only_harvey.csv
+
+    # Test multiple models on multiple datasets
+    antibody-test --model experiments/checkpoints/model1.pkl experiments/checkpoints/model2.pkl --data dataset1.csv dataset2.csv
+
+    # Use configuration file
+    antibody-test --config test_config.yaml
+
+    # Override device, batch size, and threshold
+    antibody-test --config test_config.yaml --device cuda --batch-size 64 --threshold 0.6
+
+    # Create sample configuration
+    antibody-test --create-config
+        """,
+    )
+
+    parser.add_argument(
+        "--model", nargs="+", help="Path(s) to trained model pickle files"
+    )
+    parser.add_argument("--data", nargs="+", help="Path(s) to test dataset CSV files")
+    parser.add_argument("--config", help="Path to test configuration YAML file")
+    parser.add_argument(
+        "--output-dir",
+        default="./experiments/benchmarks",
+        help="Output directory for results",
+    )
+    parser.add_argument(
+        "--device",
+        choices=["cpu", "cuda", "mps"],
+        help="Device to use for inference (overrides config)",
+    )
+    parser.add_argument(
+        "--batch-size",
+        type=int,
+        help="Batch size for embedding extraction (overrides config)",
+    )
+    parser.add_argument(
+        "--threshold",
+        type=float,
+        help="Manual decision threshold override (default: auto-detect from dataset name). "
+        "Use 0.5 for ELISA datasets (Boughter, Jain) or 0.5495 for PSR datasets (Harvey, Shehata).",
+    )
+    parser.add_argument(
+        "--sequence-column",
+        type=str,
+        help="Column name for sequences in dataset (default: 'sequence', overrides config)",
+    )
+    parser.add_argument(
+        "--label-column",
+        type=str,
+        help="Column name for labels in dataset (default: 'label', overrides config)",
+    )
+    parser.add_argument(
+        "--create-config", action="store_true", help="Create sample configuration file"
+    )
+
+    args = parser.parse_args()
+
+    # Create sample config if requested
+    if args.create_config:
+        create_sample_test_config()
+        return 0
+
+    # Load configuration
+    if args.config:
+        config = load_config_file(args.config)
+    else:
+        if not args.model or not args.data:
+            parser.error("Either --config or both --model and --data must be specified")
+
+        config = TestConfig(
+            model_paths=args.model, data_paths=args.data, output_dir=args.output_dir
+        )
+
+    # Override config with command line arguments
+    if args.device:
+        config.device = args.device
+    if args.batch_size:
+        config.batch_size = args.batch_size
+    if args.threshold:
+        config.threshold = args.threshold
+    if args.sequence_column:
+        config.sequence_column = args.sequence_column
+    if args.label_column:
+        config.label_column = args.label_column
+
+    # Run testing
+    try:
+        tester = ModelTester(config)
+        results = tester.run_comprehensive_test()
+
+        print(f"\n{'=' * 60}")
+        print("TESTING COMPLETED SUCCESSFULLY!")
+        print(f"{'=' * 60}")
+        print(f"Results saved to: {config.output_dir}")
+
+        # Print summary
+        for dataset_name, dataset_results in results.items():
+            print(f"\nDataset: {dataset_name}")
+            print("-" * 40)
+            for model_name, model_results in dataset_results.items():
+                print(f"Model: {model_name}")
+                if "test_scores" in model_results:
+                    for metric, value in model_results["test_scores"].items():
+                        print(f"  {metric}: {value:.4f}")
+
+        return 0
+
+    except KeyboardInterrupt:
+        print("Error during testing: Interrupted by user", file=sys.stderr)
+        return 1
+    except Exception as e:
+        print(f"Error during testing: {e}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

src/antibody_training_esm/cli/testing/__init__.py

@@ -0,0 +1 @@
+"""Test CLI package."""

src/antibody_training_esm/cli/testing/config.py

@@ -0,0 +1,62 @@
+"""Configuration management for the testing pipeline."""
+
+from dataclasses import dataclass
+
+import yaml
+
+from antibody_training_esm.core.config import DEFAULT_BATCH_SIZE
+
+
+@dataclass
+class TestConfig:
+    """Configuration for testing pipeline"""
+
+    model_paths: list[str]
+    data_paths: list[str]
+    sequence_column: str = "sequence"  # Column name for sequences in dataset
+    label_column: str = "label"  # Column name for labels in dataset
+    output_dir: str = "./experiments/benchmarks"
+    metrics: list[str] | None = None
+    save_predictions: bool = True
+    batch_size: int = DEFAULT_BATCH_SIZE  # Batch size for embedding extraction
+    device: str = "mps"  # Device to use for inference [cuda, cpu, mps] - MUST match training config
+    threshold: float | None = (
+        None  # Manual threshold override (None = auto-detect from dataset name)
+    )
+
+    def __post_init__(self) -> None:
+        if self.metrics is None:
+            self.metrics = [
+                "accuracy",
+                "precision",
+                "recall",
+                "f1",
+                "roc_auc",
+                "pr_auc",
+            ]
+
+
+def load_config_file(config_path: str) -> TestConfig:
+    """Load test configuration from YAML file"""
+    with open(config_path) as f:
+        config_dict = yaml.safe_load(f)
+
+    return TestConfig(**config_dict)
+
+
+def create_sample_test_config() -> None:
+    """Create a sample test configuration file"""
+    sample_config = {
+        "model_paths": ["./experiments/checkpoints/antibody_classifier.pkl"],
+        "data_paths": ["./sample_data.csv"],
+        "sequence_column": "sequence",
+        "label_column": "label",
+        "output_dir": "./experiments/benchmarks",
+        "metrics": ["accuracy", "precision", "recall", "f1", "roc_auc", "pr_auc"],
+        "save_predictions": True,
+    }
+
+    with open("test_config.yaml", "w") as f:
+        yaml.dump(sample_config, f, default_flow_style=False)
+
+    print("Sample test configuration created: test_config.yaml")

src/antibody_training_esm/cli/testing/data.py

@@ -0,0 +1,73 @@
+"""Dataset loading and validation utilities."""
+
+import logging
+import os
+
+import pandas as pd
+
+from antibody_training_esm.cli.testing.config import TestConfig
+
+logger = logging.getLogger(__name__)
+
+
+def load_dataset(data_path: str, config: TestConfig) -> tuple[list[str], list[int]]:
+    """
+    Load dataset from CSV file using configured column names.
+
+    Args:
+        data_path: Path to the CSV file.
+        config: Test configuration object containing column names.
+
+    Returns:
+        Tuple of (sequences, labels).
+    """
+    logger.info(f"Loading dataset from {data_path}")
+
+    if not os.path.exists(data_path):
+        raise FileNotFoundError(f"Dataset file not found: {data_path}")
+
+    # Defensive: Handle legacy files with comment headers
+    # New files (post-HF cleanup) are standard CSVs without comments
+    df = pd.read_csv(data_path, comment="#")
+
+    sequence_col = config.sequence_column
+    label_col = config.label_column
+
+    if sequence_col not in df.columns:
+        raise ValueError(
+            f"Sequence column '{sequence_col}' not found in dataset. Available columns: {list(df.columns)}"
+        )
+    if label_col not in df.columns:
+        raise ValueError(
+            f"Label column '{label_col}' not found in dataset. Available columns: {list(df.columns)}"
+        )
+
+    # CRITICAL VALIDATION: Check for NaN labels (P0 bug fix)
+    nan_count = df[label_col].isna().sum()
+    if nan_count > 0:
+        raise ValueError(
+            f"CRITICAL: Dataset contains {nan_count} NaN labels! "
+            f"This will corrupt evaluation metrics. "
+            f"Please use the curated canonical test file (e.g., "
+            f"data/test/jain/canonical/VH_only_jain_86_p5e_s2.csv with no NaNs)."
+        )
+
+    # For Jain test sets, validate expected size (allow legacy 94 + canonical 86)
+    if "jain" in data_path.lower() and "test" in data_path.lower():
+        expected_sizes = {94, 86}
+        if len(df) not in expected_sizes:
+            raise ValueError(
+                f"Jain test set has {len(df)} antibodies but expected one of {sorted(expected_sizes)}. "
+                f"Using the wrong test set will produce invalid metrics. "
+                f"Please use the correct curated file (preferred: "
+                f"data/test/jain/canonical/VH_only_jain_86_p5e_s2.csv)."
+            )
+
+    sequences = df[sequence_col].tolist()
+    labels = df[label_col].tolist()
+
+    logger.info(
+        f"Loaded {len(sequences)} samples from {data_path} (sequence_col='{sequence_col}', label_col='{label_col}')"
+    )
+    logger.info(f"  Label distribution: {pd.Series(labels).value_counts().to_dict()}")
+    return sequences, labels

src/antibody_training_esm/cli/testing/evaluation.py

@@ -0,0 +1,134 @@
+"""Metric calculation and model evaluation utilities."""
+
+import logging
+from typing import Any
+
+import numpy as np
+from sklearn.metrics import (
+    classification_report,
+    confusion_matrix,
+)
+
+from antibody_training_esm.core.classifier import BinaryClassifier
+from antibody_training_esm.models.artifact import EvaluationMetrics
+
+logger = logging.getLogger(__name__)
+
+
+def detect_assay_type(dataset_name: str) -> str | None:
+    """
+    Auto-detect assay type from dataset name for threshold selection
+
+    Args:
+        dataset_name: Name of the dataset (e.g., "VH_only_jain", "VHH_only_harvey")
+
+    Returns:
+        'ELISA' for ELISA-based datasets (Boughter, Jain)
+        'PSR' for PSR-based datasets (Harvey, Shehata)
+        None if unable to detect
+
+    Notes:
+        Novo Nordisk (Sakhnini et al. 2025, Section 2.7):
+        "Antibodies characterised by the PSR assay appear to be on a different
+        non-specificity spectrum than that from the non-specificity ELISA assay."
+
+        PSR datasets require threshold=0.5495 for optimal performance.
+        ELISA datasets use standard threshold=0.5.
+    """
+    dataset_lower = dataset_name.lower()
+
+    # PSR-based datasets (Harvey, Shehata)
+    if any(marker in dataset_lower for marker in ["harvey", "shehata"]):
+        return "PSR"
+
+    # ELISA-based datasets (Boughter, Jain)
+    if any(marker in dataset_lower for marker in ["boughter", "jain"]):
+        return "ELISA"
+
+    # Unable to detect - will use default threshold
+    return None
+
+
+def evaluate_pretrained(
+    model: BinaryClassifier,
+    X: np.ndarray,
+    y: np.ndarray,
+    model_name: str,
+    dataset_name: str,
+    _metrics_list: list[str] | None = None,
+    threshold_override: float | None = None,
+) -> dict[str, Any]:
+    """
+    Evaluate pretrained model directly on test set (no retraining)
+
+    Args:
+        model: The trained BinaryClassifier.
+        X: Embeddings (features).
+        y: True labels.
+        model_name: Name of the model for logging.
+        dataset_name: Name of the dataset for logging.
+        _metrics_list: List of metrics to calculate (default: all).
+        threshold_override: Optional manual threshold.
+
+    Returns:
+        Dictionary of results including scores, predictions, and reports.
+        Contains 'metrics' key with EvaluationMetrics object.
+    """
+    logger.info(f"Evaluating pretrained model {model_name} on {dataset_name}")
+
+    # Determine threshold: manual override > auto-detect > default 0.5
+    if threshold_override is not None:
+        # Manual override via CLI
+        threshold = threshold_override
+        logger.info(f"Using manual threshold override: {threshold}")
+    else:
+        # Auto-detect assay type from dataset name
+        assay_type = detect_assay_type(dataset_name)
+        if assay_type is not None:
+            threshold = model.ASSAY_THRESHOLDS[assay_type]
+            logger.info(
+                f"Auto-detected assay type: {assay_type} → threshold={threshold} "
+                f"(Dataset: {dataset_name})"
+            )
+        else:
+            threshold = 0.5
+            logger.warning(
+                f"Unable to auto-detect assay type for '{dataset_name}'. "
+                f"Using default threshold={threshold}. "
+                f"For optimal results, specify --threshold or use standard dataset names."
+            )
+
+    # Get predictions using the pretrained model with appropriate threshold
+    y_pred = model.predict(
+        X, threshold=threshold, assay_type=None
+    )  # threshold already determined
+    y_proba = model.predict_proba(X)[:, 1]
+
+    # Create Pydantic metrics
+    eval_metrics = EvaluationMetrics.from_sklearn_metrics(
+        y,
+        y_pred,
+        y_proba.reshape(-1, 1) if y_proba.ndim == 1 else y_proba,
+        dataset_name=dataset_name,
+    )
+
+    # Calculate legacy results for compatibility with visualization tools
+    results = {
+        "metrics": eval_metrics,  # Store Pydantic model
+        "test_scores": eval_metrics.model_dump(
+            exclude={"confusion_matrix", "dataset_name", "n_samples"}
+        ),
+        "predictions": {"y_true": y, "y_pred": y_pred, "y_proba": y_proba},
+        "confusion_matrix": confusion_matrix(y, y_pred),
+        "classification_report": classification_report(y, y_pred, output_dict=True),
+    }
+
+    # Log results
+    logger.info(f"Test results for {model_name} on {dataset_name}:")
+    logger.info(f"  Accuracy:  {eval_metrics.accuracy:.4f}")
+    if eval_metrics.f1 is not None:
+        logger.info(f"  F1:        {eval_metrics.f1:.4f}")
+    if eval_metrics.roc_auc is not None:
+        logger.info(f"  ROC-AUC:   {eval_metrics.roc_auc:.4f}")
+
+    return results

src/antibody_training_esm/cli/testing/tester.py

@@ -0,0 +1,384 @@
+"Model orchestration logic."
+
+import json
+import logging
+import os
+import pickle  # nosec B403
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import torch
+
+from antibody_training_esm.cli.testing.config import TestConfig
+from antibody_training_esm.cli.testing.data import load_dataset
+from antibody_training_esm.cli.testing.evaluation import evaluate_pretrained
+from antibody_training_esm.cli.testing.visualization import (
+    plot_confusion_matrix,
+    save_detailed_results,
+)
+from antibody_training_esm.core.classifier import BinaryClassifier
+from antibody_training_esm.core.config import DEFAULT_BATCH_SIZE
+from antibody_training_esm.core.directory_utils import (
+    extract_classifier_shortname,
+    extract_model_shortname,
+    get_hierarchical_test_results_dir,
+)
+from antibody_training_esm.core.embeddings import ESMEmbeddingExtractor
+
+
+class ModelTester:
+    """Model testing orchestrator"""
+
+    def __init__(self, config: TestConfig):
+        self.config = config
+        self.logger = self._setup_logging()
+        self.results: dict[str, Any] = {}
+        self.cached_embedding_files: list[str] = []  # Track cached files for cleanup
+
+        # Create output directory
+        os.makedirs(config.output_dir, exist_ok=True)
+
+    def _setup_logging(self) -> logging.Logger:
+        """Setup logging configuration"""
+        # Create output directory if it doesn't exist
+        os.makedirs(self.config.output_dir, exist_ok=True)
+
+        log_file = os.path.join(
+            self.config.output_dir,
+            f"test_{datetime.now().strftime('%Y%m%d_%H%M%S')}.log",
+        )
+
+        logging.basicConfig(
+            level=logging.INFO,
+            format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+            handlers=[logging.FileHandler(log_file), logging.StreamHandler()],
+        )
+
+        return logging.getLogger(__name__)
+
+    def load_model(self, model_path: str) -> BinaryClassifier:
+        """Load trained model from pickle file"""
+        self.logger.info(f"Loading model from {model_path}")
+
+        if not os.path.exists(model_path):
+            raise FileNotFoundError(f"Model file not found: {model_path}")
+
+        with open(model_path, "rb") as f:
+            model = pickle.load(f)  # nosec B301
+
+        if not isinstance(model, BinaryClassifier):
+            raise ValueError(f"Expected BinaryClassifier, got {type(model)}")
+
+        # Update device if different from config
+        if (
+            hasattr(model, "embedding_extractor")
+            and model.embedding_extractor.device != self.config.device
+        ):
+            self.logger.warning(
+                f"Device mismatch: model trained on {model.embedding_extractor.device}, "
+                f"test config specifies {self.config.device}. Recreating extractor..."
+            )
+
+            # CRITICAL: Explicit cleanup to prevent semaphore leaks (P0 bug fix)
+            old_device = str(model.embedding_extractor.device)
+            old_extractor = model.embedding_extractor
+
+            # Delete old extractor before creating new one
+            del model.embedding_extractor
+            del old_extractor
+
+            # Clear device-specific GPU cache
+            if old_device.startswith("cuda"):
+                torch.cuda.empty_cache()
+            elif old_device.startswith("mps"):
+                torch.mps.empty_cache()
+
+            self.logger.info(f"Cleaned up old extractor on {old_device}")
+
+            # NOW create new extractor (no leak)
+            batch_size = getattr(model, "batch_size", DEFAULT_BATCH_SIZE)
+            revision = getattr(model, "revision", "main")
+            model.embedding_extractor = ESMEmbeddingExtractor(
+                model.model_name, self.config.device, batch_size, revision=revision
+            )
+            model.device = self.config.device
+
+            self.logger.info(f"Created new extractor on {self.config.device}")
+
+        # Update batch_size if different from config
+        if (
+            hasattr(model, "embedding_extractor")
+            and model.embedding_extractor.batch_size != self.config.batch_size
+        ):
+            self.logger.info(
+                f"Updating batch_size from {model.embedding_extractor.batch_size} to {self.config.batch_size}"
+            )
+            model.embedding_extractor.batch_size = self.config.batch_size
+
+        self.logger.info(
+            f"Model loaded successfully: {model_path} on device: {model.embedding_extractor.device}"
+        )
+        return model
+
+    def embed_sequences(
+        self,
+        sequences: list[str],
+        model: BinaryClassifier,
+        dataset_name: str,
+        output_dir: str,
+    ) -> np.ndarray:
+        """Extract embeddings for sequences using the model's embedding extractor"""
+        # Ensure output directory exists before file I/O
+        os.makedirs(output_dir, exist_ok=True)
+
+        cache_file = os.path.join(output_dir, f"{dataset_name}_test_embeddings.pkl")
+
+        # Track this file for cleanup
+        if cache_file not in self.cached_embedding_files:
+            self.cached_embedding_files.append(cache_file)
+
+        # Try to load from cache
+        if os.path.exists(cache_file):
+            try:
+                self.logger.info(f"Loading cached embeddings from {cache_file}")
+                with open(cache_file, "rb") as f:
+                    embeddings: np.ndarray = pickle.load(f)  # nosec B301
+
+                # Validate shape and type
+                if not isinstance(embeddings, np.ndarray):
+                    raise ValueError(f"Invalid cache data type: {type(embeddings)}")
+                if embeddings.ndim != 2:
+                    raise ValueError(f"Invalid embedding shape: {embeddings.shape}")
+
+                if len(embeddings) == len(sequences):
+                    self.logger.info(f"Loaded {len(embeddings)} cached embeddings")
+                    return embeddings
+                else:
+                    self.logger.warning(
+                        "Cached embeddings size mismatch, recomputing..."
+                    )
+
+            except (pickle.UnpicklingError, EOFError, ValueError, AttributeError) as e:
+                self.logger.warning(
+                    f"Failed to load cached embeddings from {cache_file}: {e}. "
+                    "Recomputing embeddings..."
+                )
+                # Fall through to recomputation below
+
+        # Extract embeddings
+        self.logger.info(f"Extracting embeddings for {len(sequences)} sequences...")
+        embeddings = model.embedding_extractor.extract_batch_embeddings(sequences)
+
+        # Cache embeddings
+        with open(cache_file, "wb") as f:
+            pickle.dump(embeddings, f)
+        self.logger.info(f"Embeddings cached to {cache_file}")
+
+        return embeddings
+
+    def cleanup_cached_embeddings(self) -> None:
+        """Delete cached embedding files"""
+        self.logger.info("Cleaning up cached embedding files...")
+        for cache_file in self.cached_embedding_files:
+            if os.path.exists(cache_file):
+                try:
+                    os.remove(cache_file)
+                    self.logger.info(f"Deleted cached embeddings: {cache_file}")
+                except Exception as e:
+                    self.logger.warning(f"Failed to delete {cache_file}: {e}")
+
+    def _compute_output_directory(
+        self,
+        model_path: str | None,
+        dataset_name: str,
+    ) -> str:
+        """Compute output directory (hierarchical if model config available, else flat)."""
+        if model_path is None:
+            self.logger.warning("No model path provided, using flat output structure")
+            return self.config.output_dir
+
+        # Try to load model config JSON
+        model_config_path = (
+            Path(model_path)
+            .with_suffix("")
+            .with_name(Path(model_path).stem + "_config.json")
+        )
+
+        if not model_config_path.exists():
+            self.logger.info(
+                f"Model config not found at {model_config_path}, using flat output structure"
+            )
+            return self.config.output_dir
+
+        try:
+            with open(model_config_path) as f:
+                model_config = json.load(f)
+
+            model_name = model_config.get("model_name") or model_config.get(
+                "esm_model", ""
+            )
+            if not model_name:
+                raise ValueError("Model config missing 'model_name' or 'esm_model'")
+
+            classifier_config = model_config.get("classifier", {})
+
+            # Use shared utility for hierarchical path generation
+            hierarchical_path = get_hierarchical_test_results_dir(
+                base_dir=self.config.output_dir,
+                model_name=model_name,
+                classifier_config=classifier_config,
+                dataset_name=dataset_name,
+            )
+
+            # Extract shortnames for logging
+            model_short = extract_model_shortname(model_name)
+            classifier_short = extract_classifier_shortname(classifier_config)
+
+            self.logger.info(
+                f"Using hierarchical output: {hierarchical_path} "
+                f"(model={model_short}, classifier={classifier_short})"
+            )
+            return str(hierarchical_path)
+
+        except (json.JSONDecodeError, KeyError, ValueError) as e:
+            self.logger.warning(
+                f"Could not determine hierarchical path from model config: {e}. "
+                "Using flat structure."
+            )
+            return self.config.output_dir
+
+    def run_comprehensive_test(self) -> dict[str, dict[str, Any]]:
+        """Run testing pipeline"""
+        self.logger.info("Starting model testing")
+        self.logger.info(f"Models to test: {self.config.model_paths}")
+        self.logger.info(f"Datasets to test: {self.config.data_paths}")
+
+        all_results = {}
+        failed_datasets = []
+        failed_models = []
+
+        try:
+            # Test each dataset
+            for data_path in self.config.data_paths:
+                dataset_name = Path(data_path).stem
+                self.logger.info(f"\n{'=' * 60}")
+                self.logger.info(f"Testing on dataset: {dataset_name}")
+                self.logger.info(f"{'=' * 60}")
+
+                # Load dataset
+                try:
+                    sequences, labels_list = load_dataset(data_path, self.config)
+                    labels: np.ndarray = np.array(labels_list)
+                except Exception as e:
+                    self.logger.error(f"Failed to load dataset {data_path}: {e}")
+                    failed_datasets.append((dataset_name, str(e)))
+                    continue
+
+                dataset_results = {}
+
+                # Test each model
+                for model_path in self.config.model_paths:
+                    model_name = Path(model_path).stem
+                    self.logger.info(f"\nTesting model: {model_name}")
+
+                    output_dir_for_dataset = self._compute_output_directory(
+                        model_path, dataset_name
+                    )
+
+                    try:
+                        # Load model
+                        model = self.load_model(model_path)
+
+                        # Extract embeddings
+                        X_embedded = self.embed_sequences(
+                            sequences,
+                            model,
+                            f"{dataset_name}_{model_name}",
+                            output_dir_for_dataset,
+                        )
+
+                        # Evaluation (delegated to evaluation module)
+                        test_results = evaluate_pretrained(
+                            model,
+                            X_embedded,
+                            labels,
+                            model_name,
+                            dataset_name,
+                            self.config.metrics,
+                            self.config.threshold,
+                        )
+                        dataset_results[model_name] = test_results
+
+                        # Visualization (delegated to visualization module)
+                        single_model_results = {model_name: test_results}
+                        plot_confusion_matrix(
+                            single_model_results,
+                            dataset_name,
+                            output_dir=output_dir_for_dataset,
+                        )
+                        save_detailed_results(
+                            single_model_results,
+                            dataset_name,
+                            self.config.__dict__,
+                            output_dir=output_dir_for_dataset,
+                            save_predictions=self.config.save_predictions,
+                        )
+
+                    except Exception as e:
+                        self.logger.error(f"Failed to test model {model_path}: {e}")
+                        failed_models.append((f"{dataset_name}_{model_name}", str(e)))
+                        continue
+
+                # Generate aggregated multi-model report
+                if dataset_results:
+                    aggregated_output_dir = self.config.output_dir
+                    self.logger.info(
+                        f"Generating aggregated multi-model report for {dataset_name} "
+                        f"in {aggregated_output_dir}"
+                    )
+
+                    plot_confusion_matrix(
+                        dataset_results,
+                        dataset_name,
+                        output_dir=aggregated_output_dir,
+                    )
+                    save_detailed_results(
+                        dataset_results,
+                        dataset_name,
+                        self.config.__dict__,
+                        output_dir=aggregated_output_dir,
+                        save_predictions=self.config.save_predictions,
+                    )
+
+                all_results[dataset_name] = dataset_results
+
+            # Check if all tests failed
+            if not all_results:
+                error_msg = "All tests failed:\n"
+                if failed_datasets:
+                    error_msg += (
+                        f"  Failed datasets: {[name for name, _ in failed_datasets]}\n"
+                    )
+                if failed_models:
+                    error_msg += (
+                        f"  Failed models: {[name for name, _ in failed_models]}\n"
+                    )
+                raise RuntimeError(error_msg + "No successful test results to report.")
+
+            if failed_datasets or failed_models:
+                self.logger.warning(
+                    f"\nSome tests failed (datasets: {len(failed_datasets)}, "
+                    f"models: {len(failed_models)}). Check logs for details."
+                )
+
+            self.results = all_results
+            self.logger.info(
+                f"\nTesting completed. Results saved to: {self.config.output_dir}"
+            )
+
+        finally:
+            self.cleanup_cached_embeddings()
+
+        return all_results

src/antibody_training_esm/cli/testing/visualization.py

@@ -0,0 +1,127 @@
+"""Plotting and result serialization utilities."""
+
+import logging
+import os
+from datetime import datetime
+from typing import Any
+
+import matplotlib.pyplot as plt
+import pandas as pd
+import seaborn as sns
+import yaml
+
+# Configure matplotlib
+plt.style.use("seaborn-v0_8" if "seaborn-v0_8" in plt.style.available else "default")
+sns.set_palette("husl")
+
+logger = logging.getLogger(__name__)
+
+
+def plot_confusion_matrix(
+    results: dict[str, dict[str, Any]],
+    dataset_name: str,
+    output_dir: str,
+) -> None:
+    """
+    Create confusion matrix visualization (individual files per model).
+
+    Args:
+        results: Dictionary mapping model names to result dictionaries.
+        dataset_name: Name of the dataset.
+        output_dir: Directory to save plots.
+    """
+    os.makedirs(output_dir, exist_ok=True)
+
+    logger.info(f"Creating confusion matrices for {dataset_name} in {output_dir}")
+
+    # Create individual confusion matrix for each model to prevent overrides
+    for model_name, model_results in results.items():
+        if "confusion_matrix" not in model_results:
+            logger.warning(f"No confusion matrix found for {model_name}, skipping plot")
+            continue
+
+        fig, ax = plt.subplots(1, 1, figsize=(8, 6))
+        cm = model_results["confusion_matrix"]
+        sns.heatmap(
+            cm,
+            annot=True,
+            fmt="d",
+            cmap="Blues",
+            xticklabels=["Negative", "Positive"],
+            yticklabels=["Negative", "Positive"],
+            ax=ax,
+        )
+        ax.set_title(f"Confusion Matrix - {model_name} on {dataset_name}")
+        ax.set_ylabel("True Label")
+        ax.set_xlabel("Predicted Label")
+
+        plt.tight_layout()
+
+        # Save plot with model name to prevent overrides when testing multiple backbones
+        plot_file = os.path.join(
+            output_dir,
+            f"confusion_matrix_{model_name}_{dataset_name}.png",
+        )
+        plt.savefig(plot_file, dpi=300, bbox_inches="tight")
+        plt.close()
+
+        logger.info(f"Confusion matrix saved to {plot_file}")
+
+
+def save_detailed_results(
+    results: dict[str, dict[str, Any]],
+    dataset_name: str,
+    config_dict: dict[str, Any],
+    output_dir: str,
+    save_predictions: bool = True,
+) -> None:
+    """
+    Save detailed results to files (individual files per model).
+
+    Args:
+        results: Dictionary mapping model names to result dictionaries.
+        dataset_name: Name of the dataset.
+        config_dict: Configuration dictionary to embed in YAML.
+        output_dir: Directory to save results.
+        save_predictions: Whether to save prediction CSVs.
+    """
+    os.makedirs(output_dir, exist_ok=True)
+
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+
+    # Save individual YAML for each model to prevent overrides
+    for model_name, model_results in results.items():
+        results_file = os.path.join(
+            output_dir,
+            f"detailed_results_{model_name}_{dataset_name}_{timestamp}.yaml",
+        )
+        with open(results_file, "w") as f:
+            yaml.dump(
+                {
+                    "dataset": dataset_name,
+                    "model": model_name,
+                    "config": config_dict,
+                    "results": model_results,
+                },
+                f,
+                default_flow_style=False,
+            )
+        logger.info(f"Detailed results saved to {results_file}")
+
+    # Save predictions if requested
+    if save_predictions:
+        for model_name, model_results in results.items():
+            if "predictions" in model_results:
+                pred_file = os.path.join(
+                    output_dir,
+                    f"predictions_{model_name}_{dataset_name}_{timestamp}.csv",
+                )
+                pred_df = pd.DataFrame(
+                    {
+                        "y_true": model_results["predictions"]["y_true"],
+                        "y_pred": model_results["predictions"]["y_pred"],
+                        "y_proba": model_results["predictions"]["y_proba"],
+                    }
+                )
+                pred_df.to_csv(pred_file, index=False)
+                logger.info(f"Predictions saved to {pred_file}")

src/antibody_training_esm/cli/train.py

@@ -0,0 +1,42 @@
+"""
+Training CLI - Hydra Entry Point
+
+Professional command-line interface for antibody model training.
+Uses Hydra for configuration management and supports dynamic overrides.
+
+Usage:
+    # Default config
+    antibody-train
+
+    # With overrides
+    antibody-train hardware.device=cuda training.batch_size=16
+
+    # Multi-run sweep
+    antibody-train --multirun classifier.C=0.1,1.0,10.0
+
+    # Help
+    antibody-train --help
+"""
+
+from antibody_training_esm.core.trainer import main as hydra_main
+
+
+def main() -> None:
+    """
+    Main entry point for training CLI
+
+    Delegates to Hydra-decorated main() in core.trainer.
+    This provides automatic config composition, override support,
+    and multi-run sweeps.
+
+    Note:
+        This function does not return an exit code (Hydra handles that).
+        Use try/except at a higher level if you need custom error handling.
+    """
+    # Delegate to Hydra entry point
+    # Hydra automatically parses sys.argv and handles all CLI logic
+    hydra_main()
+
+
+if __name__ == "__main__":
+    main()

src/antibody_training_esm/conf/__init__.py

@@ -0,0 +1,9 @@
+"""
+Hydra configuration package
+
+Contains YAML configs and structured config schemas.
+"""
+
+# Import config_schema to execute ConfigStore registrations
+# This MUST run at import time for structured configs to work
+from . import config_schema  # noqa: F401

src/antibody_training_esm/conf/classifier/logreg.yaml

@@ -0,0 +1,12 @@
+type: logistic_regression
+C: 1.0
+penalty: l2
+solver: lbfgs
+max_iter: 1000
+random_state: ${training.random_state}
+class_weight: null
+cv_folds: 10
+stratify: true
+path: null
+# Optional path to the JSON config file (for .npz models)
+config_path: null

src/antibody_training_esm/conf/classifier/xgboost.yaml

@@ -0,0 +1,14 @@
+type: xgboost
+n_estimators: 100
+max_depth: 6
+learning_rate: 0.3
+subsample: 1.0
+colsample_bytree: 1.0
+reg_alpha: 0.0
+reg_lambda: 1.0
+random_state: ${training.random_state}
+objective: binary:logistic
+cv_folds: 10
+stratify: true
+path: null
+config_path: null

src/antibody_training_esm/conf/config.yaml

@@ -0,0 +1,36 @@
+defaults:
+  - model: esm1v
+  - classifier: logreg
+  - data: boughter_jain
+  - hardware: default
+  - hydra: default
+  - _self_
+
+# Training settings (matches current trainer.py requirements)
+training:
+  # Cross-validation
+  n_splits: 10
+  random_state: 42
+  stratify: true
+
+  # Evaluation metrics (list of metrics to compute)
+  metrics: [accuracy, precision, recall, f1, roc_auc]
+
+  # Model saving
+  save_model: true
+  model_name: boughter_vh_esm1v_logreg
+  model_save_dir: ./experiments/checkpoints
+
+  # Logging (Hydra-aware: relative to Hydra output dir, or logs/ in legacy mode)
+  log_level: INFO
+  log_file: training.log
+
+  # Performance optimization
+  batch_size: 8
+  num_workers: 4
+
+# Experiment metadata (Hydra manages output dirs)
+experiment:
+  name: novo_replication
+  description: "Train ESM-1v VH-based LogisticReg on Boughter, test on Jain"
+  tags: [baseline, esm1v, logreg]

src/antibody_training_esm/conf/config_schema.py

@@ -0,0 +1,142 @@
+"""
+Structured configuration schemas for Hydra
+
+Type-safe configuration using dataclasses with full field coverage
+validated against current trainer.py requirements.
+"""
+
+from dataclasses import dataclass, field
+
+# ConfigStore import removed - no longer needed since registrations are commented out
+# from hydra.core.config_store import ConfigStore
+from omegaconf import MISSING
+
+
+@dataclass
+class ModelConfig:
+    """ESM model configuration (matches current model config structure)"""
+
+    name: str = "facebook/esm1v_t33_650M_UR90S_1"
+    revision: str = "main"
+    device: str = MISSING  # Provided by YAML interpolation ${hardware.device}
+
+
+@dataclass
+class ClassifierConfig:
+    """Classifier head configuration (matches current classifier config)"""
+
+    type: str = "logistic_regression"
+    C: float = 1.0
+    penalty: str = "l2"
+    solver: str = "lbfgs"
+    max_iter: int = 1000
+    random_state: int = (
+        MISSING  # Provided by YAML interpolation ${training.random_state}
+    )
+    class_weight: str | None = None
+    cv_folds: int = 10
+    stratify: bool = True
+
+
+@dataclass
+class DataConfig:
+    """Dataset configuration (ALL fields used by loaders.py + trainer.py)"""
+
+    # REQUIRED by loaders.py
+    source: str = "local"
+    train_file: str = MISSING  # Required
+    test_file: str = MISSING  # Required
+    sequence_column: str = "sequence"
+    label_column: str = "label"
+
+    # REQUIRED by trainer.py
+    embeddings_cache_dir: str = "./experiments/cache"
+
+    # Optional fields
+    dataset_name: str = "boughter_vh"
+    max_sequence_length: int = 1024
+    save_embeddings: bool = True
+
+    # Fragment metadata (testing only)
+    train_fragment: str = "VH"
+    test_fragment: str = "VH"
+    test_assay: str = "ELISA"
+    test_threshold: float = 0.5
+
+
+@dataclass
+class TrainingConfig:
+    """Training hyperparameters (ALL fields used by trainer.py)"""
+
+    # Cross-validation
+    n_splits: int = 10
+    random_state: int = 42
+    stratify: bool = True
+
+    # Evaluation metrics
+    metrics: list[str] = field(
+        default_factory=lambda: ["accuracy", "precision", "recall", "f1", "roc_auc"]
+    )
+
+    # Model saving
+    save_model: bool = True
+    model_name: str = "boughter_vh_esm1v_logreg"
+    model_save_dir: str = "./experiments/checkpoints"
+
+    # Logging (Hydra-aware: relative to Hydra output dir, or logs/ in legacy mode)
+    log_level: str = "INFO"
+    log_file: str = "training.log"  # Routes to logs/ dir in legacy mode, Hydra output dir in Hydra mode
+
+    # Performance optimization
+    batch_size: int = 8
+    num_workers: int = 4
+
+
+@dataclass
+class HardwareConfig:
+    """Hardware settings"""
+
+    device: str = "mps"
+    gpu_memory_fraction: float = 0.8
+    clear_cache_frequency: int = 100
+
+
+@dataclass
+class ExperimentConfig:
+    """Experiment metadata"""
+
+    name: str = "novo_replication"
+    description: str = "Train ESM-1v VH-based LogisticReg on Boughter, test on Jain"
+    tags: list[str] = field(default_factory=lambda: ["baseline", "esm1v", "logreg"])
+
+
+@dataclass
+class Config:
+    """Root configuration (complete schema matching current trainer.py)"""
+
+    model: ModelConfig = field(default_factory=ModelConfig)
+    classifier: ClassifierConfig = field(default_factory=ClassifierConfig)
+    data: DataConfig = field(default_factory=DataConfig)
+    training: TrainingConfig = field(default_factory=TrainingConfig)
+    hardware: HardwareConfig = field(default_factory=HardwareConfig)
+    experiment: ExperimentConfig = field(default_factory=ExperimentConfig)
+
+
+# ConfigStore registrations REMOVED to fix CLI override bug
+#
+# Root cause: Registering structured configs with the same names as YAML files
+# causes Hydra to prefer ConfigStore over YAML when using package-based config
+# loading (which the console script does). This breaks config group overrides.
+#
+# Known issue: Hydra structured configs strictly validate keys.
+# Overrides adding new keys require proper schema definition or +key syntax with strict mode disabled.# See: https://hydra.cc/docs/1.2/upgrades/1.0_to_1.1/automatic_schema_matching
+#
+# The dataclasses above are kept for type hints and validation in code, but are
+# no longer registered with ConfigStore. This allows YAML files to be the single
+# source of truth for configuration.
+#
+# cs = ConfigStore.instance()
+# cs.store(name="config", node=Config)
+# cs.store(group="model", name="esm1v", node=ModelConfig)
+# cs.store(group="classifier", name="logreg", node=ClassifierConfig)
+# cs.store(group="data", name="boughter_jain", node=DataConfig)

src/antibody_training_esm/conf/data/boughter_jain.yaml

@@ -0,0 +1,23 @@
+# Data source (matches current loaders.py requirements)
+source: local
+dataset_name: boughter_vh
+
+# File paths
+train_file: data/train/boughter/canonical/VH_only_boughter_training.csv
+test_file: data/test/jain/canonical/VH_only_jain_86_p5e_s2.csv
+
+# Data format options (required by loaders.py)
+# Jain canonical parity file uses 'vh_sequence'; align config to avoid column errors
+sequence_column: sequence
+label_column: label
+max_sequence_length: 1024
+
+# Embedding caching (required by trainer.py)
+save_embeddings: true
+embeddings_cache_dir: ./experiments/cache
+
+# Fragment metadata (for testing only)
+train_fragment: VH
+test_fragment: VH
+test_assay: ELISA
+test_threshold: 0.5

src/antibody_training_esm/conf/hardware/default.yaml

@@ -0,0 +1,5 @@
+# Hardware configuration
+# Default to MPS for macOS performance (training/testing); Gradio app handles stability fallback
+device: mps
+gpu_memory_fraction: 0.8
+clear_cache_frequency: 100

src/antibody_training_esm/conf/hydra/default.yaml

@@ -0,0 +1,10 @@
+# Hydra output directory management
+run:
+  dir: experiments/runs/${experiment.name}/${now:%Y-%m-%d_%H-%M-%S}
+
+sweep:
+  dir: experiments/runs/sweeps/${experiment.name}
+  subdir: ${hydra.job.num}
+
+job:
+  chdir: false  # Don't change working directory

src/antibody_training_esm/conf/model/esm1v.yaml

@@ -0,0 +1,4 @@
+name: facebook/esm1v_t33_650M_UR90S_1
+revision: main
+# Default to CPU for stability on macOS; override with hardware.device or CLI if desired
+device: ${hardware.device}

src/antibody_training_esm/conf/model/esm2_650m.yaml

@@ -0,0 +1,3 @@
+name: facebook/esm2_t33_650M_UR50D
+revision: main
+device: ${hardware.device}

src/antibody_training_esm/conf/predict.yaml

@@ -0,0 +1,26 @@
+# @package _global_
+
+defaults:
+  - /model: esm1v
+  - /classifier: logreg
+  - /hardware: default
+  - _self_
+
+input_file: null
+output_file: "predictions.csv"
+sequence_column: "sequence"
+assay_type: null  # Options: "PSR", "ELISA", or null
+threshold: 0.5    # Ignored if assay_type is set
+
+gradio:
+  server_name: "0.0.0.0"
+  server_port: 7860
+  share: false
+  queue:
+    concurrency_limit: 2  # Based on 8GB VRAM (3GB per ESM-1v inference)
+    max_size: 10          # Prevents unbounded queue growth
+  log_level: INFO
+
+hydra:
+  job:
+    chdir: False

src/antibody_training_esm/conf/testing/jain_p5e_s2.yaml

@@ -0,0 +1,7 @@
+model_paths: [experiments/checkpoints/esm1v/logreg/boughter_vh_esm1v_logreg.pkl]
+data_paths: [data/test/jain/canonical/VH_only_jain_86_p5e_s2.csv]
+sequence_column: vh_sequence
+label_column: label
+output_dir: experiments/benchmarks
+device: cpu
+batch_size: 8

src/antibody_training_esm/core/__init__.py

@@ -0,0 +1,19 @@
+"""
+Core ML Module
+
+Professional ML components for antibody classification:
+- ESM embedding extraction
+- Binary classification
+- Training pipelines
+- Model serialization (pickle + NPZ+JSON)
+"""
+
+from antibody_training_esm.core.classifier import BinaryClassifier
+from antibody_training_esm.core.embeddings import ESMEmbeddingExtractor
+from antibody_training_esm.core.trainer import load_model_from_npz
+
+__all__ = [
+    "BinaryClassifier",
+    "ESMEmbeddingExtractor",
+    "load_model_from_npz",
+]