AutoKernel: GPU kernel का स्वचालित रिसर्च सिस्टम

• Karpathy के Autoresearch को GPU kernel ऑप्टिमाइज़ेशन में लागू किया गया है
• PyTorch मॉडल इनपुट करने पर Triton या CUDA C++ kernel को स्वचालित रूप से optimize करने वाला GPU kernel ऑटो रिसर्च टूल
• मॉडल के बॉटलनेक kernel को प्रोफाइलिंग, एक्सट्रैक्शन, ऑप्टिमाइज़ेशन और वेरिफिकेशन करने के लिए पूर्णतः स्वचालित pipeline उपलब्ध कराता है
• Amdahl के नियम पर आधारित orchestration से प्राथमिकता तय की जाती है, प्रत्येक प्रयोग लगभग 90 सेकंड का होता है, इसलिए पूरी रात में सैकड़ों बार दोहराना संभव है
• KernelBench के साथ एकीकरण के बाद 250 से अधिक समस्याओं पर 50~300 बार दोहराव प्रयोग चलाए जाते हैं, जिससे one-shot generation की बजाय systematic खोज संभव होती है
• Triton और CUDA C++ डुअल बैकएंड, accuracy-first validation, single-file edit structure के साथ अधिक कुशल और reproducible kernel optimization का समर्थन

---

काम करने का तरीका

• AutoKernel, PyTorch मॉडल लेने के बाद निम्नलिखित चरण चलाता है
  • प्रोफाइलिंग के जरिए GPU के बॉटलनेक kernel की पहचान
  • उन्हें अलग करके स्वतंत्र Triton या CUDA C++ kernel के रूप में extract करना
  • ऑटो ऑप्टिमाइज़ेशन लूप द्वारा modify, benchmark, keep/rollback दोहराना
  • accuracy check के बाद कुल गति सुधार की रिपोर्ट बनाना
• program.md में दी गई निर्देशों के आधार पर kernel.py को बदलता है और bench.py से 5 चरणों वाली correctness जाँच तथा roofline analysis करता है
• प्रत्येक प्रयोग लगभग 90 सेकंड, प्रति घंटा लगभग 40 रन और एक रात में करीब 320 रन संभव

निष्पादन और घटक

• आवश्यक वातावरण: NVIDIA GPU(H100/A100/RTX 4090), Python 3.10+, uv पैकेज
• प्रमुख स्क्रिप्ट संरचना
  • profile.py: GPU-time आधारित kernel ranking
  • extract.py: शीर्ष बॉटलनेक kernel निकालना
  • bench.py: 5 चरणीय accuracy और performance benchmark
  • orchestrate.py: Amdahl के नियम पर आधारित multi-kernel scheduling
  • verify.py: पूरे मॉडल का सत्यापन और speedup रिपोर्ट
• program.md में 6-step optimization strategy, conflict handling और decision framework शामिल हैं, जिससे लंबे समय तक autonomous रन संभव होता है

समर्थित kernel और उदाहरण मॉडल

• 9 प्रकार के kernel समर्थित: matmul, softmax, layernorm, rmsnorm, flash_attention, fused_mlp, cross_entropy, rotary_embedding, reduce
• प्रत्येक kernel में PyTorch reference implementation (reference.py) तथा Triton/CUDA प्रारंभिक संस्करण (kernels/, kernels/cuda/) मौजूद हैं
• उदाहरण मॉडल: GPT-2, LLaMA (7B सहित), BERT-base, custom models
• HuggingFace मॉडल uv sync --extra models से भी जोड़े जा सकते हैं

KernelBench इंटीग्रेशन

• KernelBench (Stanford Scaling Intelligence Lab) के साथ एकीकृत होकर AI-generated GPU kernel का standardized benchmark चलाता है
• AutoKernel प्रत्येक problem पर 50~300 बार दोहराए गए प्रयोग करके optimization space की systematic खोज करता है
• मुख्य tools
  • bridge.py: समस्या लोड करना और प्रारंभिक kernel निर्माण
  • bench_kb.py: accuracy और performance evaluation
  • scorer.py: कुल स्तर का score गणना
  • program_kb.md: KernelBench-विशिष्ट agent निर्देश

HuggingFace Hub export

• optimized kernel को HuggingFace Hub पर export कर सकते हैं और get_kernel() से तुरंत लोड किया जा सकता है
• export_hf.py CUDA kernel export तथा upload को सपोर्ट करता है

डिजाइन सिद्धांत

