""" Graph Neural Network models for Ruby code complexity prediction. This module contains PyTorch Geometric models for learning from Ruby AST structures with performance optimizations. """ import torch import torch.nn.functional as F from torch_geometric.nn import GCNConv, SAGEConv, GATConv, GINConv, GraphConv, global_mean_pool from torch_geometric.data import Data, Batch import torch_geometric from typing import Dict try: from sentence_transformers import SentenceTransformer SENTENCE_TRANSFORMERS_AVAILABLE = True except ImportError: SENTENCE_TRANSFORMERS_AVAILABLE = False # Performance optimization: Cache CUDA availability CUDA_AVAILABLE = torch.cuda.is_available() class RubyComplexityGNN(torch.nn.Module): """ Graph Neural Network for predicting Ruby method complexity. This model uses Graph Convolutional Networks (GCN) or GraphSAGE layers to learn from Abstract Syntax Tree representations of Ruby methods. """ def __init__(self, input_dim: int, hidden_dim: int = 64, num_layers: int = 3, conv_type: str = 'GCN', dropout: float = 0.1): """ Initialize the GNN model. Args: input_dim: Dimension of input node features hidden_dim: Hidden layer dimension num_layers: Number of convolutional layers conv_type: Type of convolution ('GCN', 'SAGE', 'GAT', 'GIN', 'GraphConv') dropout: Dropout probability for regularization """ super().__init__() supported = ['GCN', 'SAGE', 'GAT', 'GIN', 'GraphConv'] if conv_type not in supported: raise ValueError(f"conv_type must be one of {supported}") self.num_layers = num_layers self.conv_type = conv_type self.dropout = dropout self.convs = torch.nn.ModuleList() def _make_conv(in_dim, out_dim): if conv_type == 'GCN': return GCNConv(in_dim, out_dim) elif conv_type == 'SAGE': return SAGEConv(in_dim, out_dim) elif conv_type == 'GAT': return GATConv(in_dim, out_dim, heads=1) elif conv_type == 'GIN': mlp = torch.nn.Sequential( torch.nn.Linear(in_dim, out_dim), torch.nn.ReLU(), torch.nn.Linear(out_dim, out_dim), ) return GINConv(mlp) elif conv_type == 'GraphConv': return GraphConv(in_dim, out_dim) # First layer self.convs.append(_make_conv(input_dim, hidden_dim)) # Hidden layers for _ in range(num_layers - 2): self.convs.append(_make_conv(hidden_dim, hidden_dim)) # Last layer if num_layers > 1: self.convs.append(_make_conv(hidden_dim, hidden_dim)) # Output layer for complexity prediction self.predictor = torch.nn.Linear(hidden_dim, 1) def forward(self, data: Data, return_embedding: bool = False) -> torch.Tensor: """ Forward pass through the network. Args: data: PyTorch Geometric Data object containing graph return_embedding: If True, return graph embedding instead of prediction Returns: Complexity prediction tensor of shape (batch_size, 1) or Graph embedding tensor of shape (batch_size, hidden_dim) if return_embedding=True """ x, edge_index, batch = data.x, data.edge_index, data.batch # Apply convolution layers with ReLU activation and dropout for i, conv in enumerate(self.convs): x = conv(x, edge_index) if i < len(self.convs) - 1: # No activation after last layer x = F.relu(x) x = F.dropout(x, p=self.dropout, training=self.training) # Global pooling to get graph-level representation embedding = global_mean_pool(x, batch) if return_embedding: return embedding # Predict complexity return self.predictor(embedding) def get_model_info(self) -> str: """ Get information about the model configuration. Returns: String describing the model architecture """ return (f"RubyComplexityGNN({self.conv_type}, " f"layers={self.num_layers}, " f"dropout={self.dropout})") class ASTDecoder(torch.nn.Module): """ GNN-based decoder for reconstructing Abstract Syntax Trees from embeddings. This module takes a graph embedding and autoregressively generates node features and edge structure to reconstruct an AST. """ def __init__(self, embedding_dim: int, output_node_dim: int, hidden_dim: int = 256, num_layers: int = 5, max_nodes: int = 100, conv_type: str = 'GCN', gradient_checkpointing: bool = False): """ Initialize the AST decoder. Args: embedding_dim: Dimension of input graph embedding output_node_dim: Dimension of output node features hidden_dim: Hidden layer dimension for GNN layers. num_layers: Number of decoder GNN layers. max_nodes: Maximum number of nodes to generate. conv_type: The type of GNN layer to use ('GCN', 'SAGE', 'GAT', 'GIN', 'GraphConv'). gradient_checkpointing: Whether to use gradient checkpointing for memory efficiency. """ super().__init__() self.embedding_dim = embedding_dim self.output_node_dim = output_node_dim self.hidden_dim = hidden_dim self.num_layers = num_layers self.max_nodes = max_nodes self.gradient_checkpointing = gradient_checkpointing self.embedding_transform = torch.nn.Linear(embedding_dim, hidden_dim) self.convs = torch.nn.ModuleList() current_dim = hidden_dim for i in range(num_layers): if conv_type == 'GAT': heads = 4 conv = GATConv(current_dim, hidden_dim, heads=heads) current_dim = hidden_dim * heads elif conv_type == 'GIN': mlp = torch.nn.Sequential( torch.nn.Linear(current_dim, current_dim), torch.nn.ReLU(), torch.nn.Linear(current_dim, current_dim) ) conv = GINConv(mlp) elif conv_type == 'SAGE': conv = SAGEConv(current_dim, current_dim) elif conv_type == 'GCN': conv = GCNConv(current_dim, current_dim) elif conv_type == 'GraphConv': conv = GraphConv(current_dim, current_dim) else: raise ValueError(f"Unsupported conv_type: {conv_type}") self.convs.append(conv) self.node_output = torch.nn.Linear(current_dim, output_node_dim) self.parent_predictor = torch.nn.Linear(current_dim, max_nodes) def forward(self, embedding: torch.Tensor, num_nodes_per_graph: torch.Tensor) -> dict: """ Forward pass to decode a batch of embeddings into AST structures. Args: embedding: Graph embedding tensor of shape [batch_size, embedding_dim]. num_nodes_per_graph: Tensor of shape [batch_size] with the number of nodes for each graph. Returns: Dictionary containing batched node features and parent predictions. """ batch_size = embedding.size(0) device = embedding.device # Use torch.repeat_interleave to expand each graph's embedding # to match the number of nodes in that graph. # This is the core of the batch-aware processing. node_features = self.embedding_transform(embedding) node_features = node_features.repeat_interleave(num_nodes_per_graph, dim=0) # Vectorized edge construction for sequential edges within each graph. # This approach avoids loops over graphs in the batch, creating all edges # at once for efficiency. num_edges_per_graph = torch.clamp(num_nodes_per_graph - 1, min=0) total_edges = torch.sum(num_edges_per_graph).item() if total_edges == 0: edge_index = torch.empty((2, 0), dtype=torch.long, device=device) else: # Calculate node offsets for each graph node_offsets = torch.cat([torch.zeros(1, device=device, dtype=num_nodes_per_graph.dtype), torch.cumsum(num_nodes_per_graph[:-1], dim=0)]) # Efficient edge index computation for sequential nodes # Pre-allocate tensors to avoid repeated allocations total_edges = num_edges_per_graph.sum().item() # Determine which graph each edge belongs to graph_indices = torch.repeat_interleave(torch.arange(len(num_nodes_per_graph), device=device), num_edges_per_graph) # Calculate the starting edge index for each graph edge_offsets = torch.cat([torch.zeros(1, device=device, dtype=num_edges_per_graph.dtype), torch.cumsum(num_edges_per_graph[:-1], dim=0)]) # Compute local (within-graph) source indices more efficiently src_in_graph = torch.arange(total_edges, device=device) - edge_offsets[graph_indices] # Get the starting node index for each edge's graph edge_node_offsets = node_offsets[graph_indices] # Compute global source and destination indices src = edge_node_offsets + src_in_graph dst = src + 1 edge_index = torch.stack([src, dst], dim=0) # GNNs are typically undirected, so we add reverse edges. edge_index = torch_geometric.utils.to_undirected(edge_index) # Apply GNN layers with optional gradient checkpointing x = node_features if self.gradient_checkpointing and self.training: # Use gradient checkpointing for memory efficiency during training def create_custom_forward(module): def custom_forward(*inputs): return module(*inputs) return custom_forward for conv in self.convs: x = torch.utils.checkpoint.checkpoint( create_custom_forward(conv), x, edge_index, use_reentrant=False ) x = F.relu(x) else: # Standard forward pass for conv in self.convs: x = conv(x, edge_index) x = F.relu(x) # In-place for memory efficiency # Predict the final node features and parent logits for all nodes in the batch. output_node_features = self.node_output(x) parent_logits = self.parent_predictor(x) return { 'node_features': output_node_features, # Shape: [total_nodes, feature_dim] 'parent_logits': parent_logits # Shape: [total_nodes, max_nodes] } class TreeAwareASTDecoder(torch.nn.Module): """ Tree-topology-aware AST decoder. Unlike ASTDecoder which constructs sequential chain edges (0→1→2→…), this decoder uses the actual AST tree structure for GNN message passing. Three edge modes: - 'chain': Legacy sequential edges (same as ASTDecoder). - 'teacher_forced': Uses ground-truth AST edges during training. - 'iterative': Two-pass: chain edges → predict parents → rebuild tree edges → refine predictions. Fully feed-forward. """ def __init__(self, embedding_dim: int, output_node_dim: int, hidden_dim: int = 256, num_layers: int = 5, max_nodes: int = 100, conv_type: str = 'GCN', edge_mode: str = 'teacher_forced', gradient_checkpointing: bool = False): super().__init__() self.embedding_dim = embedding_dim self.output_node_dim = output_node_dim self.hidden_dim = hidden_dim self.num_layers = num_layers self.max_nodes = max_nodes self.edge_mode = edge_mode self.gradient_checkpointing = gradient_checkpointing self.embedding_transform = torch.nn.Linear(embedding_dim, hidden_dim) # Primary GNN stack self.convs = torch.nn.ModuleList() current_dim = hidden_dim for _ in range(num_layers): conv, current_dim = self._make_conv(conv_type, current_dim, hidden_dim) self.convs.append(conv) self.node_output = torch.nn.Linear(current_dim, output_node_dim) self.parent_predictor = torch.nn.Linear(current_dim, max_nodes) # Refinement GNN stack (only used in iterative mode) if edge_mode == 'iterative': self.refine_convs = torch.nn.ModuleList() ref_dim = current_dim for _ in range(max(num_layers // 2, 1)): conv, ref_dim = self._make_conv(conv_type, ref_dim, hidden_dim) self.refine_convs.append(conv) self.refine_node_output = torch.nn.Linear(ref_dim, output_node_dim) self.refine_parent_predictor = torch.nn.Linear(ref_dim, max_nodes) @staticmethod def _make_conv(conv_type: str, in_dim: int, hidden_dim: int): if conv_type == 'GAT': heads = 4 return GATConv(in_dim, hidden_dim, heads=heads), hidden_dim * heads elif conv_type == 'GIN': mlp = torch.nn.Sequential( torch.nn.Linear(in_dim, in_dim), torch.nn.ReLU(), torch.nn.Linear(in_dim, in_dim), ) return GINConv(mlp), in_dim elif conv_type == 'SAGE': return SAGEConv(in_dim, in_dim), in_dim elif conv_type == 'GCN': return GCNConv(in_dim, in_dim), in_dim elif conv_type == 'GraphConv': return GraphConv(in_dim, in_dim), in_dim else: raise ValueError(f"Unsupported conv_type: {conv_type}") # ------------------------------------------------------------------ # Edge construction helpers # ------------------------------------------------------------------ @staticmethod def _build_chain_edges(num_nodes_per_graph: torch.Tensor) -> torch.Tensor: """Build sequential chain edges (legacy behaviour).""" device = num_nodes_per_graph.device num_edges_per_graph = torch.clamp(num_nodes_per_graph - 1, min=0) total_edges = num_edges_per_graph.sum().item() if total_edges == 0: return torch.empty((2, 0), dtype=torch.long, device=device) node_offsets = torch.cat([ torch.zeros(1, device=device, dtype=num_nodes_per_graph.dtype), torch.cumsum(num_nodes_per_graph[:-1], dim=0), ]) graph_indices = torch.repeat_interleave( torch.arange(len(num_nodes_per_graph), device=device), num_edges_per_graph, ) edge_offsets = torch.cat([ torch.zeros(1, device=device, dtype=num_edges_per_graph.dtype), torch.cumsum(num_edges_per_graph[:-1], dim=0), ]) src_in_graph = torch.arange(total_edges, device=device) - edge_offsets[graph_indices] edge_node_offsets = node_offsets[graph_indices] src = edge_node_offsets + src_in_graph dst = src + 1 return torch.stack([src, dst], dim=0) @staticmethod def _parents_to_edges(parent_logits: torch.Tensor, num_nodes_per_graph: torch.Tensor) -> torch.Tensor: """Convert per-node parent logits to a hard edge_index (argmax).""" device = parent_logits.device total_nodes = parent_logits.size(0) max_nodes = parent_logits.size(1) # Compute graph membership and node offsets batch_vec = torch.repeat_interleave( torch.arange(len(num_nodes_per_graph), device=device), num_nodes_per_graph, ) node_offsets = torch.cat([ torch.zeros(1, device=device, dtype=num_nodes_per_graph.dtype), torch.cumsum(num_nodes_per_graph[:-1], dim=0), ]) # Mask out logits for positions beyond each graph's node count mask = torch.arange(max_nodes, device=device).unsqueeze(0).expand(total_nodes, -1) graph_sizes = num_nodes_per_graph[batch_vec].unsqueeze(1) parent_logits = parent_logits.clone() parent_logits[mask >= graph_sizes] = float('-inf') # Local parent index → global parent index local_parent = parent_logits.argmax(dim=1) # [total_nodes] global_parent = local_parent + node_offsets[batch_vec] # Node 0 of each graph (the root) has no parent — remove those edges local_idx = torch.arange(total_nodes, device=device) - node_offsets[batch_vec] is_root = local_idx == 0 src = global_parent[~is_root] dst = torch.arange(total_nodes, device=device)[~is_root] return torch.stack([src, dst], dim=0).long() # ------------------------------------------------------------------ # Forward # ------------------------------------------------------------------ def _apply_convs(self, x, edge_index, convs): edge_index = torch_geometric.utils.to_undirected(edge_index) if self.gradient_checkpointing and self.training: def _make_fn(module): def fn(*inputs): return module(*inputs) return fn for conv in convs: x = torch.utils.checkpoint.checkpoint( _make_fn(conv), x, edge_index, use_reentrant=False, ) x = F.relu(x) else: for conv in convs: x = conv(x, edge_index) x = F.relu(x) return x def forward(self, embedding: torch.Tensor, num_nodes_per_graph: torch.Tensor, gt_edge_index: torch.Tensor | None = None) -> dict: """ Args: embedding: [batch_size, embedding_dim] num_nodes_per_graph: [batch_size] gt_edge_index: [2, num_edges] ground-truth AST edges (optional). Required for teacher_forced mode during training. """ device = embedding.device node_features = self.embedding_transform(embedding) node_features = node_features.repeat_interleave(num_nodes_per_graph, dim=0) # ---- choose edges for the first GNN pass ---- if self.edge_mode == 'teacher_forced' and gt_edge_index is not None: first_pass_edges = gt_edge_index else: first_pass_edges = self._build_chain_edges(num_nodes_per_graph) x = self._apply_convs(node_features, first_pass_edges, self.convs) output_node_features = self.node_output(x) parent_logits = self.parent_predictor(x) # ---- optional second (refinement) pass ---- if self.edge_mode == 'iterative': predicted_edges = self._parents_to_edges(parent_logits, num_nodes_per_graph) if predicted_edges.size(1) > 0: x2 = self._apply_convs(x, predicted_edges, self.refine_convs) output_node_features = self.refine_node_output(x2) parent_logits = self.refine_parent_predictor(x2) return { 'node_features': output_node_features, 'parent_logits': parent_logits, } class AutoregressiveASTDecoder(torch.nn.Module): """ Autoregressive decoder for generating Abstract Syntax Trees sequentially. This decoder generates AST nodes one by one, maintaining state across generation steps and considering both text description and current partial graph context. """ def __init__(self, text_embedding_dim: int = 64, graph_hidden_dim: int = 64, state_hidden_dim: int = 128, node_types: int = 74, max_nodes: int = 100, sequence_model: str = 'GRU'): # Options: 'GRU', 'LSTM', 'Transformer' """ Initialize the AutoregressiveASTDecoder. Args: text_embedding_dim: Dimension of text embeddings (from alignment model) graph_hidden_dim: Hidden dimension for graph encoding state_hidden_dim: Hidden dimension for sequential state node_types: Number of possible node types (also node feature dimension) max_nodes: Maximum number of nodes for connection prediction sequence_model: Type of sequence model ('GRU', 'LSTM', 'Transformer') """ super().__init__() self.text_embedding_dim = text_embedding_dim self.graph_hidden_dim = graph_hidden_dim self.state_hidden_dim = state_hidden_dim self.node_types = node_types self.max_nodes = max_nodes self.sequence_model = sequence_model # Graph Context Encoder - GNN for processing partial graph structure # Note: Node features are node_types dimensional (one-hot encoded) self.graph_gnn_layers = torch.nn.ModuleList([ GCNConv(node_types, graph_hidden_dim), GCNConv(graph_hidden_dim, graph_hidden_dim) ]) self.graph_layer_norm = torch.nn.LayerNorm(graph_hidden_dim) self.graph_dropout = torch.nn.Dropout(0.1) # Sequential State Encoder - maintains state across generation steps input_size = text_embedding_dim + graph_hidden_dim if sequence_model == 'GRU': self.state_encoder = torch.nn.GRU( input_size=input_size, hidden_size=state_hidden_dim, num_layers=2, batch_first=True, dropout=0.1 ) elif sequence_model == 'LSTM': self.state_encoder = torch.nn.LSTM( input_size=input_size, hidden_size=state_hidden_dim, num_layers=2, batch_first=True, dropout=0.1 ) elif sequence_model == 'Transformer': # For transformer, we'll use a transformer encoder layer encoder_layer = torch.nn.TransformerEncoderLayer( d_model=state_hidden_dim, nhead=8, dim_feedforward=256, dropout=0.1, batch_first=True ) self.state_encoder = torch.nn.TransformerEncoder( encoder_layer=encoder_layer, num_layers=4 ) # For transformer, we need to project input to state_hidden_dim self.input_projection = torch.nn.Linear(input_size, state_hidden_dim) else: raise ValueError(f"Unknown sequence model: {sequence_model}. Choose from 'GRU', 'LSTM', 'Transformer'") # Dual Prediction Heads # Predict next node type self.node_type_predictor = torch.nn.Linear(state_hidden_dim, node_types) # Predict connection to existing nodes self.connection_predictor = torch.nn.Sequential( torch.nn.Linear(state_hidden_dim, max_nodes), torch.nn.Sigmoid() # Probability of connection to each existing node ) def forward(self, text_embedding, partial_graph=None, hidden_state=None): """ Forward pass for autoregressive AST generation. Args: text_embedding: (batch_size, text_embedding_dim) - Text description embedding partial_graph: Dict with keys 'x', 'edge_index', 'batch' - Current partial AST (optional) hidden_state: Previous hidden state for sequence model (optional) Returns: Dictionary containing: - node_type_logits: (batch_size, node_types) - Probabilities for next node type - connection_probs: (batch_size, max_nodes) - Connection probabilities - hidden_state: Updated hidden state """ batch_size = text_embedding.size(0) device = text_embedding.device # 1. Encode current graph state using GNN if partial_graph is not None and 'x' in partial_graph and len(partial_graph['x']) > 0: # We have a non-empty partial graph - process it with GNN # Convert partial graph to tensor if needed graph_features = partial_graph['x'] if isinstance(graph_features, list): # Convert list of features to tensor if graph_features and isinstance(graph_features[0], list): graph_features = torch.tensor(graph_features, dtype=torch.float32, device=device) else: # Empty or malformed graph graph_encoded = torch.zeros(batch_size, self.graph_hidden_dim, device=device) else: graph_features = graph_features.to(device) if len(graph_features.shape) == 2 and graph_features.size(0) > 0: # Get edge information for GNN processing edge_index = partial_graph.get('edge_index', None) if edge_index is None: # Create simple sequential edges if no edges provided num_nodes = graph_features.size(0) if num_nodes > 1: edge_list = [] for i in range(num_nodes - 1): edge_list.extend([[i, i + 1], [i + 1, i]]) # Bidirectional edges edge_index = torch.tensor(edge_list, dtype=torch.long, device=device).t() else: # Single node - no edges edge_index = torch.empty((2, 0), dtype=torch.long, device=device) else: if isinstance(edge_index, list): edge_index = torch.tensor(edge_index, dtype=torch.long, device=device) else: edge_index = edge_index.to(device) # Apply GNN layers for structural encoding x = graph_features for i, gnn_layer in enumerate(self.graph_gnn_layers): x = gnn_layer(x, edge_index) if i < len(self.graph_gnn_layers) - 1: # Apply activation for all but last layer x = F.relu(x) x = self.graph_dropout(x) # Apply layer normalization to final GNN output x = self.graph_layer_norm(x) # Global pooling to get graph-level representation per batch if 'batch' in partial_graph and partial_graph['batch'] is not None: # Use batch indices for proper pooling batch_indices = partial_graph['batch'] if isinstance(batch_indices, list): batch_indices = torch.tensor(batch_indices, dtype=torch.long, device=device) else: batch_indices = batch_indices.to(device) # Use global_mean_pool for proper batched pooling graph_encoded = global_mean_pool(x, batch_indices, size=batch_size) # Ensure we have the right batch size if graph_encoded.size(0) < batch_size: # Pad with zeros for missing batches padding = torch.zeros(batch_size - graph_encoded.size(0), self.graph_hidden_dim, device=device) graph_encoded = torch.cat([graph_encoded, padding], dim=0) elif graph_encoded.size(0) > batch_size: # Trim if too many graph_encoded = graph_encoded[:batch_size] else: # Single graph case - use mean pooling graph_encoded = x.mean(dim=0).unsqueeze(0).expand(batch_size, -1) else: # Unexpected shape or empty, use zeros graph_encoded = torch.zeros(batch_size, self.graph_hidden_dim, device=device) else: # Empty graph - start with zero representation graph_encoded = torch.zeros(batch_size, self.graph_hidden_dim, device=device) # 2. Combine text and graph context combined_input = torch.cat([text_embedding, graph_encoded], dim=-1) # 3. Update sequential state if self.sequence_model == 'Transformer': # For transformer, project input and treat as sequence sequence_input = self.input_projection(combined_input.unsqueeze(1)) # (batch_size, 1, state_hidden_dim) sequence_output = self.state_encoder(sequence_input) # (batch_size, 1, state_hidden_dim) sequence_output = sequence_output.squeeze(1) # (batch_size, state_hidden_dim) new_hidden_state = None # Transformers don't maintain hidden state in the same way else: # For RNN/GRU/LSTM sequence_input = combined_input.unsqueeze(1) # (batch_size, 1, input_size) sequence_output, new_hidden_state = self.state_encoder(sequence_input, hidden_state) sequence_output = sequence_output.squeeze(1) # (batch_size, state_hidden_dim) # 4. Predict next step node_type_logits = self.node_type_predictor(sequence_output) connection_probs = self.connection_predictor(sequence_output) return { 'node_type_logits': node_type_logits, 'connection_probs': connection_probs, 'hidden_state': new_hidden_state } def get_model_info(self) -> str: """ Get information about the autoregressive decoder configuration. Returns: String describing the model architecture """ return (f"AutoregressiveASTDecoder(\n" f" text_dim={self.text_embedding_dim}, " f" graph_dim={self.graph_hidden_dim}, " f" state_dim={self.state_hidden_dim}\n" f" node_types={self.node_types}, " f" sequence_model={self.sequence_model}\n" f")") class ASTAutoencoder(torch.nn.Module): """ Autoencoder for Abstract Syntax Trees using Graph Neural Networks. Combines the existing RubyComplexityGNN (as encoder) with the new ASTDecoder to create an autoencoder that can reconstruct ASTs from learned embeddings. """ def __init__(self, encoder_input_dim: int, node_output_dim: int, hidden_dim: int = 64, num_layers: int = 3, conv_type: str = 'GCN', dropout: float = 0.1, freeze_encoder: bool = False, encoder_weights_path: str = None, max_nodes: int = 100, decoder_conv_type: str = 'GCN', gradient_checkpointing: bool = False, decoder_edge_mode: str = 'chain'): """ Initialize the AST autoencoder. Args: encoder_input_dim: Input dimension for encoder (node feature dimension) node_output_dim: Output dimension for decoder node features hidden_dim: Hidden dimension for both encoder and decoder num_layers: Number of layers in both encoder and decoder conv_type: Type of convolution for encoder ('GCN' or 'SAGE') dropout: Dropout rate for encoder freeze_encoder: Whether to freeze encoder weights encoder_weights_path: Path to pre-trained encoder weights max_nodes: Maximum number of nodes for the decoder. decoder_conv_type: The GNN layer type for the decoder. gradient_checkpointing: Whether to enable gradient checkpointing for memory efficiency. decoder_edge_mode: Edge construction strategy for the decoder. 'chain' uses the original ASTDecoder with sequential edges. 'teacher_forced' or 'iterative' uses TreeAwareASTDecoder. """ super().__init__() self.decoder_edge_mode = decoder_edge_mode # Initialize encoder (RubyComplexityGNN without prediction head) self.encoder = RubyComplexityGNN( input_dim=encoder_input_dim, hidden_dim=hidden_dim, num_layers=num_layers, conv_type=conv_type, dropout=dropout ) # Load pre-trained weights if provided and adjust encoder config if needed self.encoder_weights_path = encoder_weights_path if encoder_weights_path is not None: try: checkpoint = torch.load(encoder_weights_path, map_location='cpu', weights_only=True) # Check if checkpoint contains model config and use it to create compatible encoder if 'model_config' in checkpoint: saved_config = checkpoint['model_config'] # Recreate encoder with saved configuration if it differs from current if (saved_config.get('conv_type', conv_type) != conv_type or saved_config.get('hidden_dim', hidden_dim) != hidden_dim or saved_config.get('num_layers', num_layers) != num_layers or saved_config.get('dropout', dropout) != dropout): print(f"Adjusting encoder config to match saved model: conv_type={saved_config.get('conv_type', conv_type)}") self.encoder = RubyComplexityGNN( input_dim=encoder_input_dim, hidden_dim=saved_config.get('hidden_dim', hidden_dim), num_layers=saved_config.get('num_layers', num_layers), conv_type=saved_config.get('conv_type', conv_type), dropout=saved_config.get('dropout', dropout) ) # Update hidden_dim for decoder compatibility hidden_dim = saved_config.get('hidden_dim', hidden_dim) self.encoder.load_state_dict(checkpoint['model_state_dict']) print(f"Loaded encoder weights from {encoder_weights_path}") except FileNotFoundError: print(f"Warning: Could not find encoder weights at {encoder_weights_path}") except Exception as e: print(f"Warning: Could not load encoder weights: {e}") # Freeze encoder if requested if freeze_encoder: for param in self.encoder.parameters(): param.requires_grad = False print("Encoder weights frozen") # Initialize decoder if decoder_edge_mode in ('teacher_forced', 'iterative'): self.decoder = TreeAwareASTDecoder( embedding_dim=hidden_dim, output_node_dim=node_output_dim, hidden_dim=hidden_dim, num_layers=num_layers, max_nodes=max_nodes, conv_type=decoder_conv_type, edge_mode=decoder_edge_mode, gradient_checkpointing=gradient_checkpointing, ) else: self.decoder = ASTDecoder( embedding_dim=hidden_dim, output_node_dim=node_output_dim, hidden_dim=hidden_dim, num_layers=num_layers, max_nodes=max_nodes, conv_type=decoder_conv_type, gradient_checkpointing=gradient_checkpointing, ) self.hidden_dim = hidden_dim self.freeze_encoder = freeze_encoder def forward(self, data: Data) -> dict: """ Forward pass through the autoencoder. Args: data: PyTorch Geometric Data object containing a batch of input ASTs. Returns: Dictionary containing reconstructed AST information for the batch. """ # Encode: Batch of ASTs -> Batch of embeddings embedding = self.encoder(data, return_embedding=True) # Get the number of nodes in each graph of the batch num_nodes_per_graph = torch.bincount(data.batch) # Decode: Batch of embeddings -> Batch of reconstructed ASTs # Pass ground-truth edges for tree-aware decoders if self.decoder_edge_mode != 'chain': reconstruction = self.decoder( embedding, num_nodes_per_graph, gt_edge_index=data.edge_index, ) else: reconstruction = self.decoder(embedding, num_nodes_per_graph) return { 'embedding': embedding, 'reconstruction': reconstruction } def get_model_info(self) -> str: """ Get information about the autoencoder configuration. Returns: String describing the model architecture """ encoder_info = self.encoder.get_model_info() decoder_info = f"ASTDecoder(embedding_dim={self.hidden_dim})" freeze_status = " [FROZEN]" if self.freeze_encoder else "" return (f"ASTAutoencoder(\n" f" encoder: {encoder_info}{freeze_status}\n" f" decoder: {decoder_info}\n" f")") class SimpleTextEncoder(torch.nn.Module): """ Simple text encoder as fallback when sentence-transformers is not available. This provides a basic text encoding mechanism using character-level features and a simple neural network. Used as fallback for testing when internet access is not available. """ def __init__(self, output_dim: int = 384, max_length: int = 100): """ Initialize the simple text encoder. Args: output_dim: Output embedding dimension max_length: Maximum text length to consider """ super().__init__() self.output_dim = output_dim self.max_length = max_length # Character embedding (256 ASCII characters) self.char_embedding = torch.nn.Embedding(256, 64) # Simple RNN for text processing self.rnn = torch.nn.LSTM(64, 128, batch_first=True, bidirectional=True) # Output projection self.output_proj = torch.nn.Linear(256, output_dim) def encode(self, texts: list, convert_to_tensor: bool = True) -> torch.Tensor: """ Encode texts to embeddings. Args: texts: List of text strings convert_to_tensor: Whether to return tensor (for compatibility) Returns: Text embeddings tensor """ batch_size = len(texts) # Convert texts to character indices char_sequences = [] for text in texts: # Convert to lowercase and get character codes chars = [min(ord(c), 255) for c in text.lower()[:self.max_length]] # Pad to max_length chars.extend([0] * (self.max_length - len(chars))) char_sequences.append(chars[:self.max_length]) # Convert to tensor and move to same device as model char_tensor = torch.tensor(char_sequences, dtype=torch.long) char_tensor = char_tensor.to(next(self.parameters()).device) # Embed characters embedded = self.char_embedding(char_tensor) # (batch, seq_len, embed_dim) # Process with RNN rnn_output, (hidden, _) = self.rnn(embedded) # Use last hidden state (concatenated forward and backward) final_hidden = torch.cat([hidden[0], hidden[1]], dim=1) # (batch, 256) # Project to output dimension embeddings = self.output_proj(final_hidden) return embeddings def get_sentence_embedding_dimension(self) -> int: """Get embedding dimension for compatibility.""" return self.output_dim class AlignmentModel(torch.nn.Module): """ Dual-encoder model for aligning text descriptions with code embeddings. This model combines a frozen RubyComplexityGNN (code encoder) with a sentence-transformers text encoder to create aligned embeddings in the same 64-dimensional space. """ def __init__(self, input_dim: int, hidden_dim: int = 64, num_layers: int = 3, conv_type: str = 'GCN', dropout: float = 0.1, text_model_name: str = 'all-MiniLM-L6-v2', code_encoder_weights_path: str = 'models/best_model.pt'): """ Initialize the alignment model. Args: input_dim: Input dimension for code encoder (node feature dimension) hidden_dim: Hidden dimension for both encoders (default: 64) num_layers: Number of layers in code encoder conv_type: Type of convolution for code encoder ('GCN' or 'SAGE') dropout: Dropout rate for code encoder text_model_name: Name of the sentence-transformers model to use code_encoder_weights_path: Path to pre-trained code encoder weights (default: 'models/best_encoder_model.pt') """ super().__init__() self.hidden_dim = hidden_dim # Initialize frozen code encoder (RubyComplexityGNN without prediction head) self.code_encoder = RubyComplexityGNN( input_dim=input_dim, hidden_dim=hidden_dim, num_layers=num_layers, conv_type=conv_type, dropout=dropout ) # Load pre-trained weights if provided if code_encoder_weights_path is not None: try: checkpoint = torch.load(code_encoder_weights_path, map_location='cpu', weights_only=True) # Handle both direct state dict and checkpoint format if 'model_state_dict' in checkpoint: state_dict = checkpoint['model_state_dict'] else: state_dict = checkpoint # Load state dict, ignoring predictor weights if present model_state = {} for key, value in state_dict.items(): if not key.startswith('predictor'): model_state[key] = value self.code_encoder.load_state_dict(model_state, strict=False) print(f"Loaded code encoder weights from {code_encoder_weights_path}") except FileNotFoundError: print(f"Warning: Could not find code encoder weights at {code_encoder_weights_path}") except Exception as e: print(f"Warning: Could not load code encoder weights: {e}") # Freeze code encoder parameters for param in self.code_encoder.parameters(): param.requires_grad = False print("Code encoder weights frozen") # Initialize text encoder if SENTENCE_TRANSFORMERS_AVAILABLE: try: self.text_encoder = SentenceTransformer(text_model_name) self.text_encoder_type = "sentence_transformers" print(f"Using SentenceTransformer: {text_model_name}") except Exception as e: print(f"Warning: Could not load SentenceTransformer ({e}), using fallback") self.text_encoder = SimpleTextEncoder(output_dim=384) self.text_encoder_type = "simple" else: print("SentenceTransformers not available, using simple text encoder") self.text_encoder = SimpleTextEncoder(output_dim=384) self.text_encoder_type = "simple" # Get text encoder output dimension text_dim = self.text_encoder.get_sentence_embedding_dimension() # Projection head to align text embeddings to code embedding space # Small MLP for better capacity: Linear(384 -> 256) -> ReLU() -> Linear(256 -> 64) self.text_projection = torch.nn.Sequential( torch.nn.Linear(text_dim, 256), torch.nn.ReLU(), torch.nn.Linear(256, hidden_dim) ) print(f"Text encoder output dim: {text_dim}, projecting to: {hidden_dim}") def encode_code(self, data: Data) -> torch.Tensor: """ Encode graph data to embeddings using the frozen code encoder. Args: data: PyTorch Geometric Data object containing graph Returns: Code embeddings tensor of shape (batch_size, hidden_dim) """ with torch.no_grad(): # Code encoder is frozen return self.code_encoder(data, return_embedding=True) def encode_text(self, texts: list) -> torch.Tensor: """ Encode text descriptions to embeddings using the text encoder. Args: texts: List of text descriptions Returns: Text embeddings tensor of shape (batch_size, hidden_dim) """ # Get text embeddings from sentence transformer text_embeddings = self.text_encoder.encode(texts, convert_to_tensor=True) # Clone tensor to create a normal tensor for autograd (SentenceTransformer creates inference tensors) text_embeddings = text_embeddings.clone() # Project to code embedding space projected_embeddings = self.text_projection(text_embeddings) return projected_embeddings def forward(self, data: Data, texts: list) -> dict: """ Forward pass through both encoders. Args: data: PyTorch Geometric Data object containing graphs texts: List of text descriptions (same length as batch size) Returns: Dictionary containing: - 'code_embeddings': Code embeddings (batch_size, hidden_dim) - 'text_embeddings': Text embeddings (batch_size, hidden_dim) """ # Encode code code_embeddings = self.encode_code(data) # Encode text text_embeddings = self.encode_text(texts) # Ensure embeddings are on the same device if code_embeddings.device != text_embeddings.device: text_embeddings = text_embeddings.to(code_embeddings.device) return { 'code_embeddings': code_embeddings, 'text_embeddings': text_embeddings } def get_model_info(self) -> str: """ Get information about the alignment model configuration. Returns: String describing the model architecture """ code_info = self.code_encoder.get_model_info() if self.text_encoder_type == "sentence_transformers": # Try to get model name from _model_config, fallback to transformer config, or use generic name model_name = self.text_encoder._model_config.get('_name_or_path') if model_name is None: # Try to get from transformer module config try: model_name = self.text_encoder[0].auto_model.config._name_or_path except (AttributeError, IndexError): model_name = "SentenceTransformer" text_info = f"SentenceTransformer({model_name})" else: text_info = f"SimpleTextEncoder(dim={self.text_encoder.output_dim})" # Handle Sequential projection (MLP) vs single Linear layer if isinstance(self.text_projection, torch.nn.Sequential): first_layer = self.text_projection[0] last_layer = self.text_projection[2] projection_info = f"MLP({first_layer.in_features} -> 256 -> {last_layer.out_features})" else: projection_info = f"Linear({self.text_projection.in_features} -> {self.text_projection.out_features})" return (f"AlignmentModel(\n" f" code_encoder: {code_info} [FROZEN]\n" f" text_encoder: {text_info}\n" f" projection: {projection_info}\n" f")") class HierarchicalASTDecoder(torch.nn.Module): """ Hierarchical, coarse-to-fine decoder for generating ASTs level by level. This model takes a text embedding and progressively generates an AST from the root down, with each stage adding one level of depth to the tree. Uses proper GNN layers to process graph structures at each level. """ def __init__(self, embedding_dim: int, hidden_dim: int, num_levels: int, node_feature_dim: int, conv_type: str = 'GCN'): """ Initialize the HierarchicalASTDecoder. Args: embedding_dim: Dimension of the input text embedding. hidden_dim: Hidden dimension for the GNN layers. num_levels: The maximum depth of the AST to generate (number of stages). node_feature_dim: The dimension of the node features to be predicted. conv_type: The type of GNN convolution to use ('GCN' or 'SAGE'). """ super().__init__() self.embedding_dim = embedding_dim self.hidden_dim = hidden_dim self.num_levels = num_levels self.node_feature_dim = node_feature_dim self.conv_type = conv_type self.register_buffer('device_indicator', torch.empty(0)) # Select GNN layer type if conv_type == 'GCN': ConvLayer = GCNConv elif conv_type == 'SAGE': ConvLayer = SAGEConv else: raise ValueError(f"Unsupported conv_type: {conv_type}. Use 'GCN' or 'SAGE'.") # A ModuleList to hold the generator for each level of the AST. self.level_generators = torch.nn.ModuleList() for i in range(num_levels): # Level 0 takes embedding as input, subsequent levels take hidden state # which has the same dimension as the output of the previous level's GNN if i == 0: input_dim = self.embedding_dim else: input_dim = self.hidden_dim # Each level generator uses proper GNN layers level_gnn = ConvLayer(input_dim, self.hidden_dim) node_predictor = torch.nn.Linear(self.hidden_dim, node_feature_dim) adjacency_predictor = torch.nn.Linear(self.hidden_dim, self.hidden_dim) self.level_generators.append(torch.nn.ModuleDict({ 'gnn': level_gnn, 'node_predictor': node_predictor, 'adjacency_predictor': adjacency_predictor, })) @property def device(self): """Returns the device the model is on.""" return self.device_indicator.device def forward(self, input_data: Data, target_level: int) -> Dict[str, torch.Tensor]: """ Performs a forward pass for a single level of generation. Args: input_data: PyG Data object with node features (x) and edge indices (edge_index). For level 0, x should be the text embedding repeated for initial node(s). target_level: The specific AST level to generate. Returns: Dictionary containing: - pred_features: Predicted node features for next level - pred_adjacency: Predicted adjacency matrix (only diagonal for memory efficiency) - hidden_state: Hidden representations for next level """ if target_level >= self.num_levels: raise ValueError(f"Target level {target_level} is out of bounds for {self.num_levels} levels.") generator = self.level_generators[target_level] # Process through GNN layer hidden_state = F.relu(generator['gnn'](input_data.x, input_data.edge_index)) # Predict node features pred_features = generator['node_predictor'](hidden_state) # Predict adjacency - use diagonal only for memory efficiency # Only compute self-connections (diagonal) to avoid huge matrix adjacency_repr = generator['adjacency_predictor'](hidden_state) # For diagonal: just take dot product with self pred_adjacency_diag = (adjacency_repr * adjacency_repr).sum(dim=1, keepdim=True) return { 'hidden_state': hidden_state, 'pred_features': pred_features, 'pred_adjacency_diag': pred_adjacency_diag # Changed: return only diagonal } def generate(self, embedding: torch.Tensor, max_levels: int = None, max_nodes_per_level: int = 10, max_total_nodes: int = 1000) -> list: """ Generate a complete AST from a text embedding using hierarchical generation. Args: embedding: Text embedding tensor of shape (1, embedding_dim) or (embedding_dim,) max_levels: Maximum depth of AST to generate (default: self.num_levels) max_nodes_per_level: Maximum children per parent node (default: 10) max_total_nodes: Maximum total nodes in AST to prevent runaway growth (default: 1000) Returns: List representing AST in JSON format with 'type' and 'children' fields """ if max_levels is None: max_levels = self.num_levels device = self.device if embedding.dim() == 1: embedding = embedding.unsqueeze(0) embedding = embedding.to(device) # Track all nodes with their metadata all_nodes = [] node_id_counter = 0 # Level 0: Generate root node root_data = Data( x=embedding, # Single node with embedding as features edge_index=torch.empty((2, 0), dtype=torch.long, device=device) ) with torch.no_grad(): root_output = self.forward(root_data, target_level=0) root_features = root_output['pred_features'] root_type_idx = root_features.argmax(dim=1)[0].item() root_node = { 'id': node_id_counter, 'type_idx': root_type_idx, 'features': root_features[0], 'hidden': root_output['hidden_state'][0], # Store hidden state for next level 'children': [], 'level': 0 } all_nodes.append(root_node) node_id_counter += 1 # Current level nodes that can spawn children current_level_nodes = [root_node] # Generate subsequent levels (optimized: batch all parents at each level) for level in range(1, max_levels): if len(current_level_nodes) == 0 or len(all_nodes) >= max_total_nodes: break next_level_nodes = [] # OPTIMIZATION: Batch all parent nodes together if len(current_level_nodes) > 0: # Stack all parent hidden states parent_hiddens = torch.stack([node['hidden'] for node in current_level_nodes]) # Create batched data (disconnected nodes, one per parent) batch_indices = torch.arange(len(current_level_nodes), device=device).repeat_interleave(1) batched_data = Data( x=parent_hiddens, edge_index=torch.empty((2, 0), dtype=torch.long, device=device), batch=batch_indices ) with torch.no_grad(): output = self.forward(batched_data, target_level=level) pred_features = output['pred_features'] # (num_parents, node_feature_dim) # Use diagonal adjacency values for spawn probability # Process each parent's output for parent_idx, parent_node in enumerate(current_level_nodes): # Use diagonal element as spawn probability for this parent spawn_prob = torch.sigmoid(output['pred_adjacency_diag'][parent_idx, 0]).item() num_children = min(int(spawn_prob * max_nodes_per_level), max_nodes_per_level) # Generate children nodes for this parent for child_idx in range(num_children): if len(all_nodes) >= max_total_nodes: break # Stop if we hit the node limit # Use the parent's predicted features/hidden state child_features = pred_features[parent_idx] child_hidden = output['hidden_state'][parent_idx] child_type_idx = child_features.argmax(dim=0).item() child_node = { 'id': node_id_counter, 'type_idx': child_type_idx, 'features': child_features, 'hidden': child_hidden, 'children': [], 'level': level, 'parent_id': parent_node['id'] } parent_node['children'].append(child_node) all_nodes.append(child_node) next_level_nodes.append(child_node) node_id_counter += 1 current_level_nodes = next_level_nodes # Convert to AST JSON format (recursive structure) def node_to_ast_json(node): ast_node = { 'type': f"type_{node['type_idx']}", # Will be mapped to actual types by caller 'children': [node_to_ast_json(child) for child in node['children']] } return ast_node if len(all_nodes) > 0: return [node_to_ast_json(all_nodes[0])] else: return []