Upload src/train.py with huggingface_hub

src/train.py

@@ -0,0 +1,282 @@
+#!/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()