#!/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()