code/scripts/prepare_finetune_data.py

#!/usr/bin/env python
"""
Prepare fine-tuning data for Spec-Agent from RAG dataset.

This script converts the RAG dataset into a format suitable for fine-tuning
Llama-3 on molecular structure prediction tasks.
"""
from __future__ import annotations

import argparse
import json
import sys
from pathlib import Path
from typing import List, Dict, Any

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

from spec_rag.io import load_embeddings, load_smiles
from spec_rag.faiss_index import load_index
from spec_rag.retrieval import search_index


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="Prepare fine-tuning data for Spec-Agent")
    parser.add_argument(
        "--train-jsonl",
        type=Path,
        required=True,
        help="Training JSONL file (from build_rag_dataset.py)",
    )
    parser.add_argument(
        "--spec-embeddings",
        type=Path,
        help="Path to spectrum embeddings .npy file (only needed if RAG context not in input_text)",
    )
    parser.add_argument(
        "--faiss-index",
        type=Path,
        help="Path to FAISS index directory (only needed if RAG context not in input_text)",
    )
    parser.add_argument(
        "--smiles-path",
        type=Path,
        help="Path to SMILES file used for indexing (only needed if RAG context not in input_text)",
    )
    parser.add_argument(
        "--mgf-path",
        type=Path,
        help="Path to MGF file for extracting peaks",
    )
    parser.add_argument(
        "--output-jsonl",
        type=Path,
        required=True,
        help="Output JSONL file for fine-tuning",
    )
    parser.add_argument(
        "--top-k",
        type=int,
        default=5,
        help="Number of RAG references to include (default: 5)",
    )
    parser.add_argument(
        "--max-examples",
        type=int,
        help="Maximum number of examples to process (for testing)",
    )
    return parser.parse_args()


def load_all_mgf_peaks(mgf_path: Path) -> Dict[int, List[tuple[float, float]]]:
    """Load all spectrum peaks from MGF file into memory (indexed by spectrum index)."""
    peaks_dict = {}
    
    print(f"Loading all peaks from MGF file: {mgf_path}")
    with open(mgf_path, "r") as f:
        spec_count = -1
        current_peaks = []
        in_spec = False
        
        for line in f:
            line_stripped = line.strip()
            if line_stripped.startswith("BEGIN IONS"):
                # Save previous spectrum if exists
                if in_spec and current_peaks:
                    peaks_dict[spec_count] = sorted(current_peaks, key=lambda x: x[1], reverse=True)
                spec_count += 1
                in_spec = True
                current_peaks = []
            elif in_spec:
                if line_stripped.startswith("END IONS"):
                    if current_peaks:
                        peaks_dict[spec_count] = sorted(current_peaks, key=lambda x: x[1], reverse=True)
                    in_spec = False
                    current_peaks = []
                elif line_stripped and not line_stripped.startswith(("PEPMASS", "CHARGE", "RTINSECONDS", "TITLE", "SCANS", "NAME", "SMILES", "INCHIKEY", "FORMULA", "PRECURSOR", "ADDUCT", "INSTRUMENT", "COLLISION", "FOLD", "SIMULATION")):
                    parts = line_stripped.split()
                    if len(parts) >= 2:
                        try:
                            mz = float(parts[0])
                            intensity = float(parts[1])
                            if intensity > 0:
                                current_peaks.append((mz, intensity))
                        except ValueError:
                            continue
        
        # Handle last spectrum if file doesn't end with END IONS
        if in_spec and current_peaks:
            peaks_dict[spec_count] = sorted(current_peaks, key=lambda x: x[1], reverse=True)
    
    print(f"Loaded {len(peaks_dict)} spectra from MGF file")
    return peaks_dict


def calculate_target_mass(smiles: str) -> float | None:
    """Calculate molecular mass from SMILES."""
    try:
        from rdkit import Chem
        from rdkit.Chem import Descriptors
        mol = Chem.MolFromSmiles(smiles)
        if mol:
            return Descriptors.ExactMolWt(mol)
    except:
        pass
    return None


def build_finetune_prompt(
    spectrum_peaks: List[tuple[float, float]] | None,
    rag_context: List[str],
    target_mass: float | None,
    target_smiles: str,
) -> Dict[str, Any]:
    """Build a fine-tuning prompt in chat format."""
    
    # Build system message
    system_content = """You are an expert mass spectrometrist and computational chemist specializing in de novo molecular structure elucidation from mass spectrometry data.

TASK: Predict the complete molecular structure (SMILES) from mass spectrum data.

CRITICAL REQUIREMENTS:
1. Generate COMPLEX molecules (30-100 atoms), NOT simple molecules
2. Use reference molecules as structural templates
3. Match target molecular mass within 10 Da
4. Output ONLY valid SMILES strings

WORKFLOW:
1. Analyze target mass to estimate atom count
2. Select best reference molecule as template
3. Modify template to match target mass
4. Validate structure"""
    
    # Build user message
    user_parts = []
    
    if target_mass:
        estimated_atoms = int(target_mass / 14)
        user_parts.append(f"Target molecular mass: {target_mass:.4f} Da (estimated {estimated_atoms} atoms)")
    
    if spectrum_peaks and len(spectrum_peaks) > 0:
        peaks_str = ', '.join(f'{mz:.2f} (intensity: {intensity:.3f})' for mz, intensity in spectrum_peaks[:20])
        user_parts.append(f"Major spectrum peaks (m/z with intensity): {peaks_str}")
    
    if rag_context:
        user_parts.append("\nReference molecules (structural templates):")
        for i, smiles in enumerate(rag_context[:5], 1):
            user_parts.append(f"  {i}. {smiles}")
        user_parts.append("\nPredict the molecular structure (SMILES) matching the target mass.")
    
    user_content = "\n".join(user_parts)
    
    # Assistant response
    assistant_content = target_smiles
    
    return {
        "messages": [
            {"role": "system", "content": system_content},
            {"role": "user", "content": user_content},
            {"role": "assistant", "content": assistant_content},
        ]
    }