• Triton + CUDA C++ डुअल बैकएंड: Triton तेज़ iteration देता है, जबकि CUDA सर्वोच्च performance देता है
• accuracy-first: यदि PyTorch आउटपुट से मेल न खाए तो तुरंत rollback हो जाता है
• Amdahl के नियम पर आधारित orchestration से total performance contribution के आधार पर priority तय की जाती है
• single-file edit structure (kernel.py) के कारण बदलाव ट्रैक करना और recovery आसान होता है
• TSV लॉग (results.tsv) के जरिए प्रयोग परिणाम सरल और readable तरीके से दर्ज होते हैं

परिणाम लॉग फ़ॉर्मेट

• results.tsv में प्रत्येक प्रयोग की क्रम संख्या, kernel type, throughput (TFLOPS), latency, GPU peak के विरुद्ध ratio, PyTorch speedup, accuracy, VRAM उपयोग, explanation दर्ज की जाती है

परियोजना की पृष्ठभूमि

• Andrej Karpathy के autoresearch concept से प्रेरित होकर, LLM research के लिए बनाए गए autonomous AI agent ढाँचे को GPU kernel optimization में लागू किया गया है
• KernelBench इंटीग्रेशन Stanford Scaling Intelligence Lab के शोध पर आधारित है और AutoKernel one-shot generation की बजाय iterative optimization चलता है
• परियोजना RightNow AI की Forge टीम ने विकसित की, और इसे MIT License के तहत ओपन-सोर्स किया गया है

[GN⁺]

Hacker News टिप्पणियाँ

• सच में बहुत बढ़िया प्रोजेक्ट है
  मैं भी पिछले कुछ हफ्तों से लगभग ऐसा ही बना रहा था, लेकिन वो कहीं ज़्यादा generic और over-designed वाला संस्करण था
  Triton और सिर्फ़ specific kernel पर फोकस करने की वजह से यह approach सरल है लेकिन बहुत efficient है
  बस progress graph थोड़ा confusing है। यह 4096x4096x4096 fp16 matmul benchmark जैसा लगता है, जबकि cuBLAS के मुकाबले 1.31x सुधार बताते हुए भी 187 TFLOPS यानी सिर्फ़ 18.9% peak utilization दिखाता है
  cuBLAS काफी ज्यादा peak के करीब performance देता है; शायद CPU overhead या कोई दूसरा bottleneck कारण हो सकता है
  benchmark करना सच में कठिन है, लेकिन मुझे लगता है कि आने वाले 6 महीनों में यह क्षेत्र काफ़ी promising रहेगा

• अगर यह llama.cpp जैसे किसी जगह काम करे तो असर काफ़ी बड़ा होगा
  कई तरह के quantization kernels और हार्डवेयर कॉन्फ़िगरेशन मौजूद हैं, और अकेले users की संख्या भी ज्यादा है, इसलिए efficiency gain और बड़ा होगा
  अच्छा रहेगा अगर यह प्रोजेक्ट उसमें contributor के तौर पर शामिल हो

  • सही कहा आपने
    llama.cpp में Q4_K_M, Q5_K_S, Q8_0 जैसे कई हाथ से tuned CUDA kernels हैं, और हर एक अलग hardware profile target करता है
    यदि GPU-by-GPU auto-optimization संभव हो जाए तो बदलाव बहुत बड़ा होगा
    इसी कारण अभी भी একই quantization format में RTX 3090 और 5070 Ti के बीच performance gap काफी बड़ा दिखता है
    llama.cpp जैसा high hardware diversity वाला environment ही है जहाँ auto kernel खोज सबसे ज़्यादा चमकेगी

• कमाल!
  मैं Apple Silicon के लिए भी यही capability जोड़ रहा हूँ
  अपनी project autoresearch-everywhere में मैं autoresearch को एक serious tool बनाने पर काम कर रहा हूँ

• कुछ गड़बड़ लग रहा है
  4kx4kx4k fp16 GEMM के हिसाब से देखें तो cutlass लगभग 3x तेज़ है

• क्या आपने TVM के Ansor जैसी automated scheduling से कोई compare benchmark किया है?

• अभी यह बस शुरुआत है
  वैसे Google ने दो मॉडल generations पहले ही ऐसा काम कर लिया था
  मई 2025 के ब्लॉग पोस्ट AlphaEvolve में बताया गया कि उन्होंने Gemini architecture के key kernels में बड़े matrix multiplication को छोटे sub-problems में बाँटकर 23% speedup हासिल किया और training time 1% कम किया
  यानी अब ऐसा वक्त आ गया है जब ये टेक्नोलॉजी “घर पर भी” संभव है
  खासकर क्योंकि हाल के समय में RL-based learning बढ़ रही है, inference speedup सीधे training speedup में बदल जाएगा

• Swift या Rust जैसी open source language runtimes में भी अगर ऐसी optimizations शामिल हो जाएँ तो आख़िरी performance drop करने का दिन कब आएगा