टेन्सफोर्लो

Question

में एक अनुकूलक कैसे बनाएं I Tensorflow पर अपने नेटवर्क के लिए एक नया अनुकूलन एल्गोरिदम लिखना चाहता हूं। मैं Levenberg Marquardt optimization algorithm को लागू करने की आशा करता हूं, जिसे अब टीएफ एपीआई से बाहर रखा गया है। मुझे कस्टम ऑप्टिमाइज़र लिखने के तरीके पर खराब दस्तावेज मिला, इसलिए मैं पूछता हूं कि कोई मेरी सलाह दे सकता है या नहीं। धन्यवाद।

Answer 1

एक अनुकूलक का सबसे सरल उदाहरण शायद gradient descent optimizer है। यह दिखाता है कि कैसे कोई मूल optimizer class का उदाहरण बनाता है। ऑप्टिमाइज़र बेस क्लास प्रलेखन बताता है कि विधियां क्या करती हैं।

ऑप्टिमाइज़र के पायथन पक्ष ग्राफ में नए नोड्स जोड़ते हैं जो गणना और ग्रेडियेंट को वापस प्रसारित करते हैं। यह उन पैरामीटर की आपूर्ति करता है जो ओप को पास करते हैं और ऑप्टिमाइज़र के कुछ उच्च स्तरीय प्रबंधन करते हैं। फिर, आपको वास्तविक "लागू करें" सेशन की आवश्यकता है।

ओपीएस में एक अजगर और सी ++ घटक दोनों हैं। एक प्रशिक्षण सेशन लिखना एक ही (लेकिन विशेष) general process of adding an Op to TensorFlow के रूप में है।

प्रशिक्षण ओप्स की एक उदाहरण सेट के लिए जो ग्रेडियेंट की गणना और लागू करते हैं, python/training/training_ops.py देखें - यह वास्तविक प्रशिक्षण ओप के लिए पायथन गोंद है। ध्यान दें कि यहां कोड ज्यादातर आकार अनुमान के बारे में है - गणना C++ में होने वाली है।

ग्रेडियेंट्स को लागू करने के लिए वास्तविक गणित को एक ओप द्वारा संभाला जाता है (याद करते हुए, सामान्य रूप से, ओप्स सी ++ में लिखे जाते हैं)। इस मामले में, लागू ग्रेडियेंट ऑप्स को core/kernels/training_ops.cc में परिभाषित किया गया है। आप उदाहरण के लिए, देख सकते हैं, वहाँ में ApplyGradientDescentOp के कार्यान्वयन, एक functor ApplyGradientDescent का संदर्भ जो:

var.device(d) -= grad * lr(); 

Op खुद के कार्यान्वयन को जोड़ने-एक-op डॉक्स में वर्णित के रूप में किसी अन्य सेशन के कार्यान्वयन इस प्रकार है ।

Answer 2

Tensorflow सत्र चलाने से पहले, एक एक अनुकूलक नीचे के रूप में देखा शुरू करनी चाहिए:

# Gradient Descent 
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost) 

tf.train.GradientDescentOptimizer वर्ग GradientDescentOptimizer की एक वस्तु है और जैसा कि नाम से कहते हैं, यह ढाल वंश मूल एल्गोरिदम लागू करता है।

विधि को कम () पैरामीटर के रूप में एक "लागत" के साथ बुलाया जा रहा है और दो तरीकों compute_gradients() और फिर apply_gradients() के होते हैं।

अधिकांश (कस्टम) अनुकूलक कार्यान्वयन के लिए, विधि apply_gradients() को अनुकूलित करने की आवश्यकता है।

इस विधि (नया) अनुकूलक (वर्ग) है, जो हम पैदा करेगा पर निर्भर करता है, निम्न विधियों में लागू करने के लिए: _create_slots(), _prepare(), _apply_dense(), और _apply_sparse()।

• _create_slots() और _prepare() बना सकते हैं और इस तरह के गति के रूप में अतिरिक्त चर, आरंभ।

• _apply_dense(), और _apply_sparse() जो अद्यतन चर वास्तविक ऑप्स, को लागू।

ओपीएस आमतौर पर सी ++ में लिखे जाते हैं। स्वयं को C++ हेडर बदलने के बिना, आप अभी भी इन तरीकों के माध्यम से कुछ ओपीएस के एक अजगर आवरण को वापस कर सकते हैं। इस प्रकार यह किया जाता है:

def _create_slots(self, var_list): 
    # Create slots for allocation and later management of additional 
    # variables associated with the variables to train. 
    # for example: the first and second moments. 
    ''' 
    for v in var_list: 
     self._zeros_slot(v, "m", self._name) 
     self._zeros_slot(v, "v", self._name) 
    ''' 
def _apply_dense(self, grad, var): 
    #define your favourite variable update 
    # for example: 
    ''' 
    # Here we apply gradient descents by substracting the variables 
    # with the gradient times the learning_rate (defined in __init__) 
    var_update = state_ops.assign_sub(var, self.learning_rate * grad) 
    ''' 
    #The trick is now to pass the Ops in the control_flow_ops and 
    # eventually groups any particular computation of the slots your 
    # wish to keep track of: 
    # for example:  
    ''' 
    m_t = ...m... #do something with m and grad 
    v_t = ...v... # do something with v and grad 
    ''' 
    return control_flow_ops.group(*[var_update, m_t, v_t]) 

उदाहरण के साथ एक अधिक विस्तृत विवरण के लिए, इस ब्लॉग पोस्ट https://www.bigdatarepublic.nl/custom-optimizer-in-tensorflow/