30

मान लीजिए कि मैं एक कस्टम ऑप्टिमाइज़र क्लास लिखना चाहता हूं जो tf.kerasएपीआई (TensorFlow संस्करण> = 2.0 का उपयोग करके) के अनुरूप है । मैं यह करने के लिए प्रलेखित तरीके के बारे में उलझन में हूं कि कार्यान्वयन में क्या किया गया है।

tf.keras.optimizers.Optimizer राज्यों के लिए दस्तावेज ,

  ### Write a customized optimizer.
  If you intend to create your own optimization algorithm, simply inherit from
  this class and override the following methods:

    - resource_apply_dense (update variable given gradient tensor is dense)
    - resource_apply_sparse (update variable given gradient tensor is sparse)
    - create_slots (if your optimizer algorithm requires additional variables)

हालाँकि, वर्तमान tf.keras.optimizers.Optimizerकार्यान्वयन एक resource_apply_denseविधि को परिभाषित नहीं करता है , लेकिन यह एक निजी दिखने वाली विधि ठूंठ को परिभाषित करता है । इसी तरह, कोई विधि या विधि नहीं हैं , लेकिन एक विधि स्टब और एक विधि कॉल हैं ।_resource_apply_denseresource_apply_sparsecreate_slots_resource_apply_sparse_create_slots

आधिकारिक में tf.keras.optimizers.Optimizerउपवर्गों (का उपयोग कर tf.keras.optimizers.Adamएक उदाहरण के रूप में), देखते हैं _resource_apply_dense, _resource_apply_sparseऔर _create_slotsविधियों, और वहाँ प्रमुख अंडरस्कोर के बिना ऐसी कोई तरीके हैं।

वहाँ थोड़ा-कम-सरकारी में इसी तरह के अग्रणी अंडरस्कोर तरीके हैं tf.keras.optimizers.Optimizerउपवर्गों (जैसे, tfa.optimizers.MovingAverage: TensorFlow ऐड-ऑन से _resource_apply_dense, _resource_apply_sparse, _create_slots)।

मेरे लिए एक और उलझन की बात यह है कि कुछ TensorFlow Addons ऑप्टिमाइज़र भीapply_gradients विधि (जैसे tfa.optimizers.MovingAverage) को ओवरराइड करते हैं , जबकि tf.keras.optimizersऑप्टिमाइज़र ऐसा नहीं करते हैं।

इसके अलावा, मैंने देखा कि apply_gradientsविधि tf.keras.optimizers.Optimizerविधि कॉल करती है_create_slots , लेकिन बेस tf.keras.optimizers.Optimizerक्लास में _create_slotsविधि नहीं है । तो, ऐसा लगता है कि एक _create_slotsविधि को एक ऑप्टिमाइज़र उपवर्ग में परिभाषित किया जाना चाहिए यदि वह उपवर्ग ओवरराइड नहीं करता है apply_gradients।

प्रशन

उपवर्ग का सही तरीका क्या है tf.keras.optimizers.Optimizer ? विशेष रूप से,

क्या tf.keras.optimizers.Optimizerशीर्ष पर सूचीबद्ध दस्तावेज़ीकरण का तात्पर्य उन विधियों के प्रमुख-अंडरस्कोर संस्करणों को ओवरराइड करने से है, जिनका वे उल्लेख करते हैं (उदाहरण के लिए;_resource_apply_dense इसके बजाय resource_apply_dense)? यदि हां, तो क्या TensorFlow के भविष्य के संस्करणों में अपना व्यवहार बदलने वाले इन निजी-दिखने वाले तरीकों के बारे में कोई API गारंटी नहीं है? इन विधियों के हस्ताक्षर क्या हैं?
विधियों के apply_gradientsअतिरिक्त कोई ओवरराइड कब करेगा _apply_resource_[dense|sparse]?

संपादित करें। गिटहब पर खुला मुद्दा: # 36449

— आर्टेम माव्रिन
स्रोत

1

यह देवताओं के लिए एक प्रलेखन मुद्दे के रूप में रिपोर्ट करने के लिए कुछ हो सकता है। यह निश्चित रूप से उन तरीकों की तरह दिखता है जिन्हें ओवरराइड करने के लिए प्रलेखन में प्रारंभिक अंडरस्कोर शामिल होना चाहिए, लेकिन किसी भी मामले में, जैसे आप कहते हैं, उनके हस्ताक्षर और सटीक उद्देश्य के बारे में कोई जानकारी नहीं है। यह भी हो सकता है कि अंडरस्कोर (और डॉक्यूमेंटेड) के बिना विधि के नाम (जैसे के साथ get_config) जोड़े जाने की योजना है , लेकिन फिर वे अभी तक सार्वजनिक दस्तावेज में नहीं दिखना चाहिए ।

— jdehesa

हस्ताक्षरों के लिए, आप हमेशा घोषणा को देख सकते हैं, _resource_apply_denseया _resource_apply_sparseकार्यान्वित ऑप्टिमाइज़र में उनके उपयोग को देख सकते हैं। हालांकि यह नहीं हो सकता है, मुझे लगता है, स्थिरता की गारंटी के साथ सार्वजनिक एपीआई, मैं कहूंगा कि उनका उपयोग करना बहुत सुरक्षित है। उन्हें बस इस पहलू में बेहतर मार्गदर्शन देना चाहिए।

— jdehesa

मैं मानता हूं कि यह TensorFlow के साथ एक प्रलेखन मुद्दा है। क्या आपने tf Github repo में इसके लिए कोई मुद्दा बनाया था? यदि हां, तो क्या आप यहां लिंक साझा कर सकते हैं?

— *******

3

