🤜 📿 💆🏻 TensorFlow में सेंसर 🖐️ ✋🏾 👆🏾

Tensorflow में हेरफेर की गई मुख्य वस्तु दहाई है। टेंसर्स क्या हैं, टेंसर्स क्या हैं, उनके पास क्या गुण हैं और उनमें हेरफेर कैसे करें, टेंसोरफ्लो से ट्रांसलेशन गाइड पढ़ें।

TensorFlow, जैसा कि नाम से पता चलता है, टेनसर्स का उपयोग करके गणना को परिभाषित करने और प्रदर्शन करने के लिए एक मंच है। एक टेंसर वैक्टर और मैट्रिसेज़ से उच्च आयामों का एक सामान्यीकरण है। TensorFlow के अंदर, दसियों को मूल डेटा प्रकारों के n- आयामी सरणियों के रूप में दर्शाया जाता है।

एक TensorFlow कार्यक्रम लिखते समय, मुख्य वस्तु जिसे आप हेरफेर करते हैं और पास है tf.Tensor । TensorFlow प्रोग्राम पहले tf.Tensor ऑब्जेक्ट्स का tf.Tensor और विस्तार से वर्णन करते हुए काम करते हैं कि कैसे प्रत्येक टेंसर की गणना अन्य उपलब्ध tf.Tensor आधार पर की जाती है, और फिर गणना परिणाम प्राप्त करने के लिए इस ग्राफ़ के कुछ हिस्सों को चलाया जाता है।

tf.Tensor पास निम्नलिखित विकल्प हैं:

उदाहरण के लिए डेटा प्रकार ( float32 , float32 , या string )
आकार (आकार)

सभी टेंसर तत्वों में समान डेटा प्रकार होता है, और यह हमेशा ज्ञात होता है। आयाम (माप की संख्या और प्रत्येक माप का आकार) केवल आंशिक रूप से ज्ञात हो सकते हैं। अधिकांश परिचालनों का परिणाम ज्ञात आयामों के साथ टेन्सर्स हैं, यदि इनपुट पर आयाम भी पूरी तरह से ज्ञात हैं, लेकिन कुछ मामलों में ग्राफ के निष्पादन के दौरान केवल टेंसर के आयामों का पता लगाना संभव है।

दसियों के मुख्य प्रकार इस प्रकार हैं:

tf.Variable
tf.constant
tf.placeholder
tf.SparseTensor

tf.Variable के अपवाद के साथ, टेंसर मान अपरिवर्तित है, अर्थात एक निष्पादन के संदर्भ में, एक टेनसर का केवल एक मूल्य हो सकता है। हालांकि, एक ही टेंसर की गणना दो बार विभिन्न मूल्यों को वापस कर सकती है; उदाहरण के लिए, वही टेंसर एक डिस्क से डेटा पढ़ने, या एक यादृच्छिक संख्या उत्पन्न करने का परिणाम हो सकता है।

पद

tf.Tensor ऑब्जेक्ट की रैंक इसके आयामों की संख्या है। किसी पद के पर्यायवाची क्रम , डिग्री , आयाम हैं । ध्यान दें कि TensorFlow में एक रैंक गणित में मैट्रिक्स रैंक के समान नहीं है। निम्न तालिका से पता चलता है, Tensorflow में प्रत्येक रैंक कुछ गणितीय इकाई से मेल खाती है:

पद	गणितीय इकाई
0	स्केलर (केवल मूल्य)
1	वेक्टर (परिमाण और दिशा)
2	मैट्रिक्स (संख्या की तालिका)
3	3-सेंसर (संख्याओं का घन)
n	एन-टेंसर (ठीक है, आपको विचार मिलता है)

रैंक 0

निम्नलिखित स्निपेट रैंक 0 के कई चर के निर्माण को प्रदर्शित करता है:

 mammal = tf.Variable("Elephant", tf.string) ignition = tf.Variable(451, tf.int16) floating = tf.Variable(3.14159265359, tf.float64) its_complicated = tf.Variable(12.3 - 4.85j, tf.complex64)

