Upload src/models.py with huggingface_hub

src/models.py

@@ -0,0 +1,1351 @@
+"""
+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 []