मैंने Kirs AdamW को सभी प्रमुख TF & Keras संस्करणों में लागू किया है - मैं आपको ऑप्टिमाइज़र्स_ v2.py की जांच करने के लिए आमंत्रित करता हूं । कई बिंदु:

आपको विरासत में प्राप्त करना चाहिए OptimizerV2, जो वास्तव में आप जो जुड़े हुए हैं; इसके लिए नवीनतम और वर्तमान आधार वर्ग है tf.kerasoptimizers
आप (1) में सही हैं - यह एक प्रलेखन गलती है; तरीके निजी हैं, क्योंकि वे सीधे उपयोगकर्ता द्वारा उपयोग किए जाने के लिए नहीं हैं।
apply_gradients(या कोई अन्य विधि) केवल तभी ओवरएड की जाती है, जब डिफ़ॉल्ट किसी दिए गए ऑप्टिमाइज़र के लिए आवश्यक चीज़ों को पूरा नहीं करता है; आपके लिंक किए गए उदाहरण में, यह मूल में सिर्फ एक-लाइनर एडऑन है
"तो, ऐसा लगता है कि एक _create_slotsआशावादी उपवर्ग में एक विधि को परिभाषित किया जाना चाहिए यदि वह उपवर्ग ओवरराइड नहीं करता है apply_gradients" - दोनों असंबंधित हैं; यह संयोग है।

बीच क्या अंतर है _resource_apply_denseऔर _resource_apply_sparse?

छिटपुट परतों के साथ लैटर सौदे - जैसे Embedding- और बाकी सब कुछ के साथ पूर्व; उदाहरण है ।

मुझे कब उपयोग करना चाहिए _create_slots()?

जब ट्रेन के tf.Variable एस को परिभाषित करना ; उदाहरण: वज़न के पहले और दूसरे क्रम के क्षण (जैसे एडम)। इसका उपयोग करता है add_slot()।

मुझे कब उपयोग करना चाहिए _set_hyper()?

बहुत ज्यादा, जब भी उपयोग न करें _create_slots(); यह वर्ग विशेषताओं को स्थापित करने जैसा है, लेकिन उपयोग में शुद्धता सुनिश्चित करने के लिए अतिरिक्त प्रीप्रोसेसिंग चरणों के साथ। तो पायथन int, float,tf.Tensor , tf.Variable, और अन्य शामिल हैं। (मुझे इसे केआरएएसडब्ल्यूडब्ल्यू में अधिक इस्तेमाल करना चाहिए)।

नोट : जबकि मेरे लिंक किए गए ऑप्टिमाइज़र सही ढंग से काम करते हैं और मूल के रूप में तेज़ होते हैं, कोड सर्वश्रेष्ठ TensorFlow प्रथाओं का पालन करता है और अभी भी तेज हो सकता है; मैं इसे "आदर्श संदर्भ" के रूप में अनुशंसित नहीं करता हूं। उदाहरण के लिए कुछ पायथन ऑब्जेक्ट्स (जैसे int) टेंसर्स होने चाहिए; eta_tएक के रूप में परिभाषित किया गया है tf.Variable, लेकिन तुरंत तरीकों tf.Tensorमें एक के रूप में _applyखत्म हो गया है। जरूरी नहीं कि कोई बड़ी बात हो, बस नवीनीकरण का समय नहीं मिला है।

— OverLordGoldDragon
स्रोत

2

हाँ, यह एक प्रलेखन त्रुटि प्रतीत होती है। पूर्ववर्ती अंडरस्कोर नाम ओवरराइड करने के लिए सही तरीके हैं। संबंधित गैर Keras अनुकूलक जो इन सभी परिभाषित किया गया है, लेकिन आधार वर्ग में लागू नहीं किया https://github.com/tensorflow/tensorflow/blob/master/tensorflow/python/training/optimizer.py

  def _create_slots(self, var_list):
    """Create all slots needed by the variables.
    Args:
      var_list: A list of `Variable` objects.
    """
    # No slots needed by default
    pass

  def _resource_apply_dense(self, grad, handle):
    """Add ops to apply dense gradients to the variable `handle`.
    Args:
      grad: a `Tensor` representing the gradient.
      handle: a `Tensor` of dtype `resource` which points to the variable
       to be updated.
    Returns:
      An `Operation` which updates the value of the variable.
    """
    raise NotImplementedError()

  def _resource_apply_sparse(self, grad, handle, indices):
    """Add ops to apply sparse gradients to the variable `handle`.
    Similar to `_apply_sparse`, the `indices` argument to this method has been
    de-duplicated. Optimizers which deal correctly with non-unique indices may
    instead override `_resource_apply_sparse_duplicate_indices` to avoid this
    overhead.
    Args:
      grad: a `Tensor` representing the gradient for the affected indices.
      handle: a `Tensor` of dtype `resource` which points to the variable
       to be updated.
      indices: a `Tensor` of integral type representing the indices for
       which the gradient is nonzero. Indices are unique.
    Returns:
      An `Operation` which updates the value of the variable.
    """
    raise NotImplementedError()

मैं नहीं जानता apply_dense। एक चीज के लिए, यदि आप इसे ओवरराइड करते हैं, तो कोड में उल्लेख किया गया है कि प्रति-प्रतिकृति डिस्ट्रीब्यूशनस्ट्रेगी खतरनाक हो सकती है "

    # TODO(isaprykin): When using a DistributionStrategy, and when an
    # optimizer is created in each replica, it might be dangerous to
    # rely on some Optimizer methods.  When such methods are called on a
    # per-replica optimizer, an exception needs to be thrown.  We do
    # allow creation per-replica optimizers however, because the
    # compute_gradients()->apply_gradients() sequence is safe.

— टायलर
स्रोत

कस्टम TensorFlow Keras अनुकूलक

प्रशन