code/scripts/train_molt5_rag.py

#!/usr/bin/env python
from __future__ import annotations

import argparse
import inspect
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 datasets import load_dataset
import torch
from transformers import (
    AutoModelForSeq2SeqLM,
    AutoTokenizer,
    DataCollatorForSeq2Seq,
    Seq2SeqTrainer,
    Seq2SeqTrainingArguments,
)
import torch

from spec_rag.io import load_embeddings
from spec_rag.molt5_with_embeddings import MolT5WithEmbeddings


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="Fine-tune MolT5 on RAG dataset.")
    parser.add_argument("--model-name", default="laituan245/molt5-base")
    parser.add_argument("--train-jsonl", required=True)
    parser.add_argument("--eval-jsonl", default=None, help="Optional validation JSONL. If not provided, will split train data.")
    parser.add_argument("--output-dir", required=True)
    parser.add_argument("--spec-embeddings", default=None, help="Path to spectrum embeddings .npy file")
    parser.add_argument("--val-split", type=float, default=0.005, help="Validation split ratio (default: 0.005 = 0.5%%)")
    parser.add_argument("--seed", type=int, default=42, help="Random seed for reproducibility")
    parser.add_argument("--max-length", type=int, default=512)
    parser.add_argument("--batch-size", type=int, default=8)
    parser.add_argument("--epochs", type=int, default=3)
    parser.add_argument("--lr", type=float, default=2e-5)
    parser.add_argument("--eval-steps", type=int, default=500, help="Evaluate every N steps")
    parser.add_argument("--save-steps", type=int, default=500, help="Save checkpoint every N steps")
    parser.add_argument("--save-total-limit", type=int, default=3, help="Keep only N best checkpoints")
    parser.add_argument("--load-best-model", action="store_true", help="Load best model at end of training")
    parser.add_argument("--prompt-len", type=int, default=10, help="Number of soft prompt tokens for embeddings")
    parser.add_argument("--freeze-base", action="store_true", help="Freeze base model, only train projector")
    return parser.parse_args()


def make_compute_metrics(tokenizer):
    """Create a compute_metrics function that has access to tokenizer."""
    def compute_metrics(eval_pred):
        """
        Compute evaluation metrics for molecular generation:
        - Exact match (raw string)
        - Canonical exact match (after RDKit canonicalization)
        - SMILES validity rate
        - Tanimoto similarity (structural similarity)
        """
        predictions, labels = eval_pred
        if isinstance(predictions, tuple):
            predictions = predictions[0]
        
        # Decode predictions and labels
        decoded_preds = tokenizer.batch_decode(predictions, skip_special_tokens=True)
        # Replace -100 in labels (ignored tokens) with pad_token_id
        labels = np.where(labels != -100, labels, tokenizer.pad_token_id)
        decoded_labels = tokenizer.batch_decode(labels, skip_special_tokens=True)
        
        # Clean up predictions and labels
        decoded_preds = [p.strip() for p in decoded_preds]
        decoded_labels = [l.strip() for l in decoded_labels]
        
        # Exact match (raw string)
        exact_matches = sum(1 for p, l in zip(decoded_preds, decoded_labels) if p == l)
        exact_match_acc = exact_matches / len(decoded_preds) if decoded_preds else 0.0
        
        # Try to compute molecular metrics (RDKit required)
        canonical_exact = 0.0
        validity_rate = 0.0
        tanimoto_sim = 0.0
        valid_count = 0
        
        try:
            from rdkit import Chem
            from rdkit.Chem import AllChem, DataStructs
            from rdkit import rdBase
            rdBase.DisableLog("rdApp.*")  # Suppress RDKit warnings
            
            valid_preds = []
            valid_labels = []
            canonical_matches = 0
            
            for pred, label in zip(decoded_preds, decoded_labels):
                # Check validity
                try:
                    mol_pred = Chem.MolFromSmiles(pred)
                    mol_label = Chem.MolFromSmiles(label)
                    
                    if mol_pred is not None:
                        valid_count += 1
                        pred_canon = Chem.MolToSmiles(mol_pred, canonical=True)
                        valid_preds.append(mol_pred)
                    else:
                        pred_canon = None
                    
                    if mol_label is not None:
                        label_canon = Chem.MolToSmiles(mol_label, canonical=True)
                        valid_labels.append(mol_label)
                    else:
                        label_canon = None
                    
                    # Canonical exact match
                    if pred_canon and label_canon and pred_canon == label_canon:
                        canonical_matches += 1
                    
                    # Tanimoto similarity (only for valid molecules)
                    if mol_pred is not None and mol_label is not None:
                        fp_pred = AllChem.GetMorganFingerprintAsBitVect(mol_pred, radius=2, nBits=2048)
                        fp_label = AllChem.GetMorganFingerprintAsBitVect(mol_label, radius=2, nBits=2048)
                        tanimoto = DataStructs.TanimotoSimilarity(fp_pred, fp_label)
                        tanimoto_sim += tanimoto
                        
                except Exception:
                    # Invalid SMILES - skip
                    continue
            
            if len(decoded_preds) > 0:
                validity_rate = valid_count / len(decoded_preds)
                canonical_exact = canonical_matches / len(decoded_preds)
                if valid_count > 0:
                    tanimoto_sim = tanimoto_sim / valid_count
                    
        except ImportError:
            # RDKit not available - skip molecular metrics
            pass
        
        return {
            "exact_match": exact_match_acc,
            "canonical_exact_match": canonical_exact,
            "validity_rate": validity_rate,
            "tanimoto_similarity": tanimoto_sim,
        }
    return compute_metrics


