Datasets:

timlawrenz
/

gnn-ruby-code-study

	---
	language:
	- code
	license: mit
	task_categories:
	- graph-ml
	- text-classification
	tags:
	- code
	- ast
	- gnn
	- graph-neural-network
	- ruby
	- complexity-prediction
	- code-generation
	- negative-results
	size_categories:
	- 10K<n<100K
	---

	# GNN Ruby Code Study

	Systematic study of Graph Neural Network architectures for Ruby code complexity prediction and generation.

	Paper: [Graph Neural Networks for Ruby Code Complexity Prediction and Generation: A Systematic Architecture Study](paper.md)

	## Dataset

	22,452 Ruby methods parsed into AST graphs with 74-dimensional node features.

	\| Split \| Samples \| File \|
	\|-------\|---------\|------\|
	\| Train \| 19,084 \| `dataset/train.jsonl` \|
	\| Validation \| 3,368 \| `dataset/val.jsonl` \|

	Each JSONL record contains:
	- `repo_name`: Source repository
	- `file_path`: Original file path
	- `raw_source`: Raw Ruby source code
	- `complexity_score`: McCabe cyclomatic complexity
	- `ast_json`: Full AST as nested JSON (node types + literal values)
	- `id`: Unique identifier

	### Node Features (74D)
	- One-hot encoding of 73 AST node types (def, send, args, lvar, str, ...) + 1 unknown
	- Types cover Ruby AST nodes; literal values (identifiers, strings, numbers) map to unknown

	## Key Findings

	1. 5-layer GraphSAGE achieves MAE 4.018 (R² = 0.709) for complexity prediction — 16% better than 3-layer baseline (9.9σ significant)
	2. GNN autoencoders produce 0% valid Ruby across all 15+ tested configurations
	3. The literal value bottleneck: Teacher-forced GIN achieves 81% node type accuracy and 99.5% type diversity, but 0% syntax validity because 47% of AST elements are literals with no learnable representation
	4. Chain decoders collapse: 93% of predictions default to UNKNOWN without structural supervision
	5. Total cost: ~$4.32 across 51 GPU experiments on Vast.ai RTX 4090 + local RTX 2070 SUPER

	## Repository Structure

	```
	├── paper.md # Full research paper
	├── dataset/
	│ ├── train.jsonl # 19,084 Ruby methods (37 MB)
	│ └── val.jsonl # 3,368 Ruby methods (6.5 MB)
	├── models/
	│ ├── encoder_sage_5layer.pt # Pre-trained SAGE encoder
	│ └── decoders/ # Trained decoder checkpoints
	│ ├── tf-gin-256-deep.pt # Best: teacher-forced GIN, 5 layers
	│ ├── tf-gin-{128,256,512}.pt # Dimension ablation
	│ └── chain-gin-256.pt # Control (no structural supervision)
	├── results/
	│ ├── fleet_experiments.json # All Vast.ai experiment metrics
	│ ├── autonomous_research.json # 18 baseline variance replicates
	│ └── gin_deep_dive/ # Local deep-dive analysis
	│ ├── summary.json # Ablation summary table
	│ └── *_results.json # Per-config detailed results
	├── experiments/ # Ratiocinator fleet YAML specs
	├── specs/ # Ratiocinator research YAML specs
	├── src/ # Model source code
	│ ├── models.py # GNN architectures
	│ ├── data_processing.py # AST→graph pipeline
	│ ├── loss.py # Loss functions
	│ ├── train.py # Complexity prediction trainer
	│ └── train_autoencoder.py # Autoencoder trainer
	└── scripts/ # Runner and evaluation scripts
	```

	## Reproducing Results

	```bash
	# Clone the experiment branch
	git clone -b experiment/ratiocinator-gnn-study https://github.com/timlawrenz/jubilant-palm-tree
	cd jubilant-palm-tree

	# Install dependencies
	python -m venv .venv && source .venv/bin/activate
	pip install torch torchvision torch_geometric

	# Train complexity prediction (Track 1)
	python train.py --conv_type SAGE --num_layers 5 --epochs 50

	# Train autoencoder with teacher-forced GIN decoder (Track 4)
	python train_autoencoder.py --decoder_conv_type GIN --decoder_edge_mode teacher_forced --epochs 30

	# Run the full deep-dive ablation
	python scripts/gin_deep_dive.py
	```

	## Source Code

	- Model code: [jubilant-palm-tree](https://github.com/timlawrenz/jubilant-palm-tree) (branch: `experiment/ratiocinator-gnn-study`)
	- Orchestrator: [ratiocinator](https://github.com/timlawrenz/ratiocinator)

	## Citation

	If you use this dataset or findings, please cite:
	```
	@misc{lawrenz2025gnnruby,
	title={Graph Neural Networks for Ruby Code Complexity Prediction and Generation: A Systematic Architecture Study},
	author={Tim Lawrenz},
	year={2025},
	howpublished={\url{https://huggingface.co/datasets/timlawrenz/gnn-ruby-code-study}}
	}
	```