मेरा Python कोड एक neural network है

• इंसान spaghetti code को मैनेज करने में अच्छे नहीं होते
• रिसर्च प्रोजेक्ट्स में अक्सर ऐसे प्रोग्राम लिखने पड़ते हैं जो raw data से जानकारी निकालें
• डेटा किसी साफ़-सुथरी specification का पालन नहीं करता
• उदाहरण:
  • न्यूज़ आर्टिकल्स से कंपनियों और अधिकारियों की पहचान करना
  • सार्वजनिक procurement contracts को service type के अनुसार label करना
  • इंजीनियरों के बीच संदेशों में program code की पहचान करना

संदेशों में program code का पता लगाना

• code review के दौरान यह समस्या हल करना कि कोई संदेश program code को refer करता है या नहीं
• उदाहरण संदेश:
  • LGTM with render_ipa_alloc()
  • If the FTPSACK flag is set, then use a prespecified value
  • AFAICT there is nothing else to check (unless you can think of something)
  • Actually, debug_error() doesn’t return NULL, so we should use IS_ERROR() here
  • This fails to build on aarch64 even though it works without issue on amd64
  • I’ve added if (err) goto cleanup; but the code still leaks

निर्णय नियम के आइडिया

• सरल नियमों का उपयोग करके program code और सामान्य English में फर्क करने का तरीका
• नियम:
  1. जिस शब्द के बाद parentheses हों, वह code है
  2. सभी uppercase शब्द code हैं
  3. गैर-English शब्द code हैं
• हर नियम के फायदे और नुकसान:
  • नियम 1: सरल है, लेकिन स्पष्ट positive cases छूट जाते हैं
  • नियम 2: uppercase acronyms को program code के रूप में गलत classify करता है
  • नियम 3: engineering terms को program code के रूप में गलत classify करता है

हाथ से लिखा algorithm

• यह निष्कर्ष कि एक सरल algorithm काफ़ी अच्छा काम कर सकता है
• दो चरणों में तय करना कि संदेश में code है या नहीं:
  1. preprocessing: संदेश को token sequence में बदलना
  2. inference: token sequence पर नियम लागू करके तय करना कि उसमें code है या नहीं
• Python में implemented उदाहरण:

  from dataclasses import dataclass  
  
  Token = str  
  
  @dataclass  
  class State:  
      previous_was_identifier: bool = False  
      previous_was_open_paren: bool = False  
      previous_previous_was_identifier: bool = False  
      seen_code: bool = False  
  
  def contains_code(tokens: Iterable[Token]) -> bool:  
      state = State()  
      for token in tokens:  
          state = process(state, token)  
      return state.seen_code  
  
  def process(state: State, token: Token) -> State:  
      if state.seen_code:  
          return state  
      if (token == "close_paren" and state.previous_was_open_paren and state.previous_previous_was_identifier):  
          state.seen_code = True  
          return state  
      state.previous_previous_was_identifier = state.previous_was_identifier  
      state.previous_was_identifier = token in ("all_caps_identifier", "underscore_identifier", "misc_identifier")  
      state.previous_was_open_paren = token == "open_paren"  
      return state  
  

neural network की मदद

• contains_code और process को state machine के रूप में RNN में encode किया जा सकता है
• RNN का उपयोग करके बेहतर algorithm खोजा जा सकता है

सामान्य आइडिया

• RNN conditional probability का approximation करता है
• हर token के लिए state vector की गणना की जाती है
• final state के आधार पर संदेश को classify किया जाता है

गणित की नज़र से Python code

• यह समझाना कि RNN नियम 1 को कैसे encode करता है
• हर token को binary vector के रूप में represent करना
• hidden state की गणना करके नियम लागू करना

network training

• RNN को train करने के लिए activation function को ReLU में बदलना
• PyTorch का उपयोग करके training संभव है

अधिक कुशल implementation वाली architecture

