- सरल local rules से complex patterns को reverse engineer करने के तरीके की खोज
- Neural Cellular Automata(NCA) की learnability और Differentiable Logic Gate Networks को मिलाकर, discrete local rules को learning के ज़रिए प्राप्त करने का एक approach
- "क्या Conway's Game of Life के rules सीखे जा सकते हैं?"
- "क्या NCA की तरह complex patterns को reproduce करते हुए, spatiotemporal recurrent structure सीखी जा सकती है?"
Introduction
- Cellular Automata(CA) सरल local rules से शुरू होकर complex और predict करना कठिन patterns बनाते हैं
- पारंपरिक रूप से CA में rules को इंसान सीधे design करते थे, लेकिन यहाँ एक ऐसा तरीका पेश किया गया है जिसमें target pattern या behavior पहले से दिया जाता है, और उसे satisfy करने वाले local rules को उल्टा ‘सीखा’ जा सकता है
- खास तौर पर Neural Cellular Automata(NCA) को CA structure में deep learning techniques जोड़कर इस तरह design किया गया है कि वह continuous space में train हो सके
- Differentiable Logic Gate Networks logic gates (AND, OR, XOR आदि) को continuously approximate करके train करते हैं, और अंत में उन्हें फिर से discrete logic circuits में बदल देते हैं
- इन दोनों ideas को मिलाकर DiffLogic CA नाम का एक पूरी तरह discrete और trainable CA model प्रस्तावित किया गया है
- इसे Programmable Matter या Computronium की दिशा में एक छोटा कदम माना जा सकता है
- यह लेख निम्न प्रवाह में आगे बढ़ता है
- Neural Cellular Automata का सार
- Differentiable Logic Gate Networks का सार
- दोनों methodologies को मिलाने वाली DiffLogic CA architecture
- Conway’s Game of Life rule सीखने का प्रयोग
- complex patterns (checkerboard, lizard, color image आदि) बनाने के लिए training experiments
Recap – Neural Cellular Automata(NCA)
- अवधारणा
- यह एक system है जो पारंपरिक CA rules को neural net के ज़रिए trainable रूप में replace करता है
- हर cell कई channels (state) रखता है और local interactions के ज़रिए complex patterns बनाता है
- Sobel filters आदि का उपयोग कर आसपास की जानकारी ली जाती है, और neural net state changes तय करता है
- विशेषताएँ
- पूरी computation process differentiable होती है, इसलिए desired pattern बनाने के लिए इसे train किया जा सकता है
- parallelism, locality, state-based computation जैसे CA के core को बनाए रखते हुए deep learning techniques को जोड़ता है
Recap – Differentiable Logic Gate Networks(DLGNs)
- मुख्य विचार
- पारंपरिक NN की जगह logic gates (AND, OR, XOR आदि) को continuously approximate (soft gate) करके train किया जाता है
- training phase में gates continuous तरीके से काम करते हैं, और final inference में वास्तविक binary operations करते हैं
- Training process
- gate के 16 संभावित logic operations के probability distribution को train किया जाता है, जो अंततः किसी specific operation पर converge करता है
- continuous approximation के कारण यह differentiable बनता है, और training पूरी होने पर पूरी तरह discrete logic gates में बदल जाता है
- फायदे
- final circuit पूरी तरह binary logic gates से बना होता है, इसलिए hardware efficiency अधिक होती है
- discrete logic-based होने के कारण interpretability और energy efficiency में लाभ मिलता है
Differentiable Logic Cellular Automata (DiffLogic CA)
- संरचना
- 2D grid में हर cell के पास n-bit state होती है, और simulation Perception → Update चरणों में चलती है
- Perception चरण
- neighbor information (प्रत्येक channel के अनुसार) को logic circuit kernel से process किया जाता है
- Update चरण
- current state और Perception result को दूसरे logic circuit के साथ integrate करके अगले समय की state तय की जाती है
- विशेषताएँ
- सभी cells distributed तरीके से चलने वाले छोटे, स्वतंत्र processors की तरह काम करते हैं
- soft (continuous approximation) के साथ train करने के बाद hard (binary) gates से inference किया जाता है, जिससे efficiency बढ़ती है
- यह CAM-8 जैसी CA-based computing architectures के समान दर्शन रखता है
Experiment 1: Learning Game of Life
- उद्देश्य
- Conway's Game of Life rule को DiffLogic CA के साथ सीखकर यह जाँचना कि क्या इसे पूरी तरह reproduce किया जा सकता है
- सेटअप
- cell state के लिए 1-bit का उपयोग
- Perception में 16 kernels (हर एक 8→4→2→1 gate structure)
- Update में 23 layers (पहली 16 layers में 128 nodes, उसके बाद [64, 32, 16, 8, 4, 2, 1])
- 3x3 grid में सभी संभावित states (512) पर training की गई, ताकि अगले step की सही state predict की जा सके
- परिणाम
- training loss 0 के करीब पहुँचा और Game of Life के local rule को पूरी तरह सीख लिया गया
- बड़े grid में भी वास्तविक Game of Life की तरह glider, block आदि सभी patterns reproduce हुए
- final circuit में AND और OR gates का उपयोग अधिक हुआ
Experiment 2: Pattern Generation
- Checkerboard उदाहरण
- 8-bit state वाले cells ने 20 steps में 16x16 checkerboard बनाया
- Perception में 16 kernels, Update में 16 layers (अधिकतम 256 gates)
- केवल final channel की target pattern से तुलना कर loss calculate किया गया
- परिणाम
- checkerboard बिल्कुल सही बना, और सिर्फ कुछ ही gates से rule को संक्षिप्त रूप में implement किया गया
- 4 गुना बड़े grid पर भी यही rule scale up होकर बिना समस्या काम करता है
- कुछ cells को स्थायी रूप से disable करने पर भी pattern बहुत नहीं बिगड़ता, और disabled cells को restore करने पर यह अपने आप self-heal हो जाता है
- Asynchronicity
- asynchronous updates के साथ training करने पर भी checkerboard pattern बिना समस्या सीखा गया
- synchronous training से सीखे गए rules को asynchronous inference में लागू करने पर भी वे अच्छे से काम करते हैं
- asynchronous training rules में noise या damage की स्थिति से थोड़ा तेज़ recover करने की प्रवृत्ति दिखी
Experiment 3: Growing a Lizard
- उद्देश्य
- 20x20 lizard outline को 12 steps में बनाने के लिए training कर, complex shape generation की संभावना की पुष्टि करना
- सेटअप
- 128-bit state
- Perception में 4 kernels (हर एक [8, 4, 2, 1] gate structure), Update में 10 layers (पहली 8 layers में 512 gates, उसके बाद [256, 128])
- grid के केंद्र में एक active cell रखा गया, और periodic boundary conditions का उपयोग हुआ
- परिणाम
- बड़े grid (40x40) में भी lizard सामान्य रूप से grow करता है
- बहुत बड़ी संख्या में gates इस्तेमाल होते हैं, लेकिन ज़रूरी hyperparameter tuning के साथ training संभव है
Experiment 4: Learning the G with colors
- उद्देश्य
- 3-channel RGB सहित 16x16 color image को 15 steps में generate कर, multi-channel pattern generation को verify करना
- सेटअप
- 64-bit state (पहले 3 channels RGB के रूप में उपयोग, हर channel 0 या 1)
- Perception में 4 kernels (हर एक [8, 4, 2]), Update में 11 layers (पहली 8 layers में 512 gates, उसके बाद [256, 128, 64])
- target image 16x16 G pattern था, जिसमें 8 colors में से एक-एक color भरा गया था
- परिणाम
- loss लगभग 0 तक train हुआ, और 15 steps के बाद target color G को सटीक रूप से reproduce किया गया
- circuit में TRUE और FALSE gates का उपयोग अधिक था, और OR gate खास तौर पर उभरा
Summary and Discussion
- क्या किया गया
- DiffLogic CA नाम का पूरी तरह discrete लेकिन trainable CA model प्रस्तावित किया गया
- Game of Life जैसे classical rules को replicate किया गया, और checkerboard, lizard, color G जैसे patterns generate करने की क्षमता दिखाई गई
- discrete logic circuits पर आधारित होने के कारण intuitive interpretation और hardware efficiency की उम्मीद की जा सकती है
- महत्त्व
- यह सिद्ध किया गया कि NCA में दिखने वाले self-organizing patterns को discrete logic gates के आधार पर भी सीखा जा सकता है
- damage recovery और asynchronous updates जैसे गुणों को देखते हुए, distributed और fault-tolerant (robust) computing में इसके applications की संभावना अधिक है
- सीमाएँ और आगे की चुनौतियाँ
- complex images या patterns की training में उचित hyperparameter tuning की आवश्यकता होती है
- LSTM-प्रकार के gates या state को कुशलता से भूलने वाली संरचनाओं की खोज करके, और अधिक समृद्ध pattern formation संभव बनाई जा सकती है
- circuit scale optimization और training stabilization जैसी दिशाओं में इसे आगे बढ़ाया जा सकता है
- निष्कर्ष
- DiffLogic CA, Programmable Matter या Computronium जैसी सैद्धांतिक distributed computing दिशा की ओर जाने वाला एक promising approach है
- यह पूरी तरह discrete होते हुए भी trainable है, इसलिए भविष्य के distributed systems की नींव बनने की क्षमता रखता है
1 टिप्पणियां
Hacker News राय