code/scripts/run_spec_agent.py

#!/usr/bin/env python
"""
Run Spec-Agent inference on test data.

Usage:
    python scripts/run_spec_agent.py \
        --test-jsonl runs/rag_molt5_test.jsonl \
        --spec-embeddings runs/spec_embeddings_test.npy \
        --faiss-index runs/index \
        --output-json runs/spec_agent_predictions.jsonl \
        --model-name unsloth/Llama-3.1-8B-Instruct-bnb-4bit \
        --max-iterations 5
"""

from __future__ import annotations

import argparse
import json
import sys
from pathlib import Path

ROOT = Path(__file__).resolve().parents[1]
if str(ROOT) not in sys.path:
    sys.path.insert(0, str(ROOT))

import numpy as np
from tqdm import tqdm

from spec_rag.spec_agent import SpecAgent
from spec_rag.faiss_index import load_index
from spec_rag.io import load_jsonl


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="Run Spec-Agent inference")
    parser.add_argument("--test-jsonl", required=True, help="Test JSONL file")
    parser.add_argument("--spec-embeddings", required=True, help="Spectrum embeddings .npy file")
    parser.add_argument("--faiss-index", required=True, help="FAISS index directory")
    parser.add_argument("--output-json", required=True, help="Output predictions JSONL")
    parser.add_argument(
        "--model-name",
        default="meta-llama/Meta-Llama-3-8B-Instruct",
        help="HuggingFace model name. Examples:\n"
             "  - meta-llama/Meta-Llama-3-8B-Instruct (default)\n"
             "  - Qwen/Qwen2.5-7B-Instruct\n"
             "  - Qwen/Qwen2.5-14B-Instruct\n"
             "  - AI4Chem/ChemLLM-7B-Chat-1_5-DPO (latest chemistry model, recommended)\n"
             "  - AI4Chem/ChemLLM-7B-Chat (older chemistry model)\n"
             "  - microsoft/phi-3-medium-4k-instruct\n"
             "  - Any other HuggingFace chat model",
    )
    parser.add_argument(
        "--use-api",
        action="store_true",
        help="Use HuggingFace Inference API (no local model download needed)",
    )
    parser.add_argument(
        "--api-token",
        default=None,
        help="HuggingFace API token (or set HF_TOKEN env var)",
    )
    parser.add_argument(
        "--use-unsloth",
        action="store_true",
        help="Use Unsloth for fast inference (requires unsloth package, local only)",
    )
    parser.add_argument(
        "--load-in-4bit",
        action="store_true",
        default=True,
        help="Load model in 4-bit quantization (requires bitsandbytes, local only)",
    )
    parser.add_argument("--max-iterations", type=int, default=5, help="Max agent iterations")
    parser.add_argument("--top-k", type=int, default=5, help="Top-K RAG retrieval")
    parser.add_argument("--batch-size", type=int, default=1, help="Batch size (usually 1 for agent)")
    parser.add_argument("--device", default="cuda", help="Device (cuda/cpu)")
    parser.add_argument("--mass-tolerance-ppm", type=float, default=10.0, help="Mass tolerance in ppm")
    parser.add_argument("--use-selfies", action="store_true", default=True, help="Use SELFIES format (guarantees validity)")
    parser.add_argument("--no-selfies", dest="use_selfies", action="store_false", help="Disable SELFIES, use SMILES")
    parser.add_argument("--mgf-path", default=None, help="MGF file path to extract peaks (optional)")
    return parser.parse_args()