def extract_rag_context_from_input(input_text: str) -> List[str]:
    """Extract RAG context SMILES from input_text field."""
    import re
    rag_smiles = []
    
    # Try to extract from "Context: Reference Molecules: [...]" format
    if "Context: Reference Molecules:" in input_text:
        context_part = input_text.split("Context: Reference Molecules:")[1]
        if "Target:" in context_part:
            context_part = context_part.split("Target:")[0]
        
        # Extract SMILES from [SMILES] format
        smiles_pattern = r'\[([^\]]+)\]'
        matches = re.findall(smiles_pattern, context_part)
        rag_smiles = [s.strip() for s in matches if s.strip()]
    
    return rag_smiles


def main() -> None:
    args = parse_args()
    
    # Load data
    print("Loading data...")
    train_data = []
    with open(args.train_jsonl, "r") as f:
        for line in f:
            if line.strip():
                train_data.append(json.loads(line))
    
    if args.max_examples:
        train_data = train_data[:args.max_examples]
    
    print(f"Loaded {len(train_data)} training examples")
    
    # Check if we need to retrieve RAG context or extract from input_text
    use_existing_context = False
    if train_data and "input_text" in train_data[0]:
        # Check if input_text contains RAG context
        sample_input = train_data[0].get("input_text", "")
        if "Context: Reference Molecules:" in sample_input:
            use_existing_context = True
            print("Found RAG context in input_text, will extract directly (no need to retrieve)")
        else:
            print("No RAG context in input_text, will retrieve from index")
    
    # Load index only if we need to retrieve
    index = None
    smiles_list = None
    spec_embeddings = None
    
    if not use_existing_context:
        print("Loading embeddings and index for retrieval...")
        spec_embeddings = load_embeddings(args.spec_embeddings)
        
        # Find FAISS index file
        index_path = Path(args.faiss_index)
        index_file = None
        if index_path.is_dir():
            # Try different possible file names
            for name in ["smiles.index", "index.faiss", "index", "faiss.index"]:
                candidate = index_path / name
                if candidate.exists():
                    index_file = candidate
                    break
            if index_file is None:
                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:
            index_file = index_path
        
        index = load_index(index_file)
        smiles_list = load_smiles(args.smiles_path)
        
        print(f"Index has {index.ntotal} vectors")
        print(f"SMILES list has {len(smiles_list)} molecules")
    
    # Pre-load all MGF peaks if MGF path is provided
    mgf_peaks_dict = {}
    if args.mgf_path:
        mgf_peaks_dict = load_all_mgf_peaks(args.mgf_path)
    
    # Process examples
    finetune_examples = []
    
    for i, example in enumerate(train_data):
        if i % 1000 == 0:
            print(f"Processing example {i}/{len(train_data)}... ({len(finetune_examples)} created so far)")
        
        spectrum_id = example.get("spectrum_id", str(i))
        target_smiles = example.get("target_text", "")
        input_text = example.get("input_text", "")
        
        if not target_smiles:
            continue
        
        # Calculate target mass
        target_mass = calculate_target_mass(target_smiles)
        if not target_mass:
            continue
        
        # Get RAG context
        rag_smiles = []
        if use_existing_context:
            # Extract from input_text
            rag_smiles = extract_rag_context_from_input(input_text)
            if not rag_smiles:
                continue
            # Limit to top_k
            rag_smiles = rag_smiles[:args.top_k]
        else:
            # Retrieve from index
            try:
                spec_idx = int(spectrum_id)
                if spec_idx >= len(spec_embeddings):
                    continue
                
                query_embedding = spec_embeddings[spec_idx:spec_idx+1]
                scores, indices = search_index(index, query_embedding, k=args.top_k)
                
                for idx_row in indices:
                    for idx in idx_row:
                        if 0 <= idx < len(smiles_list):
                            rag_smiles.append(smiles_list[idx])
                
                if not rag_smiles:
                    continue
            except (ValueError, IndexError):
                continue
        
        # Get spectrum peaks from pre-loaded dict
        spectrum_peaks = None
        if mgf_peaks_dict:
            try:
                spec_idx = int(spectrum_id)
                spectrum_peaks = mgf_peaks_dict.get(spec_idx)
            except (ValueError, IndexError):
                pass
        
        # Build fine-tuning example
        finetune_example = build_finetune_prompt(
            spectrum_peaks=spectrum_peaks,
            rag_context=rag_smiles,
            target_mass=target_mass,
            target_smiles=target_smiles,
        )
        
        finetune_examples.append(finetune_example)
    
    # Save fine-tuning data
    print(f"\nSaving {len(finetune_examples)} fine-tuning examples to {args.output_jsonl}...")
    with open(args.output_jsonl, "w") as f:
        for example in finetune_examples:
            f.write(json.dumps(example) + "\n")
    
    print(f"Done! Created {len(finetune_examples)} fine-tuning examples.")


if __name__ == "__main__":
    main()