नोट: एक स्ट्रिंग को TensorFlow में एकल ऑब्जेक्ट माना जाता है, न कि वर्णों का एक क्रम। स्ट्रिंग स्केलर, पंक्ति वैक्टर आदि होना संभव है।

रैंक 1

रैंक 1 का tf.Tensor ऑब्जेक्ट बनाने के लिए, आप प्रारंभिक मानों के रूप में तत्वों की एक सूची पास कर सकते हैं। उदाहरण के लिए:

 mystr = tf.Variable(["Hello"], tf.string) cool_numbers = tf.Variable([3.14159, 2.71828], tf.float32) first_primes = tf.Variable([2, 3, 5, 7, 11], tf.int32) its_very_complicated = tf.Variable([12.3 - 4.85j, 7.5 - 6.23j], tf.complex64)

उच्च रैंक

tf.Tensor ऑब्जेक्ट की रैंक 2 में कम से कम एक पंक्ति और एक कॉलम होता है:

 mymat = tf.Variable([[7],[11]], tf.int16) myxor = tf.Variable([[False, True],[True, False]], tf.bool) linear_squares = tf.Variable([[4], [9], [16], [25]], tf.int32) squarish_squares = tf.Variable([ [4, 9], [16, 25] ], tf.int32) rank_of_squares = tf.rank(squarish_squares) mymatC = tf.Variable([[7],[11]], tf.int32)

उच्च श्रेणी के टेनर्स, इसी तरह, एन-आयामी सरणियों से मिलकर होते हैं। उदाहरण के लिए, छवियों को संसाधित करते समय, कई रैंक 4 टेनर्स का उपयोग किया जाता है, जिसमें पैकेट में उदाहरण संख्या, छवि ऊंचाई, छवि चौड़ाई और रंग चैनल के अनुरूप आयाम होते हैं।

 my_image = tf.zeros([10, 299, 299, 3]) #   x  x  x

`tf.Tensor` ऑब्जेक्ट `tf.Tensor`

tf.Tensor ऑब्जेक्ट की रैंक निर्धारित करने के लिए, tf.rank विधि को कॉल करें। उदाहरण के लिए, निम्न विधि प्रोग्रामेटिक रूप से ऊपर निर्दिष्ट tf.Tensor की रैंक निर्धारित करती है:

 r = tf.rank(my_image) #   , r   4.

स्लाइस के लिंक `tf.Tensor`

चूंकि tf.Tensor का एक n- आयामी सरणी है, tf.Tensor में किसी एकल कक्ष तक tf.Tensor आपको इन सूचकांकों को निर्दिष्ट करने की आवश्यकता होती है।

रैंक 0 टेनर्स (स्केलर्स) के लिए, अनुक्रमित की आवश्यकता नहीं है, क्योंकि यह पहले से ही एक संख्या है।

एक रैंक 1 टेंसर (वेक्टर) के लिए, एकल इंडेक्स पास करने से आपको संख्या तक पहुंच मिलेगी:

 my_scalar = my_vector[2]

ध्यान दें कि अगर [] पास किया गया इंडेक्स अपने आप में एक tf.Tensor स्केलर हो सकता है, अगर आप डायनेमिक रूप से किसी वेक्टर से एक तत्व चुनना चाहते हैं।

रैंक 2 या उच्चतर के दसियों के लिए, स्थिति अधिक दिलचस्प है। tf.Tensor रैंक 2 के लिए, एक अदिश की उम्मीद के अनुसार दो नंबर रिटर्न पास करना:

 my_scalar = my_matrix[1, 2]

हालाँकि, एक संख्या को पास करना, मैट्रिक्स के एक उप-ट्रैक्टर को निम्नानुसार लौटाता है:

 my_row_vector = my_matrix[2] my_column_vector = my_matrix[:, 3]

संकेतन : सिंटैक्स में, अजगर में सबर्रे आवंटन का उपयोग "इस आयाम को अकेला छोड़ दें" के रूप में किया जाता है। यह उच्च श्रेणी के टेनर्स में उपयोगी है, क्योंकि यह सबवेक्टर्स, सबमैट्रिसेस और यहां तक कि अन्य सबटेंसर्स तक पहुंच की अनुमति देता है।