• PyTorch में उपलब्ध Elman RNN जैसी architectures का उपयोग
• Elman RNN में हर hidden layer input के रूप में पिछली layer और current layer दोनों का उपयोग करती है

अधिक स्थिर gradients वाली architecture

• लंबे संदेशों में gradients शून्य के क़रीब पहुँच जाते हैं, जिससे समस्या होती है
• GRU या LSTM जैसी architectures बेहतर performance दिखा सकती हैं

data-centric अनुशासन

• RNN spaghetti code को बेहतर तरीके से संभालते हैं
• data-centric अनुशासन लागू करके समस्या को अधिक स्पष्ट बनाया जा सकता है

GN⁺ की राय

• यह लेख RNN का उपयोग करके जटिल समस्याएँ हल करने का तरीका अच्छी तरह समझाता है
• RNN का उपयोग करने से code maintenance आसान हो जाता है
• PyTorch जैसे tools की मदद से कुशल implementation संभव है
• GRU या LSTM जैसी architectures पर विचार करने की ज़रूरत है
• data-centric approach समस्या समाधान में उपयोगी है

[GN⁺]

Hacker News राय

• यह लेख testing या training data पर ज़्यादा बात नहीं करता

  • कोड समझ में आता है, ऐसा सोचने की वजह यह है कि हमने generalized properties को अनौपचारिक रूप से साबित किया है
  • neural network के मामले में समस्या यह है कि नए input पर यह कैसे generalize करेगा, यह पता नहीं होता
  • अगर properties को अच्छी तरह परिभाषित किया जा सके, तो property-based tests लिखकर बहुत सारा test data बनाया जा सकता है
  • यह proof नहीं है, लेकिन एक शुरुआत हो सकती है
  • spaghetti code या neural network पर निर्भर रहना कुछ हद तक समान हो सकता है
  • neural network को train करने के बजाय property-based tests लिखे जा सकते हैं
  • फिर भी कोड पर ज़्यादा भरोसा होगा, क्योंकि उसे debug किया जा सकता है

• अगर इस लेख को practical काम करने के लिए neural network बनाने के तरीके के रूप में पढ़ें, तो यह दिलचस्प है

  • लेखक arbitrary input को parse करने की कठिन समस्या से जूझते हैं
  • इसे हल करने के लिए neural network का सुझाव दिया गया है, लेकिन इसे समझना अब भी कठिन है
  • पढ़ने में कठिन कोड की तुलना में समझ में आने वाला कोड बेहतर हो सकता है

• neural network के लिए Universal Approximation Theorem मौजूद है

  • लेकिन ऐसा कोई theorem नहीं है जो कहे कि इन approximations को सीखा जा सकता है

• यह लेख RNN से जुड़े गहरे mathematical concepts पर बात करता है, लेकिन दिलचस्प विचार भी देता है

  • input string को character level पर process करने वाला approach शक्तिशाली है
  • पतली input-output logic लिखी जाती है और बाकी algorithm संभाल लेता है

• कुछ लोगों की राय है कि क्या RNN को transformer ने पूरी तरह replace कर दिया है

• Genetic Programming को देखना उपयोगी हो सकता है

  • इसमें math की ज़रूरत नहीं होती, और program को AST के रूप में recombine करके optimize किया जाता है
  • क्या optimize करना है, यह चुना जा सकता है (जैसे speed, program length, complex structure को कम करना आदि)

• यह लेख RNN को एक learning experience के रूप में लेता है, और PyTorch के RNN से तुलना करता है

  • यह सवाल उठाया गया है कि network में तीन hidden layers और जोड़ने की ज़रूरत क्यों है

• RNN arbitrary computation कर सकता है, लेकिन यह practical नहीं है

  • यह लेख state machine को सीखने के तरीके पर है, और Python के वास्तविक semantics को सीखना कठिन है

• कुछ लोगों का मानना है कि neural network धीरे-धीरे code जैसा दिखने लगेगा

  • MOE style model को function calls में बदलने का तरीका अगला बड़ा innovation हो सकता है