def main() -> None:
    args = parse_args()
    out_dir = Path(args.output_dir)
    out_dir.mkdir(parents=True, exist_ok=True)
    
    # Set random seed for reproducibility
    np.random.seed(args.seed)
    import torch
    torch.manual_seed(args.seed)
    if torch.cuda.is_available():
        torch.cuda.manual_seed_all(args.seed)

    # Load spectrum embeddings if provided
    spec_embeddings = None
    if args.spec_embeddings:
        print(f"Loading spectrum embeddings from {args.spec_embeddings}")
        spec_embeddings = load_embeddings(args.spec_embeddings)
        print(f"Loaded {len(spec_embeddings)} spectrum embeddings (shape: {spec_embeddings.shape})")

    tokenizer = AutoTokenizer.from_pretrained(args.model_name)
    base_model = AutoModelForSeq2SeqLM.from_pretrained(args.model_name)
    
    # Wrap model with embedding injection if embeddings are provided
    if spec_embeddings is not None:
        embedding_dim = spec_embeddings.shape[1]
        print(f"Wrapping model with spectrum embedding injection (dim={embedding_dim}, prompt_len={args.prompt_len})")
        model = MolT5WithEmbeddings(
            base_model=base_model,
            embedding_dim=embedding_dim,
            prompt_len=args.prompt_len,
            freeze_base=args.freeze_base,
        )
    else:
        model = base_model
        print("Using base model without embedding injection")

    # Load dataset
    data_files = {"train": args.train_jsonl}
    if args.eval_jsonl:
        data_files["validation"] = args.eval_jsonl
        print(f"Using provided validation set: {args.eval_jsonl}")
    else:
        print(f"No validation set provided. Will split training data with {args.val_split*100:.2f}% validation.")
    
    dataset = load_dataset("json", data_files=data_files)
    
    # Split train/val if validation not provided
    if "validation" not in dataset:
        print(f"Splitting dataset: {len(dataset['train'])} examples")
        split = dataset["train"].train_test_split(
            test_size=args.val_split,
            seed=args.seed,
        )
        dataset["train"] = split["train"]
        dataset["validation"] = split["test"]
        print(f"Train: {len(dataset['train'])} examples, Validation: {len(dataset['validation'])} examples")

    def preprocess(batch):
        inputs = batch["input_text"]
        targets = batch["target_text"]
        
        # Remove data leakage: strip "Target: ..." from input_text if present
        # The input_text should only contain the prompt, not the ground truth
        cleaned_inputs = []
        for inp in inputs:
            # Remove "Target: ..." line if it exists (data leakage prevention)
            if "\nTarget:" in inp:
                inp = inp.split("\nTarget:")[0].rstrip()
            cleaned_inputs.append(inp)
        
        model_inputs = tokenizer(
            cleaned_inputs,
            max_length=args.max_length,
            truncation=True,
        )
        labels = tokenizer(
            targets,
            max_length=args.max_length,
            truncation=True,
        )
        model_inputs["labels"] = labels["input_ids"]
        
        # Add spectrum embeddings if available
        # Store as list of lists (one per example) so datasets can serialize properly
        if spec_embeddings is not None and "spectrum_id" in batch:
            spectrum_ids = batch["spectrum_id"]
            # Convert spectrum_id to int indices
            indices = [int(sid) if isinstance(sid, (int, str)) and str(sid).isdigit() else 0 
                      for sid in spectrum_ids]
            # Ensure indices are within bounds
            indices = [min(i, len(spec_embeddings) - 1) for i in indices]
            # Get embeddings - store as list of lists (one embedding vector per example)
            # This allows datasets to properly serialize and the collator to reconstruct tensors
            model_inputs["spectrum_embeddings"] = [spec_embeddings[i].tolist() for i in indices]
        
        return model_inputs

    # Determine which columns to remove
    # Note: remove_columns removes BEFORE preprocessing, so we need to keep
    # spectrum_id if we're using it to map to embeddings
    remove_cols = dataset["train"].column_names.copy()
    if spec_embeddings is not None and "spectrum_id" in remove_cols:
        # Keep spectrum_id during preprocessing (it won't be in model_inputs output)
        remove_cols.remove("spectrum_id")
    
    tokenized = dataset.map(preprocess, batched=True, remove_columns=remove_cols)
    
    # Custom data collator that handles spectrum embeddings
    class DataCollatorWithEmbeddings(DataCollatorForSeq2Seq):
        def __call__(self, features):
            # Extract spectrum embeddings if present
            spectrum_embeddings = None
            if "spectrum_embeddings" in features[0]:
                # Handle both tensor and list formats (datasets may serialize tensors as lists)
                emb_list = [f.pop("spectrum_embeddings") for f in features]
                # Convert to tensors if needed
                emb_tensors = []
                for emb in emb_list:
                    if isinstance(emb, torch.Tensor):
                        emb_tensors.append(emb)
                    elif isinstance(emb, (list, np.ndarray)):
                        emb_tensors.append(torch.tensor(emb, dtype=torch.float32))
                    else:
                        raise TypeError(f"Unexpected type for spectrum_embeddings: {type(emb)}")
                spectrum_embeddings = torch.stack(emb_tensors)
            
            # Use parent collator for standard fields
            batch = super().__call__(features)
            
            # Add spectrum embeddings back (keep on CPU, trainer will move to GPU)
            if spectrum_embeddings is not None:
                batch["spectrum_embeddings"] = spectrum_embeddings  # Keep on CPU for pin_memory
            
            return batch
    
    data_collator = DataCollatorWithEmbeddings(tokenizer, model=model)

    # Calculate total steps for evaluation scheduling
    total_train_steps = len(dataset["train"]) // args.batch_size * args.epochs
    eval_steps = min(args.eval_steps, total_train_steps // 10)  # At least 10 evaluations per epoch
    save_steps = min(args.save_steps, total_train_steps // 10)
    
    print(f"Training configuration:")
    print(f"  Total training steps: ~{total_train_steps}")
    print(f"  Evaluation every: {eval_steps} steps")
    print(f"  Save checkpoint every: {save_steps} steps")
    
    train_args_kwargs = {
        "output_dir": str(out_dir),
        "per_device_train_batch_size": args.batch_size,
        "per_device_eval_batch_size": args.batch_size,
        "learning_rate": args.lr,
        "num_train_epochs": args.epochs,
        "evaluation_strategy": "steps",
        "eval_steps": eval_steps,
        "save_strategy": "steps",
        "save_steps": save_steps,
        "save_total_limit": args.save_total_limit,
        "load_best_model_at_end": args.load_best_model,
        "metric_for_best_model": "tanimoto_similarity",  # Use Tanimoto similarity as primary metric
        "greater_is_better": True,
        "predict_with_generate": True,
        "logging_steps": 50,
        "report_to": [],  # Disable wandb/tensorboard by default
        "seed": args.seed,
        "data_seed": args.seed,
        "fp16": True,  # Enable mixed precision for faster training
    }
    sig = inspect.signature(Seq2SeqTrainingArguments.__init__)
    supported = set(sig.parameters.keys())
    train_args = Seq2SeqTrainingArguments(
        **{k: v for k, v in train_args_kwargs.items() if k in supported}
    )

    # Custom trainer that handles spectrum embeddings
    class TrainerWithEmbeddings(Seq2SeqTrainer):
        def compute_loss(self, model, inputs, return_outputs=False, **kwargs):
            """
            Compute loss with spectrum embeddings support.
            Accepts **kwargs to handle any additional arguments (e.g., num_items_in_batch).
            """
            # Extract spectrum embeddings if present and move to device
            spectrum_embeddings = inputs.pop("spectrum_embeddings", None)
            
            # Move embeddings to model device if present
            if spectrum_embeddings is not None:
                # Get device from model
                if hasattr(model, 'base_model'):
                    device = next(model.base_model.parameters()).device
                else:
                    device = next(model.parameters()).device
                spectrum_embeddings = spectrum_embeddings.to(device)
            
            # Call model with embeddings
            if spectrum_embeddings is not None:
                outputs = model(
                    **inputs,
                    spectrum_embeddings=spectrum_embeddings,
                )
            else:
                outputs = model(**inputs)
            
            loss = outputs.loss if hasattr(outputs, "loss") else outputs[0]
            return (loss, outputs) if return_outputs else loss
    
    trainer = TrainerWithEmbeddings(
        model=model,
        args=train_args,
        train_dataset=tokenized["train"],
        eval_dataset=tokenized.get("validation"),
        data_collator=data_collator,
        tokenizer=tokenizer,
        compute_metrics=make_compute_metrics(tokenizer),
    )
    
    print("\n" + "="*60)
    print("Starting training...")
    print("="*60 + "\n")
    
    train_result = trainer.train()
    
    print("\n" + "="*60)
    print("Training completed!")
    print("="*60)
    print(f"Train loss: {train_result.metrics.get('train_loss', 'N/A')}")
    print(f"Train runtime: {train_result.metrics.get('train_runtime', 'N/A'):.2f}s")
    
    # Final evaluation
    eval_result = None
    if "validation" in tokenized:
        print("\nRunning final evaluation...")
        eval_result = trainer.evaluate()
        print(f"\nValidation Metrics:")
        print(f"  Loss: {eval_result.get('eval_loss', 'N/A'):.4f}")
        print(f"  Exact Match: {eval_result.get('eval_exact_match', 'N/A'):.4f}")
        print(f"  Canonical Exact Match: {eval_result.get('eval_canonical_exact_match', 'N/A'):.4f}")
        print(f"  Validity Rate: {eval_result.get('eval_validity_rate', 'N/A'):.4f}")
        print(f"  Tanimoto Similarity: {eval_result.get('eval_tanimoto_similarity', 'N/A'):.4f}")
    
    # Save final model
    trainer.save_model(str(out_dir))
    print(f"\nModel saved to {out_dir}")
    
    # Save training arguments and config
    import json
    config_path = out_dir / "training_config.json"
    with open(config_path, "w") as f:
        json.dump({
            "model_name": args.model_name,
            "train_examples": len(dataset["train"]),
            "val_examples": len(dataset.get("validation", [])),
            "val_split": args.val_split if not args.eval_jsonl else None,
            "batch_size": args.batch_size,
            "epochs": args.epochs,
            "learning_rate": args.lr,
            "max_length": args.max_length,
            "seed": args.seed,
            "final_train_loss": train_result.metrics.get("train_loss"),
            "final_eval_metrics": eval_result,
        }, f, indent=2)
    print(f"Training config saved to {config_path}")


if __name__ == "__main__":
    main()