आयाम

दशांश आयाम प्रत्येक आयाम में तत्वों की संख्या है। TensorFlow प्रलेखन एक टेंसर के आयाम का वर्णन करने के लिए तीन सम्मेलनों का उपयोग करता है: रैंक, आयाम और आयामों की संख्या। निम्न तालिका से पता चलता है कि वे एक दूसरे से कैसे संबंधित हैं:

पद	आयाम	माप की संख्या	उदाहरण
0	[]	0 डी	0-डी टेंसर। अदिश।
1	[D0]	1-डी	1-डी आकार टेंसर [5]।
2	[डी ०, डी १]	2-डी	2-डी आकार टेंसर [3, 4]।
3	[डी ०, डी १, डी २]	3-डी	3-डी आकार टेंसर [1, 4, 3]।
n	[D0, D1, ... Dn-1]	एन डी	आकार टेंसर [D0, D1, ... Dn-1]।

आकार को पायथन सूचियों / पूर्णांक के ट्यूपल्स या उपयोग के रूप में दर्शाया जा सकता है
tf.TensorShape

`tf.Tensor` ऑब्जेक्ट का आकार प्राप्त करना

tf.Tensor आयाम प्राप्त करने के दो तरीके हैं। ग्राफ का निर्माण करते समय, यह पूछना अक्सर उपयोगी होता है कि टेंसर के आकार के बारे में पहले से ही क्या ज्ञात है। यह tf.Tensor ऑब्जेक्ट की shape प्रॉपर्टी को पढ़कर किया जा सकता है। यह विधि TensorShape ऑब्जेक्ट TensorShape है, जो एक सुविधाजनक तरीका है।
आंशिक रूप से परिभाषित आकारों का प्रतिनिधित्व (जब एक ग्राफ का निर्माण करते समय, सभी आकार पूरी तरह से ज्ञात नहीं हो सकते हैं)।

आप tf.Tensor भी प्राप्त कर सकते हैं जो रनटाइम के दौरान दूसरे tf.Tensor के पूर्ण-परिभाषित आयामों का प्रतिनिधित्व करता है। यह tf.shape ऑपरेशन को tf.shape करके किया जाता है। इस तरह, आप एक ग्राफ बना सकते हैं जो इनपुट tf.Tensor के गतिशील आकारों के आधार पर अन्य tf.Tensor का निर्माण करके tf.Tensor आकार में tf.Tensor ।

उदाहरण के लिए, आप किसी दिए गए मैट्रिक्स के कॉलम की संख्या के समान आकार के शून्य बना सकते हैं:

 zeros = tf.zeros(my_matrix.shape[1])

`tf.Tensor` आकार बदलें

टेंसर तत्वों की संख्या इसके सभी मापों का उत्पाद है। अदिश तत्वों की संख्या हमेशा 1 । चूंकि कई अलग-अलग आकार समान तत्वों को दे सकते हैं, इसलिए अक्सर अपने तत्वों को बदले बिना tf.Tensor का आकार बदलना सुविधाजनक होता है। यह tf.reshape का उपयोग करके किया जा सकता है।

निम्नलिखित उदाहरण दिखाते हैं कि एक टेंसर का आकार कैसे बदला जाता है:

 rank_three_tensor = tf.ones([3, 4, 5]) matrix = tf.reshape(rank_three_tensor, [6, 10]) #    #   6x10 matrixB = tf.reshape(matrix, [3, -1]) #     #  3x20. -1  reshape   #    . matrixAlt = tf.reshape(matrixB, [4, 3, -1]) #     #  4x3x5 # ,         #   .     #         #     . yet_another = tf.reshape(matrixAlt, [13, 2, -1]) # ERROR!

डेटा प्रकार

आयाम के अलावा, टेंसरों में एक डेटा प्रकार होता है। एक विशेष tf.Tensor एक से अधिक डेटा प्रकार नहीं हो सकते। हालांकि, मनमानी डेटा संरचनाओं को एक string में क्रमबद्ध करना और उन्हें tf.Tensor में स्टोर करना tf.Tensor ।