def load_mgf_peaks(mgf_path: Path, spectrum_id: str) -> list[tuple[float, float]]:
    """Load spectrum peaks from MGF file for a given spectrum_id.
    
    spectrum_id can be:
    - An integer index (0-based) into the MGF file
    - A string matching NAME= field in MGF
    - A string matching any part of TITLE= field
    """
    peaks = []
    
    # Try to parse as integer index first
    try:
        spec_idx = int(spectrum_id)
        # Load by index
        with open(mgf_path, "r") as f:
            lines = f.readlines()
            spec_count = -1
            peaks = []
            in_target_spec = False
            
            for i, line in enumerate(lines):
                line_stripped = line.strip()
                if line_stripped.startswith("BEGIN IONS"):
                    spec_count += 1
                    if spec_count == spec_idx:
                        in_target_spec = True
                        peaks = []
                elif in_target_spec:
                    if line_stripped.startswith("END IONS"):
                        if peaks:
                            # Sort by intensity (descending) and return (mz, intensity) tuples
                            peaks_sorted = sorted(peaks, key=lambda x: x[1], reverse=True)
                            return peaks_sorted
                        break
                    elif line_stripped and not line_stripped.startswith(("PEPMASS", "CHARGE", "RTINSECONDS", "TITLE", "SCANS", "NAME", "SMILES", "INCHIKEY", "FORMULA", "PRECURSOR", "ADDUCT", "INSTRUMENT", "COLLISION", "FOLD", "SIMULATION")):
                        # Parse peak line: "mz intensity" or "mz\tintensity"
                        parts = line_stripped.split()
                        if len(parts) >= 2:
                            try:
                                mz = float(parts[0])
                                intensity = float(parts[1])
                                if intensity > 0:  # Only non-zero peaks
                                    peaks.append((mz, intensity))
                            except ValueError:
                                continue
        return []
    except (ValueError, IndexError):
        pass
    
    # Try to match by NAME= or TITLE= field
    with open(mgf_path, "r") as f:
        in_spec = False
        current_name = None
        current_title = None
        peaks = []
        
        for line in f:
            line_stripped = line.strip()
            if line_stripped.startswith("BEGIN IONS"):
                in_spec = True
                current_name = None
                current_title = None
                peaks = []
            elif in_spec:
                if line_stripped.startswith("NAME="):
                    current_name = line_stripped.split("=", 1)[1].strip() if "=" in line_stripped else ""
                elif line_stripped.startswith("TITLE="):
                    current_title = line_stripped.split("=", 1)[1].strip() if "=" in line_stripped else ""
                elif line_stripped.startswith("END IONS"):
                    # Check if this is the spectrum we want
                    if (current_name and spectrum_id in current_name) or \
                       (current_title and spectrum_id in current_title) or \
                       (str(spectrum_id) in (current_name or "")) or \
                       (str(spectrum_id) in (current_title or "")):
                        if peaks:
                            # Sort by intensity (descending) and return (mz, intensity) tuples
                            peaks_sorted = sorted(peaks, key=lambda x: x[1], reverse=True)
                            return peaks_sorted
                    in_spec = False
                    current_name = None
                    current_title = None
                    peaks = []
                elif line_stripped and not line_stripped.startswith(("PEPMASS", "CHARGE", "RTINSECONDS", "SCANS", "SMILES", "INCHIKEY", "FORMULA", "PRECURSOR", "ADDUCT", "INSTRUMENT", "COLLISION", "FOLD", "SIMULATION")):
                    # Parse peak line: "mz intensity"
                    parts = line_stripped.split()
                    if len(parts) >= 2:
                        try:
                            mz = float(parts[0])
                            intensity = float(parts[1])
                            if intensity > 0:  # Only non-zero peaks
                                peaks.append((mz, intensity))
                        except ValueError:
                            continue
    
    return []


