टेंसरफ़्लो:: दायरा

#include <scope.h>

एक Scope ऑब्जेक्ट संबंधित TensorFlow ऑप्स के एक सेट का प्रतिनिधित्व करता है जिसमें सामान्य नाम उपसर्ग जैसे समान गुण होते हैं।

सारांश

स्कोप ऑब्जेक्ट TensorFlow Op गुणों के लिए एक कंटेनर है। ऑप कंस्ट्रक्टर्स को अनिवार्य प्रथम तर्क के रूप में एक स्कोप ऑब्जेक्ट मिलता है और निर्मित ऑप ऑब्जेक्ट में गुण प्राप्त करता है।

एक सरल उदाहरण:

using namespace ops;
Scope root = Scope::NewRootScope();
auto c1 = Const(root, { {1, 1} });
auto m = MatMul(root, c1, { {41}, {1} });
GraphDef gdef;
Status s = root.ToGraphDef(&gdef);
if (!s.ok()) { ... }

दायरा पदानुक्रम:

स्कोप वर्ग विभिन्न <> फ़ंक्शन प्रदान करता है जो एक नया दायरा बनाते हैं। नए दायरे में आम तौर पर एक संपत्ति बदल जाती है जबकि अन्य संपत्तियां मूल दायरे से विरासत में मिलती हैं। NewSubScope(name) विधि दायरे के भीतर बनाए गए ऑप्स के लिए नामों के उपसर्ग में name जोड़ती है, और WithOpName() प्रत्यय को बदल देती है जो अन्यथा ऑप के प्रकार के लिए डिफ़ॉल्ट होता है।

नाम उदाहरण:

Scope root = Scope::NewRootScope();
Scope linear = root.NewSubScope("linear");
// W will be named "linear/W"
auto W = Variable(linear.WithOpName("W"),
                  {2, 2}, DT_FLOAT);
// b will be named "linear/b_3"
int idx = 3;
auto b = Variable(linear.WithOpName("b_", idx),
                  {2}, DT_FLOAT);
auto x = Const(linear, {...});  // name: "linear/Const"
auto m = MatMul(linear, x, W);  // name: "linear/MatMul"
auto r = BiasAdd(linear, m, b); // name: "linear/BiasAdd"

दायरा जीवनकाल:

scope::NewRootScope को कॉल करके एक नया स्कोप बनाया जाता है। यह कुछ संसाधन बनाता है जो इस दायरे से प्राप्त सभी चाइल्ड स्कोप द्वारा प्रत्यक्ष या परिवर्तनीय रूप से साझा किए जाते हैं। उदाहरण के लिए, एक नया स्कोप एक नया ग्राफ़ ऑब्जेक्ट बनाता है जिसमें ऑपरेशंस तब जोड़े जाते हैं जब नए स्कोप या उसके बच्चों का उपयोग एक ऑप कंस्ट्रक्टर द्वारा किया जाता है। नए स्कोप में एक स्टेटस ऑब्जेक्ट भी है जिसका उपयोग किसी भी चाइल्ड स्कोप पर बुलाए गए ओप-कंस्ट्रक्टर फ़ंक्शंस द्वारा त्रुटियों को इंगित करने के लिए किया जाएगा। ऑप-कंस्ट्रक्टर फ़ंक्शंस को ऑप के निर्माण के लिए आगे बढ़ने से पहले ok() विधि को कॉल करके स्कोप की स्थिति की जांच करनी होती है।

धागा सुरक्षा:

Scope ऑब्जेक्ट थ्रेड-सुरक्षित नहीं है। थ्रेड्स एक ही Scope ऑब्जेक्ट पर ऑप-कन्स्ट्रक्टर फ़ंक्शंस को समवर्ती रूप से कॉल नहीं कर सकते हैं।

निर्माता और विध्वंसक
Scope (const Scope & other)
~Scope ()

