TensorFlow कोड स्टाइल गाइड

पायथन शैली

पीईपी 8 पायथन स्टाइल गाइड का पालन करें, सिवाय इसके कि टेन्सरफ्लो 4 के बजाय 2 स्थानों का उपयोग करता है। कृपया Google पायथन स्टाइल गाइड का पालन करें, और अपने पायथन परिवर्तनों की जांच करने के लिए पिलिंट का उपयोग करें।

पाइलिंट

pylint स्थापित करने के लिए:

$ pip install pylint

TensorFlow स्रोत कोड रूट निर्देशिका से pylint वाली फ़ाइल की जाँच करने के लिए:

$ pylint --rcfile=tensorflow/tools/ci_build/pylintrc tensorflow/python/keras/losses.py

समर्थित पायथन संस्करण

समर्थित पायथन संस्करणों के लिए, TensorFlow इंस्टॉलेशन गाइड देखें।

आधिकारिक और समुदाय समर्थित बिल्ड के लिए TensorFlow निरंतर निर्माण स्थिति देखें।

C++ कोडिंग शैली

TensorFlow C++ कोड में परिवर्तन Google C++ स्टाइल गाइड और TensorFlow विशिष्ट शैली विवरण के अनुरूप होना चाहिए। अपने सी/सी++ परिवर्तनों की जांच करने के लिए clang-format उपयोग करें।

Ubuntu 16+ पर इंस्टॉल करने के लिए, करें:

$ apt-get install -y clang-format

आप निम्नलिखित के साथ C/C++ फ़ाइल का प्रारूप जांच सकते हैं:

$ clang-format <my_cc_file> --style=google > /tmp/my_cc_file.cc
$ diff <my_cc_file> /tmp/my_cc_file.cc

अन्य भाषाएं

• गूगल जावा स्टाइल गाइड
• गूगल जावास्क्रिप्ट स्टाइल गाइड
• गूगल शैल स्टाइल गाइड
• गूगल ऑब्जेक्टिव-सी स्टाइल गाइड

TensorFlow कन्वेंशन और विशेष उपयोग

पायथन ऑपरेशन

TensorFlow ऑपरेशन एक फ़ंक्शन है, जो दिए गए इनपुट टेंसर आउटपुट टेंसर लौटाता है (या ग्राफ़ बनाते समय ग्राफ़ में एक ऑप जोड़ता है)।

• पहला तर्क टेंसर होना चाहिए, उसके बाद बुनियादी पायथन पैरामीटर होना चाहिए। अंतिम तर्क None के डिफ़ॉल्ट मान वाला name है।
• टेन्सर तर्क या तो एकल टेन्सर या टेन्सर का पुनरावर्तनीय होना चाहिए। अर्थात्, "टेंसर या टेन्सर की सूची" बहुत व्यापक है। assert_proper_iterable देखें।
• जो ऑपरेशन टेंसर को तर्क के रूप में लेते हैं, उन्हें गैर-टेंसर इनपुट को टेंसर में बदलने के लिए convert_to_tensor कॉल करना चाहिए, यदि वे C++ ऑपरेशन का उपयोग कर रहे हैं। ध्यान दें कि दस्तावेज़ में तर्कों को अभी भी एक विशिष्ट dtype के Tensor ऑब्जेक्ट के रूप में वर्णित किया गया है।
• प्रत्येक पायथन ऑपरेशन में एक name_scope होना चाहिए। जैसा कि नीचे देखा गया है, ऑप का नाम एक स्ट्रिंग के रूप में पास करें।
• ऑपरेशंस में आर्ग्स और रिटर्न्स घोषणाओं के साथ एक व्यापक पायथन टिप्पणी होनी चाहिए जो प्रत्येक मान के प्रकार और अर्थ दोनों को समझाए। विवरण में संभावित आकार, प्रकार या रैंक निर्दिष्ट किए जाने चाहिए। दस्तावेज़ीकरण विवरण देखें.
• बढ़ी हुई प्रयोज्यता के लिए, उदाहरण अनुभाग में ऑप के इनपुट/आउटपुट के साथ उपयोग का एक उदाहरण शामिल करें।
• tf.Tensor.eval या tf.Session.run का स्पष्ट उपयोग करने से बचें। उदाहरण के लिए, Tensor मान पर निर्भर तर्क लिखने के लिए, TensorFlow नियंत्रण प्रवाह का उपयोग करें। वैकल्पिक रूप से, ऑपरेशन को केवल तभी चलाने तक सीमित रखें जब उत्सुक निष्पादन सक्षम हो ( tf.executing_eagerly() )।

उदाहरण:

def my_op(tensor_in, other_tensor_in, my_param, other_param=0.5,
          output_collections=(), name=None):
  """My operation that adds two tensors with given coefficients.

  Args:
    tensor_in: `Tensor`, input tensor.
    other_tensor_in: `Tensor`, same shape as `tensor_in`, other input tensor.
    my_param: `float`, coefficient for `tensor_in`.
    other_param: `float`, coefficient for `other_tensor_in`.
    output_collections: `tuple` of `string`s, name of the collection to
                        collect result of this op.
    name: `string`, name of the operation.

  Returns:
    `Tensor` of same shape as `tensor_in`, sum of input values with coefficients.

  Example:
    >>> my_op([1., 2.], [3., 4.], my_param=0.5, other_param=0.6,
              output_collections=['MY_OPS'], name='add_t1t2')
    [2.3, 3.4]
  """
  with tf.name_scope(name or "my_op"):
    tensor_in = tf.convert_to_tensor(tensor_in)
    other_tensor_in = tf.convert_to_tensor(other_tensor_in)
    result = my_param * tensor_in + other_param * other_tensor_in
    tf.add_to_collection(output_collections, result)
    return result

उपयोग:

output = my_op(t1, t2, my_param=0.5, other_param=0.6,
               output_collections=['MY_OPS'], name='add_t1t2')