neurocode-ai 0.1.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- neurocode_ai-0.1.0.dist-info/METADATA +193 -0
- neurocode_ai-0.1.0.dist-info/RECORD +30 -0
- neurocode_ai-0.1.0.dist-info/WHEEL +5 -0
- neurocode_ai-0.1.0.dist-info/entry_points.txt +4 -0
- neurocode_ai-0.1.0.dist-info/licenses/LICENSE +21 -0
- neurocode_ai-0.1.0.dist-info/top_level.txt +1 -0
- src/__init__.py +0 -0
- src/agent/llm_interface.py +62 -0
- src/agent/patcher.py +124 -0
- src/benchmark/create_thumbnail.py +64 -0
- src/benchmark/end_to_end_benchmark.py +638 -0
- src/benchmark/evaluator.py +124 -0
- src/benchmark/generate_4x3_figures.py +259 -0
- src/benchmark/mlsys_microbenchmarks.py +351 -0
- src/benchmark/plot_ablation.py +96 -0
- src/benchmark/plot_architecture.py +79 -0
- src/benchmark/plot_empirical_fig1.py +97 -0
- src/benchmark/run_ablation_study.py +205 -0
- src/benchmark/run_code_benchmarks.py +181 -0
- src/benchmark/run_comprehensive_10_tests.py +424 -0
- src/benchmark/run_dense_vector_rag_benchmark.py +271 -0
- src/benchmark/run_ephemeral_swebench.py +474 -0
- src/benchmark/run_hardware_cliff_test.py +341 -0
- src/benchmark/swebench_evaluator.py +147 -0
- src/cli.py +298 -0
- src/graph/__init__.py +0 -0
- src/graph/builder.py +124 -0
- src/graph/parser.py +175 -0
- src/graph/slicer.py +202 -0
- src/mcp_server.py +370 -0
|
@@ -0,0 +1,124 @@
|
|
|
1
|
+
"""
|
|
2
|
+
Evaluation harness comparing:
|
|
3
|
+
1. Raw Context Dump (Naive Baseline)
|
|
4
|
+
2. BM25 Text Retrieval (Agentless Baseline)
|
|
5
|
+
3. NeuroCode Host-CPU Graph Slicer (Our Proposed Method)
|
|
6
|
+
"""
|
|
7
|
+
|
|
8
|
+
import time
|
|
9
|
+
import math
|
|
10
|
+
from dataclasses import dataclass
|
|
11
|
+
from typing import List, Dict, Any, Tuple
|
|
12
|
+
import networkx as nx
|
|
13
|
+
from src.graph.builder import RepoGraphBuilder
|
|
14
|
+
from src.graph.slicer import CodeGraphSlicer
|
|
15
|
+
|
|
16
|
+
|
|
17
|
+
@dataclass
|
|
18
|
+
class BenchmarkResult:
|
|
19
|
+
method_name: str
|
|
20
|
+
prompt_tokens: int
|
|
21
|
+
preprocessing_time_ms: float
|
|
22
|
+
captured_target_entity: bool
|
|
23
|
+
estimated_kv_vram_mb: float
|
|
24
|
+
|
|
25
|
+
|
|
26
|
+
def estimate_kv_cache_vram_mb(tokens: int, num_layers: int = 32, num_heads: int = 16, head_dim: int = 256) -> float:
|
|
27
|
+
"""
|
|
28
|
+
Estimates KV-Cache VRAM usage for Gemma 2/4 9B architecture:
|
|
29
|
+
VRAM = 2 (K and V) * num_layers * num_kv_heads * head_dim * tokens * 2 bytes (FP16/BF16)
|
|
30
|
+
"""
|
|
31
|
+
bytes_per_token = 2 * num_layers * num_heads * head_dim * 2
|
|
32
|
+
total_bytes = bytes_per_token * tokens
|
|
33
|
+
return round(total_bytes / (1024 * 1024), 2)
|
|
34
|
+
|
|
35
|
+
|
|
36
|
+
class SimpleBM25Retriever:
|
|
37
|
+
"""Standard BM25 lexical retriever representing the Agentless baseline."""
|
|
38
|
+
def __init__(self, corpus: Dict[str, str]):
|
|
39
|
+
self.corpus = corpus # path -> content
|
|
40
|
+
self.doc_lens = {k: len(v.split()) for k, v in corpus.items()}
|
|
41
|
+
self.avg_doc_len = sum(self.doc_lens.values()) / max(len(self.doc_lens), 1)
|
|
42
|
+
|
|
43
|
+
def retrieve(self, query: str, top_k: int = 2) -> Dict[str, str]:
|
|
44
|
+
q_tokens = set(query.lower().split())
|
|
45
|
+
scores = {}
|
|
46
|
+
for path, text in self.corpus.items():
|
|
47
|
+
text_tokens = text.lower().split()
|
|
48
|
+
# Approximate TF-IDF matching
|
|
49
|
+
score = sum(text_tokens.count(t) for t in q_tokens)
|
|
50
|
+
scores[path] = score
|
|
51
|
+
sorted_files = sorted(scores.items(), key=lambda x: x[1], reverse=True)[:top_k]
|
|
52
|
+
return {k: self.corpus[k] for k, _ in sorted_files}
|
|
53
|
+
|
|
54
|
+
|
|
55
|
+
class PipelineEvaluator:
|
|
56
|
+
def __init__(self, repo_dir: str):
|
|
57
|
+
self.repo_dir = repo_dir
|
|
58
|
+
self.raw_files: Dict[str, str] = {}
|
|
59
|
+
self._load_raw_files()
|
|
60
|
+
|
|
61
|
+
def _load_raw_files(self):
|
|
62
|
+
import os
|
|
63
|
+
for root, dirs, files in os.walk(self.repo_dir):
|
|
64
|
+
dirs[:] = [d for d in dirs if not d.startswith(".") and d not in ("venv", ".venv")]
|
|
65
|
+
for f in files:
|
|
66
|
+
if f.endswith(".py"):
|
|
67
|
+
full = os.path.join(root, f)
|
|
68
|
+
rel = os.path.relpath(full, self.repo_dir)
|
|
69
|
+
with open(full, "r", encoding="utf-8", errors="replace") as fh:
|
|
70
|
+
self.raw_files[rel] = fh.read()
|
|
71
|
+
|
|
72
|
+
def run_raw_dump(self, issue: str, target_symbol: str) -> BenchmarkResult:
|
|
73
|
+
"""Baseline 1: Dumps all repository files into prompt."""
|
|
74
|
+
t0 = time.perf_counter()
|
|
75
|
+
full_text = "\n\n".join([f"### File: {k}\n{v}" for k, v in self.raw_files.items()])
|
|
76
|
+
elapsed_ms = (time.perf_counter() - t0) * 1000
|
|
77
|
+
tokens = int(len(full_text.split()) * 1.3)
|
|
78
|
+
|
|
79
|
+
return BenchmarkResult(
|
|
80
|
+
method_name="Baseline 1: Raw Context Dump",
|
|
81
|
+
prompt_tokens=tokens,
|
|
82
|
+
preprocessing_time_ms=round(elapsed_ms, 2),
|
|
83
|
+
captured_target_entity=target_symbol in full_text,
|
|
84
|
+
estimated_kv_vram_mb=estimate_kv_cache_vram_mb(tokens),
|
|
85
|
+
)
|
|
86
|
+
|
|
87
|
+
def run_bm25_rag(self, issue: str, target_symbol: str) -> BenchmarkResult:
|
|
88
|
+
"""Baseline 2: BM25 Lexical Retrieval (Agentless)."""
|
|
89
|
+
t0 = time.perf_counter()
|
|
90
|
+
retriever = SimpleBM25Retriever(self.raw_files)
|
|
91
|
+
results = retriever.retrieve(issue, top_k=2)
|
|
92
|
+
elapsed_ms = (time.perf_counter() - t0) * 1000
|
|
93
|
+
|
|
94
|
+
text = "\n\n".join([f"### File: {k}\n{v}" for k, v in results.items()])
|
|
95
|
+
tokens = int(len(text.split()) * 1.3)
|
|
96
|
+
|
|
97
|
+
return BenchmarkResult(
|
|
98
|
+
method_name="Baseline 2: BM25 Lexical RAG (Agentless)",
|
|
99
|
+
prompt_tokens=tokens,
|
|
100
|
+
preprocessing_time_ms=round(elapsed_ms, 2),
|
|
101
|
+
captured_target_entity=target_symbol in text,
|
|
102
|
+
estimated_kv_vram_mb=estimate_kv_cache_vram_mb(tokens),
|
|
103
|
+
)
|
|
104
|
+
|
|
105
|
+
def run_neurocode(self, issue: str, target_symbol: str) -> BenchmarkResult:
|
|
106
|
+
"""Our Proposed Method: NeuroCode Host-CPU Graph Slicing."""
|
|
107
|
+
t0 = time.perf_counter()
|
|
108
|
+
builder = RepoGraphBuilder(self.repo_dir)
|
|
109
|
+
graph = builder.build()
|
|
110
|
+
slicer = CodeGraphSlicer(graph)
|
|
111
|
+
seeds = slicer.find_seed_nodes(issue)
|
|
112
|
+
subgraph = slicer.extract_subgraph(seeds, k_hops=1)
|
|
113
|
+
slice_text = slicer.format_slice_for_llm(subgraph, seeds)
|
|
114
|
+
elapsed_ms = (time.perf_counter() - t0) * 1000
|
|
115
|
+
|
|
116
|
+
tokens = int(len(slice_text.split()) * 1.3)
|
|
117
|
+
|
|
118
|
+
return BenchmarkResult(
|
|
119
|
+
method_name="Our Method: NeuroCode Host-CPU Slicer",
|
|
120
|
+
prompt_tokens=tokens,
|
|
121
|
+
preprocessing_time_ms=round(elapsed_ms, 2),
|
|
122
|
+
captured_target_entity=target_symbol in slice_text,
|
|
123
|
+
estimated_kv_vram_mb=estimate_kv_cache_vram_mb(tokens),
|
|
124
|
+
)
|
|
@@ -0,0 +1,259 @@
|
|
|
1
|
+
"""
|
|
2
|
+
Generates publication-quality 4:3 aspect ratio figures for Kaggle Writeup & Paper.
|
|
3
|
+
Renders:
|
|
4
|
+
1. paper/figures/fig1_empirical_comparison_4x3.png (figsize=(8, 6))
|
|
5
|
+
2. paper/figures/fig2_system_architecture_4x3.png (figsize=(8, 6))
|
|
6
|
+
3. paper/figures/fig3_local_gpu_ablation_4x3.png (figsize=(8, 6))
|
|
7
|
+
"""
|
|
8
|
+
|
|
9
|
+
import matplotlib.pyplot as plt
|
|
10
|
+
import matplotlib.patches as patches
|
|
11
|
+
import numpy as np
|
|
12
|
+
from pathlib import Path
|
|
13
|
+
|
|
14
|
+
FIG_DIR = Path("/home/deepak-r/Project/research/paper/figures")
|
|
15
|
+
FIG_DIR.mkdir(parents=True, exist_ok=True)
|
|
16
|
+
|
|
17
|
+
|
|
18
|
+
def generate_fig1_4x3(out_path: Path):
|
|
19
|
+
"""Figure 1 in 4:3 aspect ratio (8 x 6 inches): Token Cost & Recall@3 (N=292)."""
|
|
20
|
+
fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(8, 6), dpi=300)
|
|
21
|
+
|
|
22
|
+
# Panel (a): Context Tokens & Dollar Cost
|
|
23
|
+
methods = ['Raw Dump\n(Baseline)', 'BM25\n(Agentless)', 'RepoMap\n(Aider)', 'NeuroCode\n(Ours)']
|
|
24
|
+
tokens = [35420, 44687, 1499, 1314]
|
|
25
|
+
costs = [(t / 1e6) * 3.0 for t in tokens]
|
|
26
|
+
colors = ['#e74c3c', '#f39c12', '#3498db', '#2ecc71']
|
|
27
|
+
|
|
28
|
+
bars1 = ax1.bar(methods, tokens, color=colors, edgecolor='black', width=0.52)
|
|
29
|
+
ax1.set_ylabel('Input Prompt Tokens', fontsize=9.5, fontweight='bold')
|
|
30
|
+
ax1.set_title('(a) Context Token Footprint & Dollar Cost per Bug Attempt (N = 292 SWE-bench Lite)', fontsize=10.5, fontweight='bold')
|
|
31
|
+
ax1.grid(axis='y', linestyle='--', alpha=0.5)
|
|
32
|
+
ax1.set_ylim(0, 52000)
|
|
33
|
+
|
|
34
|
+
for bar, tok, cost in zip(bars1, tokens, costs):
|
|
35
|
+
ax1.text(
|
|
36
|
+
bar.get_x() + bar.get_width() / 2,
|
|
37
|
+
tok + 1200,
|
|
38
|
+
f"{tok:,} tok\n(${cost:.4f})",
|
|
39
|
+
ha='center',
|
|
40
|
+
fontsize=8.5,
|
|
41
|
+
fontweight='bold'
|
|
42
|
+
)
|
|
43
|
+
|
|
44
|
+
ax1.annotate(
|
|
45
|
+
'-97.1% Cost Savings',
|
|
46
|
+
xy=(3, 1314),
|
|
47
|
+
xytext=(2.2, 22000),
|
|
48
|
+
arrowprops=dict(facecolor='#27ae60', shrink=0.08, width=1.8, headwidth=7),
|
|
49
|
+
fontsize=9,
|
|
50
|
+
fontweight='bold',
|
|
51
|
+
color='#1e8449',
|
|
52
|
+
ha='center',
|
|
53
|
+
bbox=dict(boxstyle='round,pad=0.3', facecolor='#eafaf1', edgecolor='#27ae60')
|
|
54
|
+
)
|
|
55
|
+
|
|
56
|
+
# Panel (b): Fault Localization Recall@3
|
|
57
|
+
labels = ['BM25 (Agentless)', 'RepoMap (Aider PageRank)', 'NeuroCode CPG (Our Method)']
|
|
58
|
+
recalls = [3.1, 3.1, 17.1]
|
|
59
|
+
bar_colors2 = ['#f39c12', '#3498db', '#27ae60']
|
|
60
|
+
|
|
61
|
+
bars2 = ax2.barh(labels, recalls, color=bar_colors2, edgecolor='black', height=0.45)
|
|
62
|
+
ax2.set_xlabel('Fault Localization Recall@3 (%)', fontsize=9.5, fontweight='bold')
|
|
63
|
+
ax2.set_title('(b) Target Fault Localization Accuracy on SWE-bench Lite (N = 292)', fontsize=10.5, fontweight='bold')
|
|
64
|
+
ax2.grid(axis='x', linestyle='--', alpha=0.5)
|
|
65
|
+
ax2.set_xlim(0, 22.0)
|
|
66
|
+
|
|
67
|
+
for bar, rec in zip(bars2, recalls):
|
|
68
|
+
ax2.text(
|
|
69
|
+
rec + 0.35,
|
|
70
|
+
bar.get_y() + bar.get_height() / 2,
|
|
71
|
+
f"{rec:.1f}%",
|
|
72
|
+
va='center',
|
|
73
|
+
fontsize=9.5,
|
|
74
|
+
fontweight='bold'
|
|
75
|
+
)
|
|
76
|
+
|
|
77
|
+
ax2.annotate(
|
|
78
|
+
'5.5x vs BM25 & RepoMap',
|
|
79
|
+
xy=(17.1, 2),
|
|
80
|
+
xytext=(12.0, 1.2),
|
|
81
|
+
arrowprops=dict(facecolor='#27ae60', shrink=0.08, width=1.5, headwidth=6),
|
|
82
|
+
fontsize=8.5,
|
|
83
|
+
fontweight='bold',
|
|
84
|
+
color='#1e8449',
|
|
85
|
+
ha='center',
|
|
86
|
+
bbox=dict(boxstyle='round,pad=0.3', facecolor='#eafaf1', edgecolor='#27ae60')
|
|
87
|
+
)
|
|
88
|
+
|
|
89
|
+
plt.tight_layout()
|
|
90
|
+
plt.savefig(out_path, dpi=300)
|
|
91
|
+
plt.close()
|
|
92
|
+
print(f"[OK] Generated 4:3 Figure 1 at: {out_path}")
|
|
93
|
+
|
|
94
|
+
|
|
95
|
+
def generate_fig2_4x3(out_path: Path):
|
|
96
|
+
"""Figure 2 in 4:3 aspect ratio (8 x 6 inches): System Architecture."""
|
|
97
|
+
fig, ax = plt.subplots(figsize=(8, 6), dpi=300)
|
|
98
|
+
ax.set_xlim(0, 10)
|
|
99
|
+
ax.set_ylim(0, 7.5)
|
|
100
|
+
ax.axis('off')
|
|
101
|
+
|
|
102
|
+
# Title header
|
|
103
|
+
ax.text(5.0, 7.2, "NeuroCode: Heterogeneous Division of Labor", ha="center", fontsize=12, fontweight="bold", color="#1a252f")
|
|
104
|
+
|
|
105
|
+
# 1. Host CPU Box
|
|
106
|
+
host_box = patches.FancyBboxPatch((0.5, 1.2), 4.2, 5.6, boxstyle="round,pad=0.2",
|
|
107
|
+
facecolor="#ecf0f1", edgecolor="#2c3e50", linewidth=2)
|
|
108
|
+
ax.add_patch(host_box)
|
|
109
|
+
ax.text(2.6, 6.5, "HOST SYSTEM (CPU & RAM)", ha="center", fontsize=10.5, fontweight="bold", color="#2c3e50")
|
|
110
|
+
ax.text(2.6, 6.2, "Idle Multi-Core Compute & Shared Memory", ha="center", fontsize=7.5, color="#7f8c8d")
|
|
111
|
+
|
|
112
|
+
# Sub-box 1: CPG Builder
|
|
113
|
+
cpg_box = patches.FancyBboxPatch((0.8, 4.4), 3.6, 1.5, boxstyle="round,pad=0.1",
|
|
114
|
+
facecolor="#3498db", edgecolor="#1d6fa5", linewidth=1.5)
|
|
115
|
+
ax.add_patch(cpg_box)
|
|
116
|
+
ax.text(2.6, 5.45, "1. In-Memory Code Property Graph", ha="center", fontsize=9, fontweight="bold", color="white")
|
|
117
|
+
ax.text(2.6, 5.05, "- Tree-sitter AST Multi-Language Parsing", ha="center", fontsize=7.5, color="#f0f8ff")
|
|
118
|
+
ax.text(2.6, 4.70, "- Call, Contains & Inheritance Edges", ha="center", fontsize=7.5, color="#f0f8ff")
|
|
119
|
+
|
|
120
|
+
# Sub-box 2: Slicer
|
|
121
|
+
slicer_box = patches.FancyBboxPatch((0.8, 1.7), 3.6, 2.2, boxstyle="round,pad=0.1",
|
|
122
|
+
facecolor="#2ecc71", edgecolor="#219653", linewidth=1.5)
|
|
123
|
+
ax.add_patch(slicer_box)
|
|
124
|
+
ax.text(2.6, 3.45, "2. Deterministic Context Slicer", ha="center", fontsize=9, fontweight="bold", color="white")
|
|
125
|
+
ax.text(2.6, 3.05, "- Multiple-Choice Knapsack (MCKP)", ha="center", fontsize=7.5, color="#f0f8ff")
|
|
126
|
+
ax.text(2.6, 2.70, "- Topological k-Hop Reachability", ha="center", fontsize=7.5, color="#f0f8ff")
|
|
127
|
+
ax.text(2.6, 2.35, "- Slicing Latency: 28.8 ms", ha="center", fontsize=7.5, fontweight="bold", color="#f0f8ff")
|
|
128
|
+
ax.text(2.6, 2.00, "- Cuts 96.8% of Repository Tokens", ha="center", fontsize=7.5, color="#f0f8ff")
|
|
129
|
+
|
|
130
|
+
# Internal arrow inside host
|
|
131
|
+
ax.annotate("", xy=(2.6, 4.0), xytext=(2.6, 4.4),
|
|
132
|
+
arrowprops=dict(arrowstyle="->", lw=2, color="#2c3e50"))
|
|
133
|
+
|
|
134
|
+
# 2. Accelerator Device Box (GPU)
|
|
135
|
+
gpu_box = patches.FancyBboxPatch((5.3, 1.2), 4.2, 5.6, boxstyle="round,pad=0.2",
|
|
136
|
+
facecolor="#fcf3cf", edgecolor="#f39c12", linewidth=2)
|
|
137
|
+
ax.add_patch(gpu_box)
|
|
138
|
+
ax.text(7.4, 6.5, "DEVICE ACCELERATOR (GPU < 8GB)", ha="center", fontsize=10.5, fontweight="bold", color="#b7950b")
|
|
139
|
+
ax.text(7.4, 6.2, "Consumer VRAM: RTX 3050 (4GB) / T4 (16GB)", ha="center", fontsize=7.5, color="#7f8c8d")
|
|
140
|
+
|
|
141
|
+
# Local Edge LLM Agent Box
|
|
142
|
+
agent_box = patches.FancyBboxPatch((5.6, 3.2), 3.6, 2.7, boxstyle="round,pad=0.1",
|
|
143
|
+
facecolor="#e67e22", edgecolor="#ba4a00", linewidth=1.5)
|
|
144
|
+
ax.add_patch(agent_box)
|
|
145
|
+
ax.text(7.4, 5.45, "Local Edge Developer Agent", ha="center", fontsize=9.5, fontweight="bold", color="white")
|
|
146
|
+
ax.text(7.4, 5.05, "(Gemma 4 / Qwen2.5-Coder 1.5B-7B)", ha="center", fontsize=8, fontweight="bold", color="#fef9e7")
|
|
147
|
+
ax.text(7.4, 4.60, "- Zero Exploratory Tool-Calling Loops", ha="center", fontsize=7.5, color="#fef9e7")
|
|
148
|
+
ax.text(7.4, 4.25, "- Strict <= 1,500 Token Context", ha="center", fontsize=7.5, color="#fef9e7")
|
|
149
|
+
ax.text(7.4, 3.90, "- Single-Turn Neural Patch Synthesis", ha="center", fontsize=7.5, color="#fef9e7")
|
|
150
|
+
ax.text(7.4, 3.55, "- 961 MB Active VRAM Footprint", ha="center", fontsize=7.5, fontweight="bold", color="#fef9e7")
|
|
151
|
+
|
|
152
|
+
patch_box = patches.FancyBboxPatch((5.6, 1.6), 3.6, 1.2, boxstyle="round,pad=0.1",
|
|
153
|
+
facecolor="#95a5a6", edgecolor="#7f8c8d", linewidth=1)
|
|
154
|
+
ax.add_patch(patch_box)
|
|
155
|
+
ax.text(7.4, 2.45, "Exact SEARCH/REPLACE Diff Patch", ha="center", fontsize=8.5, fontweight="bold", color="white")
|
|
156
|
+
ax.text(7.4, 2.05, "59 / 132 (44.7%) Valid Patches Applied", ha="center", fontsize=7.5, color="#f0f8ff")
|
|
157
|
+
ax.text(7.4, 1.75, "Resolved Directly in Local Repository", ha="center", fontsize=7.5, color="#f0f8ff")
|
|
158
|
+
|
|
159
|
+
# PCIe Transfer Arrow
|
|
160
|
+
ax.annotate("", xy=(5.5, 3.8), xytext=(4.5, 3.8),
|
|
161
|
+
arrowprops=dict(arrowstyle="->", lw=2.5, color="#e74c3c"))
|
|
162
|
+
ax.text(5.0, 4.1, "PCIe Transfer\n(1,034 tokens)", ha="center", fontsize=7.5, fontweight="bold", color="#c0392b")
|
|
163
|
+
|
|
164
|
+
# Feedback verification arrow back to CPU
|
|
165
|
+
ax.annotate("", xy=(4.5, 2.2), xytext=(5.5, 2.2),
|
|
166
|
+
arrowprops=dict(arrowstyle="->", lw=2.0, color="#2980b9", linestyle="--"))
|
|
167
|
+
ax.text(5.0, 1.75, "Unit Test Check\n(pytest on CPU)", ha="center", fontsize=7, fontweight="bold", color="#2980b9")
|
|
168
|
+
|
|
169
|
+
# Bottom footer caption
|
|
170
|
+
ax.text(5.0, 0.4, "Formal Host-Device Separation Resolves KV-Cache Memory Wall & Tool-Loop Drift",
|
|
171
|
+
ha="center", fontsize=8.5, fontstyle="italic", color="#555555")
|
|
172
|
+
|
|
173
|
+
plt.tight_layout()
|
|
174
|
+
plt.savefig(out_path, dpi=300)
|
|
175
|
+
plt.close()
|
|
176
|
+
print(f"[OK] Generated 4:3 Figure 2 at: {out_path}")
|
|
177
|
+
|
|
178
|
+
|
|
179
|
+
def generate_fig3_4x3(out_path: Path):
|
|
180
|
+
"""Figure 3 in 4:3 aspect ratio (8 x 6 inches): Physical On-Device Edge Validation."""
|
|
181
|
+
fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(8, 6), dpi=300)
|
|
182
|
+
|
|
183
|
+
# Panel (a): Physical RTX 3050 VRAM Pie
|
|
184
|
+
categories = ['OS/Display\n(~260MB)', 'Model Weights\n(942MB)', 'KV-Cache\n(19MB)', 'Headroom\n(2.54GB)']
|
|
185
|
+
vram_mb = [260, 942, 19, 2541]
|
|
186
|
+
colors = ['#95a5a6', '#e67e22', '#2ecc71', '#3498db']
|
|
187
|
+
|
|
188
|
+
wedges, texts, autotexts = ax1.pie(
|
|
189
|
+
vram_mb,
|
|
190
|
+
labels=categories,
|
|
191
|
+
autopct='%1.0f%%',
|
|
192
|
+
startangle=140,
|
|
193
|
+
colors=colors,
|
|
194
|
+
explode=(0.02, 0.04, 0.08, 0.02),
|
|
195
|
+
wedgeprops=dict(edgecolor='black', linewidth=0.8)
|
|
196
|
+
)
|
|
197
|
+
for t in texts: t.set_fontsize(7.5)
|
|
198
|
+
for at in autotexts:
|
|
199
|
+
at.set_fontsize(7.5)
|
|
200
|
+
at.set_fontweight('bold')
|
|
201
|
+
ax1.set_title('(a) Physical RTX 3050 VRAM Breakdown\n(3.67GB Usable | 961MB Active)', fontsize=8.5, fontweight='bold')
|
|
202
|
+
|
|
203
|
+
# Panel (b): Preprocessing & Slicing Latency
|
|
204
|
+
stages = ['CPG Build\n(Host CPU)', 'Knapsack\nSlicing']
|
|
205
|
+
lat_ms = [3294.3, 28.8]
|
|
206
|
+
bar_colors = ['#34495e', '#2ecc71']
|
|
207
|
+
|
|
208
|
+
bars = ax2.bar(stages, lat_ms, color=bar_colors, edgecolor='black', width=0.45)
|
|
209
|
+
ax2.set_ylabel('Latency (ms)', fontsize=8, fontweight='bold')
|
|
210
|
+
ax2.set_title('(b) Host CPU Processing Time\n(Sub-50ms Slicing Response)', fontsize=8.5, fontweight='bold')
|
|
211
|
+
ax2.set_yscale('log')
|
|
212
|
+
ax2.set_ylim(1, 10000)
|
|
213
|
+
ax2.grid(axis='y', linestyle='--', alpha=0.5)
|
|
214
|
+
|
|
215
|
+
for bar, val in zip(bars, lat_ms):
|
|
216
|
+
ax2.text(bar.get_x() + bar.get_width() / 2, val * 1.35, f"{val:.1f} ms",
|
|
217
|
+
ha='center', fontsize=8, fontweight='bold')
|
|
218
|
+
|
|
219
|
+
# Panel (c): Component Ablation Hit@1 (%)
|
|
220
|
+
variants = ['Lexical\nSeeds', 'Seeds+\nImports', 'Seeds+\nCalls', 'Full CPG\nUnconstr.', 'NeuroCode\n(MCKP)']
|
|
221
|
+
hit_rates = [0.0, 0.0, 40.0, 20.0, 80.0]
|
|
222
|
+
abl_colors = ['#bdc3c7', '#95a5a6', '#f39c12', '#e67e22', '#27ae60']
|
|
223
|
+
|
|
224
|
+
b_abl = ax3.bar(variants, hit_rates, color=abl_colors, edgecolor='black', width=0.55)
|
|
225
|
+
ax3.set_ylabel('Fault Hit Rate (%)', fontsize=8, fontweight='bold')
|
|
226
|
+
ax3.set_title('(c) Component Ablation Study\n(Multi-Module Bug Benchmark)', fontsize=8.5, fontweight='bold')
|
|
227
|
+
ax3.set_ylim(0, 100)
|
|
228
|
+
ax3.tick_params(axis='x', labelsize=7)
|
|
229
|
+
ax3.grid(axis='y', linestyle='--', alpha=0.5)
|
|
230
|
+
|
|
231
|
+
for bar, val in zip(b_abl, hit_rates):
|
|
232
|
+
ax3.text(bar.get_x() + bar.get_width() / 2, val + 3.0, f"{val:.0f}%",
|
|
233
|
+
ha='center', fontsize=7.5, fontweight='bold')
|
|
234
|
+
|
|
235
|
+
# Panel (d): SWE-bench Token Cost Comparison ($ / Bug)
|
|
236
|
+
cost_methods = ['BM25', 'RepoMap', 'NeuroCode']
|
|
237
|
+
costs = [0.0968, 0.0045, 0.0031]
|
|
238
|
+
c_colors = ['#f39c12', '#3498db', '#2ecc71']
|
|
239
|
+
|
|
240
|
+
bars4 = ax4.bar(cost_methods, costs, color=c_colors, edgecolor='black', width=0.5)
|
|
241
|
+
ax4.set_ylabel('API Cost per Bug ($)', fontsize=8, fontweight='bold')
|
|
242
|
+
ax4.set_title('(d) Developer API Dollar Cost\n($3.00 / 1M prompt tokens)', fontsize=8.5, fontweight='bold')
|
|
243
|
+
ax4.grid(axis='y', linestyle='--', alpha=0.5)
|
|
244
|
+
ax4.set_ylim(0, 0.12)
|
|
245
|
+
|
|
246
|
+
for bar, c in zip(bars4, costs):
|
|
247
|
+
ax4.text(bar.get_x() + bar.get_width() / 2, c + 0.004, f"${c:.4f}",
|
|
248
|
+
ha='center', fontsize=7.5, fontweight='bold')
|
|
249
|
+
|
|
250
|
+
plt.tight_layout()
|
|
251
|
+
plt.savefig(out_path, dpi=300)
|
|
252
|
+
plt.close()
|
|
253
|
+
print(f"[OK] Generated 4:3 Figure 3 at: {out_path}")
|
|
254
|
+
|
|
255
|
+
|
|
256
|
+
if __name__ == '__main__':
|
|
257
|
+
generate_fig1_4x3(FIG_DIR / "fig1_empirical_comparison_4x3.png")
|
|
258
|
+
generate_fig2_4x3(FIG_DIR / "fig2_system_architecture_4x3.png")
|
|
259
|
+
generate_fig3_4x3(FIG_DIR / "fig3_local_gpu_ablation_4x3.png")
|