सार्वजनिक समारोह
ClearColocation () const	Scope सभी सह-स्थान बाधाओं को साफ़ करें।
ColocateWith (const Operation & op) const	Scope एक नया दायरा लौटाएँ.
ColocateWith (const Output & out) const	Scope उपरोक्त के लिए सुविधा कार्य।
ExitOnError () const	Scope एक नया दायरा लौटाएँ.
GetCompositeOpScopes (const string & composite_op_name) const	CompositeOpScopes
GetUniqueNameForOp (const string & default_name) const	string यदि कोई ऑप नाम निर्दिष्ट नहीं किया गया है, तो default_name का उपयोग करके एक अद्वितीय नाम लौटाएँ।
NewSubScope (const string & child_scope_name) const	Scope एक नया दायरा लौटाएँ.
ToGraphDef (GraphDef *gdef) const	Status यदि स्थिति() स्थिति::ओके() है, तो इस दायरे में संग्रहीत ग्राफ़ ऑब्जेक्ट को ग्राफ़डिफ प्रोटो में कनवर्ट करें और स्थिति::ओके() लौटाएं।
UpdateStatus (const Status & s) const	void इस दायरे पर स्थिति अद्यतन करें.
WithAssignedDevice (const string & assigned_device) const	Scope एक नया दायरा लौटाता है.
WithControlDependencies (const gtl::ArraySlice< Operation > & control_deps) const	Scope एक नया दायरा लौटाएँ.
WithControlDependencies (const Output & control_dep) const	Scope उपरोक्त के समान, लेकिन control_dep आउटपुट उत्पन्न करने वाले ऑपरेशन पर नियंत्रण निर्भरता जोड़ने के लिए सुविधाजनक है।
WithDevice (const string & device) const	Scope एक नया दायरा लौटाएँ.
WithKernelLabel (const string & kernel_label) const	Scope एक नया दायरा लौटाएँ.
WithNoControlDependencies () const	Scope एक नया दायरा लौटाएँ.
WithOpName (Ty... fragments) const	Scope एक नया दायरा लौटाएँ.
WithXlaCluster (const string & xla_cluster) const	Scope एक नया दायरा लौटाता है.
control_deps () const	const std::vector< Operation > &
graph () const	Graph *
graph_as_shared_ptr () const	std::shared_ptr< Graph >
ok () const	bool
operator= (const Scope & other)	Scope &
status () const	Status

सार्वजनिक स्थैतिक कार्य
NewRootScope ()	Scope एक नया दायरा लौटाएँ.

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

स्पष्ट स्थान

Scope ClearColocation() const 

सभी सह-स्थान बाधाओं को साफ़ करें।

कोलोकेटविथ

Scope ColocateWith(
  const Operation & op
) const 

एक नया दायरा लौटाएँ.

लौटाए गए दायरे में बनाए गए सभी ऑप्स उस डिवाइस पर सह-स्थित किए जाएंगे जहां ऑप रखा गया है। ध्यान दें: इस फ़ंक्शन का उद्देश्य केवल उपकरणों पर ऑप्स के प्लेसमेंट को नियंत्रित करने के लिए आंतरिक पुस्तकालयों का उपयोग करना है। सार्वजनिक उपयोग को प्रोत्साहित नहीं किया जाता है क्योंकि डिवाइस प्लेसमेंट का कार्यान्वयन परिवर्तन के अधीन है।

कोलोकेटविथ

Scope ColocateWith(
  const Output & out
) const 

उपरोक्त के लिए सुविधा कार्य।

एक्ज़िटऑनत्रुटि

Scope ExitOnError() const 

एक नया दायरा लौटाएँ.

ऑप-कन्स्ट्रक्टर स्कोप पर स्थिति सेट करने के बजाय, लौटाए गए स्कोप को स्कोप तर्क के रूप में लेते हुए त्रुटि का पता चलते ही बाहर निकल जाएगा।

GetCompositeOpScopes

CompositeOpScopes GetCompositeOpScopes(
  const string & composite_op_name
) const 

GetUniqueNameForOp

string GetUniqueNameForOp(
  const string & default_name
) const 

यदि कोई ऑप नाम निर्दिष्ट नहीं किया गया है, तो default_name का उपयोग करके एक अद्वितीय नाम लौटाएँ।

न्यूसबस्कोप

Scope NewSubScope(
  const string & child_scope_name
) const 

एक नया दायरा लौटाएँ.

इस दायरे से बनाए गए ऑप्स में उपसर्ग के रूप में name/child_scope_name होगा। वर्तमान दायरे में वास्तविक नाम अद्वितीय होगा. अन्य सभी संपत्तियाँ वर्तमान दायरे से विरासत में मिली हैं। यदि child_scope_name खाली है, तो / हटा दिया गया है।

दायरा

 Scope(
  const Scope & other
)

