src/train.py

#!/usr/bin/env python3
"""
Training script for Ruby complexity prediction using Graph Neural Networks.

This script implements the main training and validation loop for the GNN model
that predicts Ruby method complexity based on AST structure.
"""

import sys
import os
import time
import argparse
import torch
import torch.nn.functional as F
from torch_geometric.data import Data

# Add src directory to path
sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'src'))

from data_processing import create_data_loaders
from models import RubyComplexityGNN


def train_epoch(model, train_loader, optimizer, criterion, device):
    """
    Train the model for one epoch.
    
    Args:
        model: The GNN model
        train_loader: Training data loader
        optimizer: Optimizer instance
        criterion: Loss function
        device: Device to run on
        
    Returns:
        Average training loss for the epoch
    """
    model.train()
    total_loss = 0.0
    num_batches = 0
    
    for batch in train_loader:
        # Convert to PyTorch tensors and move to device
        x = torch.tensor(batch['x'], dtype=torch.float).to(device)
        edge_index = torch.tensor(batch['edge_index'], dtype=torch.long).to(device)
        y = torch.tensor(batch['y'], dtype=torch.float).to(device)
        batch_idx = torch.tensor(batch['batch'], dtype=torch.long).to(device)
        
        # Create PyTorch Geometric Data object
        data = Data(x=x, edge_index=edge_index, batch=batch_idx)
        
        # Forward pass
        optimizer.zero_grad()
        predictions = model(data)
        loss = criterion(predictions.squeeze(), y)
        
        # Backward pass
        loss.backward()
        optimizer.step()
        
        total_loss += loss.item()
        num_batches += 1
    
    return total_loss / num_batches if num_batches > 0 else 0.0


def validate_epoch(model, val_loader, criterion, device):
    """
    Validate the model for one epoch.
    
    Args:
        model: The GNN model
        val_loader: Validation data loader
        criterion: Loss function
        device: Device to run on
        
    Returns:
        Average validation loss for the epoch
    """
    model.eval()
    total_loss = 0.0
    num_batches = 0
    
    with torch.no_grad():
        for batch in val_loader:
            # Convert to PyTorch tensors and move to device
            x = torch.tensor(batch['x'], dtype=torch.float).to(device)
            edge_index = torch.tensor(batch['edge_index'], dtype=torch.long).to(device)
            y = torch.tensor(batch['y'], dtype=torch.float).to(device)
            batch_idx = torch.tensor(batch['batch'], dtype=torch.long).to(device)
            
            # Create PyTorch Geometric Data object
            data = Data(x=x, edge_index=edge_index, batch=batch_idx)
            
            # Forward pass
            predictions = model(data)
            loss = criterion(predictions.squeeze(), y)
            
            total_loss += loss.item()
            num_batches += 1
    
    return total_loss / num_batches if num_batches > 0 else 0.0


def save_model(model, filepath, epoch, train_loss, val_loss):
    """
    Save model weights and training metadata.
    
    Args:
        model: The model to save
        filepath: Path to save the model
        epoch: Current epoch number
        train_loss: Training loss
        val_loss: Validation loss
    """
    torch.save({
        'epoch': epoch,
        'model_state_dict': model.state_dict(),
        'train_loss': train_loss,
        'val_loss': val_loss,
        'model_config': {
            'input_dim': 74,
            'hidden_dim': model.convs[0].out_channels if hasattr(model.convs[0], 'out_channels') else 64,
            'num_layers': model.num_layers,
            'conv_type': model.conv_type,
            'dropout': model.dropout
        }
    }, filepath)


def parse_args():
    """Parse command line arguments."""
    parser = argparse.ArgumentParser(description='Train Ruby complexity prediction GNN model')
    parser.add_argument('--dataset_path', type=str, default='dataset/',
                        help='Path to dataset directory (default: dataset/)')
    parser.add_argument('--epochs', type=int, default=100,
                        help='Number of training epochs (default: 100)')
    parser.add_argument('--output_path', type=str, default='models/best_model.pt',
                        help='Path to save the best model (default: models/best_model.pt)')
    parser.add_argument('--batch_size', type=int, default=32,
                        help='Batch size for training (default: 32)')
    parser.add_argument('--learning_rate', type=float, default=0.001,
                        help='Learning rate (default: 0.001)')
    parser.add_argument('--hidden_dim', type=int, default=64,
                        help='Hidden dimension size (default: 64)')
    parser.add_argument('--num_layers', type=int, default=3,
                        help='Number of GNN layers (default: 3)')
    parser.add_argument('--conv_type', type=str, default='SAGE',
                        choices=['GCN', 'SAGE', 'GAT', 'GIN', 'GraphConv'],
                        help='GNN convolution type (default: SAGE)')
    parser.add_argument('--dropout', type=float, default=0.1,
                        help='Dropout rate (default: 0.1)')
    parser.add_argument('--num_workers', type=int, default=0,
                        help='DataLoader workers (default: 0 for Docker compat)')
    return parser.parse_args()


