TensorFlow कोड शैली गाइड

संग्रह की मदद से व्यवस्थित रहें अपनी प्राथमिकताओं के आधार पर, कॉन्टेंट को सेव करें और कैटगरी में बांटें.

अजगर की शैली

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

पाइलिंट

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

$ pip install pylint

TensorFlow source कोड रूट डायरेक्टरी से pylint साथ फाइल चेक करने के लिए:

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

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

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

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

C ++ कोडिंग स्टाइल

TensorFlow C ++ कोड में परिवर्तन Google C ++ स्टाइल गाइड और TensorFlow विशिष्ट शैली विवरण के अनुरूप होना चाहिए। अपने C / C ++ परिवर्तनों की जाँच करने के लिए 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
  • Tensor तर्कों में या तो एक एकल टेंसर होना चाहिए या टेंसर्स का पुनरावृत्ति होना चाहिए। यही है, "Tensor या Tensors की सूची" बहुत व्यापक है। देखें assert_proper_iterable
  • यदि वे तर्क के रूप में परिचालनों को ले जाते हैं, तो यदि वे C ++ ऑपरेशन का उपयोग कर रहे हैं, तो गैर- convert_to_tensor को convert_to_tensor में बदलने के लिए convert_to_tensor को कॉल करें। ध्यान दें कि दलीलों को अभी भी प्रलेखन में एक विशिष्ट dtype के Tensor ऑब्जेक्ट के रूप में वर्णित किया गया है।
  • प्रत्येक पायथन ऑपरेशन में एक name_scope होना चाहिए। जैसा कि नीचे देखा गया है, एक स्ट्रिंग के रूप में सेशन का नाम पास करें।
  • संचालन में एक व्यापक अजगर टिप्पणी होनी चाहिए जिसमें आर्ग्स और रिटर्न घोषणाएं होती हैं जो प्रत्येक मूल्य के प्रकार और अर्थ दोनों की व्याख्या करती हैं। विवरण में संभावित आकार, dtypes या रैंक निर्दिष्ट किए जाने चाहिए। प्रलेखन विवरण देखें।
  • बढ़ी हुई प्रयोज्यता के लिए, उदाहरण अनुभाग में सेशन के आउटपुट / आउटपुट के साथ उपयोग का एक उदाहरण शामिल करें।
  • tf.Tensor.eval या tf.Session.run स्पष्ट उपयोग करने से बचें। उदाहरण के लिए, तर्क लिखने के लिए जो टेन्सर मूल्य पर निर्भर करता है, टेन्सरफ्लो नियंत्रण प्रवाह का उपयोग करें। वैकल्पिक रूप से, ऑपरेशन को केवल तभी चलाएं जब उत्सुक निष्पादन सक्षम हो ( 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')