टेंसरफ़्लो:: ऑप्स:: टेंसरअरेग्रैड

#include <data_flow_ops.h>

दिए गए हैंडल में मानों के ग्रेडिएंट्स को संग्रहीत करने के लिए एक TensorArray बनाता है।

सारांश

यदि दिया गया TensorArray ग्रेडिएंट पहले से मौजूद है, तो इसका एक संदर्भ लौटाता है।

इसके डायनामिक आकार ध्वज को अक्षम करके मूल TensorArray के आकार को लॉक कर देता है।

इनपुट फ़्लो_इन के बारे में एक नोट:

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

गतिशील रूप से आकार वाले TensorArrays के मामले में, ग्रेडिएंट गणना केवल उन रीड ऑपरेशंस पर की जानी चाहिए जो सभी राइट्स निष्पादित होने के बाद ही प्रवाह के माध्यम से जंजीर में बंधे होते हैं। इस तरह जब इस ऑपरेशन को कॉल किया जाता है तो फॉरवर्ड TensorArray का अंतिम आकार ज्ञात हो जाता है।

स्रोत विशेषता के बारे में एक नोट:

TensorArray ग्रेडिएंट कॉल एक संचायक TensorArray ऑब्जेक्ट का उपयोग करते हैं। यदि एकाधिक ग्रेडिएंट की गणना की जाती है और एक ही सत्र में चलाया जाता है, तो एकाधिक ग्रेडिएंट नोड गलती से एक ही संचायक TensorArray के माध्यम से प्रवाहित हो सकते हैं। यह दोहरी गणना करता है और आम तौर पर TensorArray ग्रेडिएंट प्रवाह को तोड़ देता है।

समाधान यह पहचानना है कि इस विशेष TensorArray ग्रेडिएंट को कौन सा ग्रेडिएंट कॉल किया जा रहा है। यह इनपुट ग्रेडिएंट Tensor के नाम से एक अद्वितीय स्ट्रिंग (उदाहरण के लिए "ग्रेडिएंट्स", "ग्रेडिएंट्स_1", ...) की पहचान करके किया जाता है। यहां TensorArray ग्रेडिएंट ऑब्जेक्ट (विशेषता source ) बनाते समय इस स्ट्रिंग का उपयोग प्रत्यय के रूप में किया जाता है।

निर्माण/लुकअप करते समय विशेषता source अग्रेषित TensorArray के नाम में एक प्रत्यय के रूप में जोड़ा जाता है, ताकि प्रत्येक अलग ग्रेडिएंट गणना को अपना स्वयं का TensorArray संचायक मिल सके।

तर्क:

  • स्कोप: एक स्कोप ऑब्जेक्ट
  • हैंडल: TensorArray को आगे बढ़ाने का हैंडल।
  • प्रवाह_इन: एक फ्लोट स्केलर जो संचालन की उचित श्रृंखला को लागू करता है।
  • स्रोत: ग्रेडिएंट सोर्स स्ट्रिंग, जिसका उपयोग यह तय करने के लिए किया जाता है कि कौन सा ग्रेडिएंट TensorArray लौटना है।

रिटर्न:

  • Output ग्रेड_हैंडल
  • Output फ्लो_आउट

निर्माता और विध्वंसक

TensorArrayGrad (const :: tensorflow::Scope & scope, :: tensorflow::Input handle, :: tensorflow::Input flow_in, StringPiece source)

सार्वजनिक गुण

flow_out
grad_handle
operation

सार्वजनिक गुण

प्रवाह_बाहर 

::tensorflow::Output flow_out

grad_handle 

::tensorflow::Output grad_handle

संचालन 

Operation operation

सार्वजनिक समारोह

टेंसरअरेग्रैड

 TensorArrayGrad(
  const ::tensorflow::Scope & scope,
  ::tensorflow::Input handle,
  ::tensorflow::Input flow_in,
  StringPiece source
)