def main() -> None:
    args = parse_args()
    
    # Load test data
    print(f"Loading test data from {args.test_jsonl}")
    test_data = load_jsonl(Path(args.test_jsonl))
    print(f"Loaded {len(test_data)} examples")
    
    # Load spectrum embeddings
    print(f"Loading spectrum embeddings from {args.spec_embeddings}")
    spec_embeddings = np.load(args.spec_embeddings)
    print(f"Loaded embeddings shape: {spec_embeddings.shape}")
    
    # Load FAISS index
    print(f"Loading FAISS index from {args.faiss_index}")
    index_path = Path(args.faiss_index)
    
    # Try different possible file names
    index_file = None
    for name in ["smiles.index", "index.faiss", "index", "faiss.index"]:
        candidate = index_path / name if index_path.is_dir() else index_path
        if candidate.exists():
            index_file = candidate
            break
    
    if index_file is None:
        # List available files for debugging
        if index_path.is_dir():
            available = list(index_path.glob("*"))
            raise FileNotFoundError(
                f"Could not find FAISS index in {index_path}. "
                f"Available files: {[f.name for f in available]}"
            )
        else:
            raise FileNotFoundError(f"Could not find FAISS index at {index_path}")
    
    index = load_index(index_file)
    
    # Load ID to SMILES mapping (if exists)
    id_to_smiles = {}
    mapping_file = index_path / "id_to_smiles.pkl" if index_path.is_dir() else index_path.parent / "id_to_smiles.pkl"
    if mapping_file.exists():
        import pickle
        with open(mapping_file, "rb") as f:
            id_to_smiles = pickle.load(f)
        print(f"Loaded {len(id_to_smiles)} SMILES mappings")
    else:
        # Fallback: load from original SMILES file if available
        smiles_file = index_path / "smiles.txt" if index_path.is_dir() else index_path.parent / "pubchem_1k.smi"
        if smiles_file.exists():
            from spec_rag.io import load_smiles
            smiles_list = load_smiles(smiles_file)
            id_to_smiles = {i: smi for i, smi in enumerate(smiles_list)}
            print(f"Loaded {len(id_to_smiles)} SMILES from {smiles_file}")
    
    print(f"Index loaded with {index.ntotal} vectors")
    
    # Initialize agent
    print(f"Initializing Spec-Agent with model: {args.model_name}")
    if args.use_api:
        print("Using HuggingFace Inference API (no local model download)")
    else:
        print("Using local model loading")
    
    agent = SpecAgent(
        model_name=args.model_name,
        use_api=args.use_api,
        api_token=args.api_token,
        use_unsloth=args.use_unsloth,
        max_iterations=args.max_iterations,
        mass_tolerance_ppm=args.mass_tolerance_ppm,
        device=args.device,
        load_in_4bit=args.load_in_4bit,
        use_selfies=args.use_selfies,
    )
    print("✓ Agent initialized")
    
    # Run inference
    predictions = []
    
    for i, example in enumerate(tqdm(test_data[:100], desc="Running Spec-Agent")):
        spectrum_id = example.get("spectrum_id", str(i))
        
        # Get spectrum embedding
        spec_idx = int(spectrum_id) if str(spectrum_id).isdigit() else i
        if spec_idx >= len(spec_embeddings):
            spec_idx = i % len(spec_embeddings)
        
        spec_emb = spec_embeddings[spec_idx]
        
        # Retrieve similar molecules via RAG
        from spec_rag.faiss_index import index_search
        distances, indices = index_search(index, spec_emb.reshape(1, -1), args.top_k)
        rag_smiles = [id_to_smiles.get(int(idx), "") for idx in indices[0] if int(idx) in id_to_smiles]
        rag_smiles = [smi for smi in rag_smiles if smi]  # Remove empty strings
        
        # Extract target mass if available
        target_mass = example.get("precursor_mz")
        if target_mass is None:
            # Try to extract from input_text or other fields
            input_text = example.get("input_text", "")
            # Look for mass patterns
            import re
            mass_match = re.search(r'(\d+\.\d+)\s*(?:Da|m/z|M\+)', input_text)
            if mass_match:
                target_mass = float(mass_match.group(1))
        
        # Extract spectrum peaks if available
        spectrum_peaks = None
        
        # Method 1: Check if peaks are directly in the example
        if "peaks" in example:
            peaks_data = example["peaks"]
            # Handle different formats: list of floats, list of [mz, intensity] pairs, etc.
            if isinstance(peaks_data, list) and len(peaks_data) > 0:
                if isinstance(peaks_data[0], (list, tuple)) and len(peaks_data[0]) >= 2:
                    # Format: [[mz1, int1], [mz2, int2], ...] - keep both m/z and intensity
                    spectrum_peaks = [(float(p[0]), float(p[1])) for p in peaks_data if len(p) >= 2]
                elif isinstance(peaks_data[0], (int, float)):
                    # Format: [mz1, mz2, ...] - only m/z, no intensity
                    spectrum_peaks = [float(p) for p in peaks_data]
        elif "spectrum_peaks" in example:
            peaks_data = example["spectrum_peaks"]
            if isinstance(peaks_data, list):
                # Check if it's tuples or just floats
                if peaks_data and isinstance(peaks_data[0], (list, tuple)) and len(peaks_data[0]) >= 2:
                    spectrum_peaks = [(float(p[0]), float(p[1])) for p in peaks_data if len(p) >= 2]
                else:
                    spectrum_peaks = [float(p) for p in peaks_data if isinstance(p, (int, float))]
        
        # Method 2: Load from MGF file if provided
        if (spectrum_peaks is None or len(spectrum_peaks) == 0) and args.mgf_path:
            mgf_path = Path(args.mgf_path)
            if mgf_path.exists():
                spectrum_peaks = load_mgf_peaks(mgf_path, spectrum_id)
                if spectrum_peaks:
                    if i < 3:  # Debug for first few
                        print(f"  ✓ Loaded {len(spectrum_peaks)} peaks from MGF for spectrum {spectrum_id}")
        
        # Method 3: Extract from input_text (look for m/z patterns)
        if spectrum_peaks is None or len(spectrum_peaks) == 0:
            input_text = example.get("input_text", "")
            import re
            # Look for patterns like "m/z: 123.45" or "123.45 m/z" or just numbers in reasonable range
            # Try multiple patterns
            peak_matches = []
            
            # Pattern 1: "m/z: 123.45" or "123.45 m/z"
            peak_matches.extend(re.findall(r'(?:m/z|mz|Da)[:\s]+(\d+\.?\d*)', input_text, re.IGNORECASE))
            peak_matches.extend(re.findall(r'(\d+\.?\d*)\s*(?:m/z|mz|Da)', input_text, re.IGNORECASE))
            
            # Pattern 2: Numbers in reasonable m/z range (50-2000) that look like peaks
            all_numbers = re.findall(r'\b(\d{2,4}\.?\d*)\b', input_text)
            peak_matches.extend([n for n in all_numbers if 50 <= float(n) <= 2000])
            
            if peak_matches:
                # Remove duplicates and sort (no intensity available from text extraction)
                spectrum_peaks = sorted(set(float(p) for p in peak_matches), reverse=True)
                if spectrum_peaks and i < 3:  # Debug for first few
                    print(f"  ✓ Extracted {len(spectrum_peaks)} peaks from input_text for spectrum {spectrum_id} (no intensity)")
        
        # Debug: Print if no peaks found (only for first few examples)
        if (spectrum_peaks is None or len(spectrum_peaks) == 0) and i < 3:
            print(f"  ⚠ No peaks found for spectrum {spectrum_id} (mgf_path={args.mgf_path})")
        
        # Run agent prediction
        result = agent.predict(
            spectrum_peaks=spectrum_peaks,
            rag_context=rag_smiles,
            target_mass=target_mass,
        )
        
        # Save prediction
        pred_entry = {
            "spectrum_id": spectrum_id,
            "predicted_smiles": result["smiles"],
            "status": result["status"],
            "iterations": result["iterations"],
            "ground_truth": example.get("target_text", ""),
            "rag_context": rag_smiles,
        }
        
        predictions.append(pred_entry)
    
    # Save predictions
    output_path = Path(args.output_json)
    output_path.parent.mkdir(parents=True, exist_ok=True)
    
    with open(output_path, "w") as f:
        for pred in predictions:
            f.write(json.dumps(pred) + "\n")
    
    print(f"\n✓ Saved {len(predictions)} predictions to {output_path}")
    
    # Print summary
    success_count = sum(1 for p in predictions if p["status"] == "success")
    print(f"\nSummary:")
    print(f"  Total: {len(predictions)}")
    print(f"  Success: {success_count} ({100*success_count/len(predictions):.1f}%)")
    print(f"  Failed/Max iterations: {len(predictions) - success_count}")


if __name__ == "__main__":
    main()