आप tf.Tensor । tf.cast का उपयोग एक डेटा प्रकार से दूसरे में tf.cast का उपयोग करके कर tf.cast :

 #         . float_tensor = tf.cast(tf.constant([1, 2, 3]), dtype=tf.float32)

tf.Tensor डेटा प्रकार देखने के लिए, Tensor.dtype गुण का उपयोग करें।

अजगर ऑब्जेक्ट से tf.Tensor बनाते tf.Tensor , आप वैकल्पिक रूप से एक डेटा प्रकार निर्दिष्ट कर सकते हैं। यदि आप नहीं करते हैं, तो TensorFlow एक डेटा प्रकार का चयन करेगा जो आपके डेटा का प्रतिनिधित्व कर सकता है। TensorFlow Python पूर्णांकों को tf.int32 , और फ़्लोटिंग-पॉइंट नंबरों को tf.float32 । अन्य मामलों में, TensorFlow एरे को परिवर्तित करते समय समान नियमों का उपयोग करता है।

टेंसर मूल्यांकन

एक बार एक कम्प्यूटेशनल ग्राफ बन जाने के बाद, आप एक कम्प्यूटेशन चला सकते हैं
एक विशिष्ट tf.Tensor उत्पन्न करेगा और उसे सौंपे गए मूल्य को tf.Tensor । यह अक्सर डिबगिंग के लिए उपयोगी होता है, साथ ही साथ TensorFlow के अधिकांश काम करने के लिए भी।

Tensor का मूल्यांकन करने का सबसे आसान तरीका Tensor.eval विधि का उपयोग करना है। उदाहरण के लिए:

 constant = tf.constant([1, 2, 3]) tensor = constant * constant print(tensor.eval())

tf.Session मेथड तभी काम करता है जब डिफ़ॉल्ट tf.Session । Tensor.eval टेंसर के समान सामग्री के साथ एक सुव्यवस्थित सरणी देता है।

कभी-कभी संदर्भ के बिना tf.Tensor का मूल्यांकन करना असंभव है, क्योंकि इसका मूल्य उपलब्ध नहीं होने वाली गतिशील जानकारी पर निर्भर हो सकता है। उदाहरण के लिए, placeholder निर्भर टेनर्स का मूल्यांकन placeholder लिए कोई मूल्य प्रदान किए बिना नहीं किया जा सकता है।

 p = tf.placeholder(tf.float32) t = p + 1.0 t.eval() #   ,   placeholder   . t.eval(feed_dict={p:2.0}) #  ,     #   placeholder.

कृपया ध्यान दें कि आप किसी भी tf.Tensor उपयोग कर सकते हैं, न कि केवल प्लेसहोल्डर।

अन्य मॉडल डिजाइन tf.Tensor का मूल्यांकन करने के लिए और अधिक कठिन बना सकते हैं। TensorFlow सीधे tf.Tensor को कार्यों के अंदर या नियंत्रण प्रवाह निर्माण के भीतर परिभाषित नहीं कर सकता है। यदि tf.Tensor कतार से मूल्य पर निर्भर करता है, तो tf.Tensor स्कोर केवल तभी काम करेगा जब कुछ कतार में रखा जाए; अन्यथा, दहाई का अनुमान स्थिर हो जाएगा। कतारों के साथ काम करते समय, किसी भी tf.Tensor मूल्यांकन करने से पहले tf.train.start_queue_runners को कॉल करना tf.train.start_queue_runners tf.Tensor ।

सत्यापन के बाद, अनुवाद Tensorflow.org पर भी दिखाई देगा। यदि आप रूसी में Tensorflow.org वेबसाइट के प्रलेखन के अनुवाद में भाग लेना चाहते हैं, तो कृपया एक व्यक्तिगत या टिप्पणी में संपर्क करें। किसी भी सुधार या टिप्पणी की सराहना की जाती है।

TensorFlow में सेंसर

पद

रैंक 0

रैंक 1

उच्च रैंक

tf.Tensor ऑब्जेक्ट tf.Tensor

स्लाइस के लिंक tf.Tensor