def main():
    """Main training function."""
    args = parse_args()
    
    print("🚀 Ruby Complexity GNN Training")
    print("=" * 50)
    
    # Training configuration from args
    config = {
        'epochs': args.epochs,
        'batch_size': args.batch_size,
        'learning_rate': args.learning_rate,
        'hidden_dim': args.hidden_dim,
        'num_layers': args.num_layers,
        'conv_type': args.conv_type,
        'dropout': args.dropout
    }
    
    print("📋 Training Configuration:")
    for key, value in config.items():
        print(f"   {key}: {value}")
    print(f"   dataset_path: {args.dataset_path}")
    print(f"   output_path: {args.output_path}")
    print()
    
    # Setup device
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    print(f"🖥️  Using device: {device}")
    
    # Create data loaders
    print("📂 Loading datasets...")
    
    # Handle sample dataset naming convention
    if args.dataset_path.rstrip('/').endswith('samples'):
        train_data_path = os.path.join(args.dataset_path, "train_sample.jsonl")
        val_data_path = os.path.join(args.dataset_path, "validation_sample.jsonl")
    else:
        train_data_path = os.path.join(args.dataset_path, "train.jsonl")
        val_data_path = os.path.join(args.dataset_path, "validation.jsonl")
    
    train_loader, val_loader = create_data_loaders(
        train_data_path,
        val_data_path,
        batch_size=config['batch_size'],
        shuffle=True,
        num_workers=args.num_workers
    )
    
    print(f"   Training batches: {len(train_loader)}")
    print(f"   Validation batches: {len(val_loader)}")
    print()
    
    # Initialize model
    print("🧠 Initializing model...")
    model = RubyComplexityGNN(
        input_dim=74,  # AST node feature dimension
        hidden_dim=config['hidden_dim'],
        num_layers=config['num_layers'],
        conv_type=config['conv_type'],
        dropout=config['dropout']
    ).to(device)
    
    param_count = sum(p.numel() for p in model.parameters())
    print(f"   Model: {model.get_model_info()}")
    print(f"   Parameters: {param_count:,}")
    print()
    
    # Setup optimizer and loss function
    optimizer = torch.optim.Adam(model.parameters(), lr=config['learning_rate'])
    criterion = torch.nn.MSELoss()
    
    print("⚙️  Training setup:")
    print(f"   Optimizer: Adam (lr={config['learning_rate']})")
    print(f"   Loss function: MSELoss")
    print()
    
    # Ensure output directory exists
    os.makedirs(os.path.dirname(args.output_path), exist_ok=True)
    
    # Training loop
    print("🏋️  Starting training...")
    print("=" * 50)
    
    best_val_loss = float('inf')
    start_time = time.time()
    
    for epoch in range(config['epochs']):
        epoch_start = time.time()
        
        # Train for one epoch
        train_loss = train_epoch(model, train_loader, optimizer, criterion, device)
        
        # Validate
        val_loss = validate_epoch(model, val_loader, criterion, device)
        
        epoch_time = time.time() - epoch_start
        
        # Print results for each epoch (required by Definition of Done)
        print(f"Epoch {epoch+1:2d}/{config['epochs']} | "
              f"Train Loss: {train_loss:.4f} | "
              f"Val Loss: {val_loss:.4f} | "
              f"Time: {epoch_time:.2f}s")
        
        # Save best model (required by Definition of Done)
        if val_loss < best_val_loss:
            best_val_loss = val_loss
            save_model(model, args.output_path, epoch, train_loss, val_loss)
            print(f"   💾 New best model saved (val_loss: {val_loss:.4f})")
    
    total_time = time.time() - start_time
    
    print("=" * 50)
    print("🎉 Training completed successfully!")
    print(f"   Total time: {total_time:.2f}s")
    print(f"   Best validation loss: {best_val_loss:.4f}")
    print(f"   Best model saved to: {args.output_path}")
    
    # Final model save (optional, keeping for compatibility)
    final_path = args.output_path.replace('.pt', '_final.pt')
    save_model(model, final_path, config['epochs']-1, train_loss, val_loss)
    print(f"   Final model saved to: {final_path}")


if __name__ == "__main__":
    main()