ToGraphDef

Status ToGraphDef(
  GraphDef *gdef
) const 

यदि स्थिति() स्थिति::ओके() है, तो इस दायरे में संग्रहीत ग्राफ़ ऑब्जेक्ट को ग्राफ़डिफ प्रोटो में कनवर्ट करें और स्थिति::ओके() लौटाएं।

अन्यथा, ग्राफ़डेफ़ रूपांतरण किए बिना त्रुटि स्थिति लौटाएँ।

अद्यतन स्थिति

void UpdateStatus(
  const Status & s
) const 

इस दायरे पर स्थिति अद्यतन करें.

नोट: स्टेटस ऑब्जेक्ट इस दायरे के सभी बच्चों के बीच साझा किया जाता है। यदि परिणामी स्थिति स्टेटस::ओके() नहीं है और इस दायरे पर exit_on_error_ सेट है, तो यह फ़ंक्शन LOG(FATAL) को कॉल करके बाहर निकलता है।

असाइन्डडिवाइस के साथ

Scope WithAssignedDevice(
  const string & assigned_device
) const 

एक नया दायरा लौटाता है.

लौटाए गए दायरे में बनाए गए सभी ऑप्स का असाइन किया गया डिवाइस assigned_device पर सेट होगा।

नियंत्रणनिर्भरता के साथ

Scope WithControlDependencies(
  const gtl::ArraySlice< Operation > & control_deps
) const 

एक नया दायरा लौटाएँ.

लौटाए गए दायरे के भीतर बनाए गए सभी ऑप्स में नियंत्रण निर्भरता के रूप में control_deps वेक्टर में संचालन का संघ और वर्तमान दायरे की नियंत्रण निर्भरताएं होंगी।

नियंत्रणनिर्भरता के साथ

Scope WithControlDependencies(
  const Output & control_dep
) const 

उपरोक्त के समान, लेकिन control_dep आउटपुट उत्पन्न करने वाले ऑपरेशन पर नियंत्रण निर्भरता जोड़ने के लिए सुविधाजनक है।

डिवाइस के साथ

Scope WithDevice(
  const string & device
) const 

एक नया दायरा लौटाएँ.

लौटाए गए दायरे में बनाए गए सभी ऑप्स में डिवाइस फ़ील्ड 'डिवाइस' पर सेट होगी।

कर्नेल लेबल के साथ

Scope WithKernelLabel(
  const string & kernel_label
) const 

एक नया दायरा लौटाएँ.

नए दायरे के साथ बनाए गए सभी ऑप्स में उनके '_कर्नेल' विशेषता के मान के रूप में कर्नेल_लेबल होगा;

बिना किसी नियंत्रण निर्भरता के

Scope WithNoControlDependencies() const 

एक नया दायरा लौटाएँ.

लौटाए गए दायरे में बनाए गए सभी ऑप्स की अन्य ऑपरेशनों पर कोई नियंत्रण निर्भरता नहीं होगी।

ओपनेम के साथ

Scope WithOpName(
  Ty... fragments
) const 

एक नया दायरा लौटाएँ.

लौटाए गए दायरे में बनाए गए सभी ऑप्स में फॉर्म name/StrCat(fragments...)[_suffix] के नाम होंगे

एक्सलाक्लस्टर के साथ

Scope WithXlaCluster(
  const string & xla_cluster
) const 

एक नया दायरा लौटाता है.

लौटाए गए दायरे में बनाए गए सभी ऑप्स की _XlaCluster विशेषता xla_cluster पर सेट होगी।

नियंत्रण_डिप्स

const std::vector< Operation > & control_deps() const 

ग्राफ

Graph * graph() const 

ग्राफ़_as_shared_ptr

std::shared_ptr< Graph > graph_as_shared_ptr() const 

ठीक है

bool ok() const 

ऑपरेटर=

Scope & operator=(
  const Scope & other
)

स्थिति

Status status() const 

~स्कोप

 ~Scope()

सार्वजनिक स्थैतिक कार्य

न्यूरूटस्कोप

Scope NewRootScope()

एक नया दायरा लौटाएँ.

यह एक नया ग्राफ़ बनाता है और इस ग्राफ़ में निर्मित सभी ऑपरेशनों को लौटाए गए ऑब्जेक्ट को "रूट" स्कोप के रूप में उपयोग करना चाहिए।