TensorFlow मूल बातें: Tensor, आकार, प्रकार, सत्र और amp; ऑपरेटर्स

Tensor क्या है?

Tensorflow का नाम सीधे इसके मूल ढांचे से लिया गया है: Tensor। Tensorflow में, सभी संगणनाओं में टेंसर्स शामिल होते हैं। एक टेंसर एन-डाइमेंशन का एक वेक्टर या मैट्रिक्स है जो सभी प्रकार के डेटा का प्रतिनिधित्व करता है। एक टेंसर में सभी मान एक ज्ञात (या आंशिक रूप से ज्ञात) आकार के साथ समान डेटा प्रकार रखते हैं। डेटा का आकार मैट्रिक्स या सरणी की आयामीता है।

एक टेंसर इनपुट डेटा या एक संगणना के परिणाम से उत्पन्न हो सकता है। TensorFlow में, सभी ऑपरेशन एक ग्राफ के अंदर किए जाते हैं। ग्राफ गणना का एक सेट है जो क्रमिक रूप से होता है। प्रत्येक ऑपरेशन को एक ऑप नोड कहा जाता है और एक दूसरे से जुड़े होते हैं।

ग्राफ ऑप्स और कनेक्शन को नोड्स के बीच रेखांकित करता है। हालाँकि, यह मान प्रदर्शित नहीं करता है। नोड्स का किनारा टेन्सर है, अर्थात, डेटा के साथ ऑपरेशन को पॉप्युलेट करने का एक तरीका है।

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

इस ट्यूटोरियल में, आप TensorFlow मूल बातें सीखेंगे जैसे-

• Tensor क्या है?
• एक सेंसर का प्रतिनिधित्व
• Tensor के प्रकार
• एन-डाइमेंशन का टेंसर बनाएं
• टेंसर का आकार
• डेटा का प्रकार
• संचालक बनाना
• कुछ उपयोगी TensorFlow ऑपरेटरों
• चर
• प्लेसहोल्डर
• अधिवेशन
• ग्राफ़

एक सेंसर का प्रतिनिधित्व

TensorFlow में, एक टेंसर n- आयामों के फ़ीचर वैक्टर (अर्थात, सरणी) का एक संग्रह है। उदाहरण के लिए, यदि हमारे पास 1 से 6 तक के मूल्यों के साथ 2x3 मैट्रिक्स है, तो हम लिखते हैं:

एक सेंसर का प्रतिनिधित्व

TensorFlow इस मैट्रिक्स का प्रतिनिधित्व करता है:

[[1, 2, 3],[4, 5, 6]] 

यदि हम 1 से 8 तक मानों के साथ एक त्रि-आयामी मैट्रिक्स बनाते हैं, तो हमारे पास है:

TensorFlow इस मैट्रिक्स का प्रतिनिधित्व करता है:

[ [[1, 2],[[3, 4],[[5, 6],[[7,8] ] 

नोट: एक तन्यता को एक स्केलर के साथ दर्शाया जा सकता है या तीन से अधिक आयामों का आकार हो सकता है। उच्च आयाम स्तर की कल्पना करना अधिक जटिल है।

Tensor के प्रकार

TensorFlow में, सभी गणना एक या अधिक टेंसरों से गुजरती हैं। एक tf.tensor तीन गुणों वाली एक वस्तु है:

• एक अद्वितीय लेबल (नाम)
• एक आयाम (आकार)
• डेटा प्रकार (dtype)

TensorFlow के साथ आपके द्वारा किया जाने वाला प्रत्येक ऑपरेशन में एक टैंसर का हेरफेर शामिल होता है। चार मुख्य टेंसर प्रकार आप बना सकते हैं:

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

इस ट्यूटोरियल में, आप सीखेंगे कि tf.constant और tf.Variable कैसे बनाएँ।

इससे पहले कि हम ट्यूटोरियल से गुजरें, सुनिश्चित करें कि आप TensorFlow के साथ कोंडा पर्यावरण को सक्रिय करते हैं। हमने इस वातावरण का नाम हैलो-टीएफ रखा।

MacOS उपयोगकर्ता के लिए:

source activate hello-tf 

विंडोज उपयोगकर्ता के लिए:

activate hello-tf 

आपके द्वारा ऐसा करने के बाद, आप टेंसोफ़्लो आयात करने के लिए तैयार हैं

# Import tfimport tensorflow as tf 

एन-डाइमेंशन का टेंसर बनाएं

आप एक आयाम के साथ एक तन्यता के निर्माण के साथ शुरू करते हैं, अर्थात् एक स्केलर।

एक टेंसर बनाने के लिए, आप tf.constant () का उपयोग कर सकते हैं जैसा कि नीचे TensorFlow टेंसर आकार में दिखाया गया है:

tf.constant(value, dtype, name = "")arguments- `value`: Value of n dimension to define the tensor. Optional- `dtype`: Define the type of data:- `tf.string`: String variable- `tf.float32`: Float variable- `tf.int16`: Integer variable- "name": Name of the tensor. Optional. By default, `Const_1:0` 

आयाम 0 का टेंसर बनाने के लिए, निम्न कोड चलाएँ

## rank 0# Default namer1 = tf.constant(1, tf.int16)print(r1)

उत्पादन

Tensor("Const:0", shape=(), dtype=int16) 

# Named my_scalarr2 = tf.constant(1, tf.int16, name = "my_scalar")print(r2) 

उत्पादन

Tensor("my_scalar:0", shape=(), dtype=int16) 

प्रत्येक टेंसर को टेंसर नाम से प्रदर्शित किया जाता है। प्रत्येक टेंसर ऑब्जेक्ट को एक अद्वितीय लेबल (नाम), एक आयाम (आकार) और TensorFlow डेटा प्रकार (dtype) की तरह टेंसर विशेषताओं के साथ परिभाषित किया गया है।

आप दशमलव मान को या डेटा के प्रकार को बदलकर एक स्ट्रिंग के साथ एक टेंसर को परिभाषित कर सकते हैं।

# Decimalr1_decimal = tf.constant(1.12345, tf.float32)print(r1_decimal)# Stringr1_string = tf.constant("Guru99", tf.string)print(r1_string) 

उत्पादन

Tensor("Const_1:0", shape=(), dtype=float32)Tensor("Const_2:0", shape=(), dtype=string) 

आयाम 1 का एक टेंसर निम्नानुसार बनाया जा सकता है:

## Rank 1r1_vector = tf.constant([1,3,5], tf.int16)print(r1_vector)r2_boolean = tf.constant([True, True, False], tf.bool)print(r2_boolean) 

उत्पादन

Tensor("Const_3:0", shape=(3,), dtype=int16)Tensor("Const_4:0", shape=(3,), dtype=bool) 

आप देख सकते हैं TensorFlow आकार केवल 1 कॉलम से बना है।

2 टेंसर आयामों की एक सरणी बनाने के लिए, आपको प्रत्येक पंक्ति के बाद कोष्ठक को बंद करने की आवश्यकता है। नीचे Keras Tensor आकार उदाहरण की जाँच करें

## Rank 2r2_matrix = tf.constant([ [1, 2],[3, 4] ],tf.int16)print(r2_matrix) 

उत्पादन

Tensor("Const_5:0", shape=(2, 2), dtype=int16) 

मैट्रिक्स में 1, 2, 3, 4 मानों से भरी 2 पंक्तियाँ और 2 कॉलम हैं।

ब्रैकेट के साथ एक और स्तर जोड़कर 3 आयामों के साथ एक मैट्रिक्स का निर्माण किया जाता है।

## Rank 3r3_matrix = tf.constant([ [[1, 2],[3, 4],[5, 6]] ], tf.int16)print(r3_matrix) 

उत्पादन

Tensor("Const_6:0", shape=(1, 3, 2), dtype=int16) 

मैट्रिक्स तस्वीर दो की तरह दिखता है।

टेंसर का आकार

जब आप टैंसर प्रिंट करते हैं, तो TensorFlow आकार का अनुमान लगाता है। हालाँकि, आप TensorFlow शेप प्रॉपर्टी के साथ टेंसर का आकार प्राप्त कर सकते हैं।

नीचे, आप 10 से 15 तक की संख्या से भरे मैट्रिक्स का निर्माण करते हैं और आप m_shape के आकार की जांच करते हैं

# Shape of tensorm_shape = tf.constant([ [10, 11],[12, 13],[14, 15] ])m_shape.shape 

उत्पादन

TensorShape([Dimension(3), Dimension(2)]) 

मैट्रिक्स में 3 पंक्तियाँ और 2 कॉलम हैं।

TensorFlow में वेक्टर या 0 या 1. से भरा मैट्रिक्स बनाने के लिए उपयोगी कमांड हैं। उदाहरण के लिए, यदि आप 10 के विशिष्ट आकार के साथ 1-D टेन्सर बनाना चाहते हैं, तो 0 से भरे, आप नीचे दिए गए कोड को चला सकते हैं:

# Create a vector of 0print(tf.zeros(10)) 

उत्पादन

Tensor("zeros:0", shape=(10,), dtype=float32) 

संपत्ति मैट्रिक्स के लिए भी काम करती है। यहां, आप 1 से भरा 10x10 मैट्रिक्स बनाते हैं

# Create a vector of 1print(tf.ones([10, 10])) 

उत्पादन

Tensor("ones:0", shape=(10, 10), dtype=float32) 

आप एक वेक्टर बनाने के लिए किसी दिए गए मैट्रिक्स के आकार का उपयोग कर सकते हैं। मैट्रिक्स m_shape एक 3x2 आयाम है। आप निम्न कोड के साथ किसी के द्वारा भरी गई 3 पंक्तियों के साथ एक टेंसर बना सकते हैं:

# Create a vector of ones with the same number of rows as m_shapeprint(tf.ones(m_shape.shape[0])) 

उत्पादन

Tensor("ones_1:0", shape=(3,), dtype=float32) 

यदि आप मान 1 को ब्रैकेट में पास करते हैं, तो आप मैट्रिक्स m_shape में स्तंभों की संख्या के बराबर वेक्टर का निर्माण कर सकते हैं।

# Create a vector of ones with the same number of column as m_shapeprint(tf.ones(m_shape.shape[1])) 

उत्पादन

Tensor("ones_2:0", shape=(2,), dtype=float32) 

अंत में, आप केवल एक के साथ एक मैट्रिक्स 3x2 बना सकते हैं

print(tf.ones(m_shape.shape)) 

उत्पादन

Tensor("ones_3:0", shape=(3, 2), dtype=float32) 

डेटा का प्रकार

एक टेंसर की दूसरी संपत्ति डेटा का प्रकार है। एक टेंसर में एक समय में केवल एक प्रकार का डेटा हो सकता है। एक टेंसर में केवल एक प्रकार का डेटा हो सकता है। आप संपत्ति dtype के साथ प्रकार वापस कर सकते हैं।

print(m_shape.dtype) 

उत्पादन

कुछ अवसरों में, आप डेटा के प्रकार को बदलना चाहते हैं। TensorFlow में, यह tf.cast विधि से संभव है।

उदाहरण

नीचे, एक फ़्लोट टेंसर पूर्णांक में परिवर्तित हो जाता है जब आप विधि का उपयोग करते हैं।

# Change type of datatype_float = tf.constant(3.123456789, tf.float32)type_int = tf.cast(type_float, dtype=tf.int32)print(type_float.dtype)print(type_int.dtype) 

उत्पादन

जब टेंसर के निर्माण के दौरान तर्क निर्दिष्ट नहीं किया जाता है, तो TensorFlow स्वचालित रूप से डेटा का प्रकार चुनता है। TensorFlow अनुमान लगाएगा कि डेटा के सबसे संभावित प्रकार क्या हैं। उदाहरण के लिए, यदि आप कोई पाठ पास करते हैं, तो यह अनुमान लगाएगा कि यह एक स्ट्रिंग है और इसे स्ट्रिंग में परिवर्तित कर देगा।

संचालक बनाना

कुछ उपयोगी TensorFlow ऑपरेटरों

आप जानते हैं कि TensorFlow के साथ एक टेंसर कैसे बनाया जाता है। यह सीखने का समय है कि गणितीय संचालन कैसे किया जाए।

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

एक संख्या का वर्ग एक अस्थायी संख्या के रूप में x के साथ tf.sqrt (x) के साथ बनाया गया है।

x = tf.constant([2.0], dtype = tf.float32)print(tf.sqrt(x)) 

उत्पादन

Tensor("Sqrt:0", shape=(1,), dtype=float32) 

नोट: आउटपुट ने एक टेंसर ऑब्जेक्ट लौटाया, न कि 2 के वर्ग का परिणाम। उदाहरण के लिए, आप टेनर की परिभाषा को प्रिंट करते हैं न कि ऑपरेशन के वास्तविक मूल्यांकन को। अगले भाग में, आप सीखेंगे कि TensorFlow संचालन को निष्पादित करने के लिए कैसे काम करता है।

निम्नलिखित आमतौर पर उपयोग किए जाने वाले कार्यों की एक सूची है। विचार वही है। प्रत्येक ऑपरेशन के लिए एक या अधिक तर्कों की आवश्यकता होती है।

• tf.add (ए, बी)
• tf.substract (ए, बी)
• tf.multiply (ए, बी)
• tf.div (ए, बी)
• tf.pow (ए, बी)
• tf.exp (a)
• tf.sqrt (a)

उदाहरण

# Addtensor_a = tf.constant([[1,2]], dtype = tf.int32)tensor_b = tf.constant([[3, 4]], dtype = tf.int32)tensor_add = tf.add(tensor_a, tensor_b)print(tensor_add) 

उत्पादन

Tensor("Add:0", shape=(1, 2), dtype=int32) 

कोड स्पष्टीकरण

दो टेनर्स बनाएँ:

• 1 और 2 के साथ एक टेंसर
• 3 और 4 के साथ एक टेंसर

आप दोनों दसियों को जोड़ते हैं।

सूचना : कि दोनों टेंसरों का आकार एक जैसा होना चाहिए। आप दो टेनर्स पर गुणा कर सकते हैं।

# Multiplytensor_multiply = tf.multiply(tensor_a, tensor_b)print(tensor_multiply) 

उत्पादन

Tensor("Mul:0", shape=(1, 2), dtype=int32) 

चर

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

एक चर बनाने के लिए, आप tf.get_variable () विधि का उपयोग कर सकते हैं

tf.get_variable(name = "", values, dtype, initializer)argument- `name = ""`: Name of the variable- `values`: Dimension of the tensor- `dtype`: Type of data. Optional- `initializer`: How to initialize the tensor. OptionalIf initializer is specified, there is no need to include the `values` as the shape of `initializer` is used. 

उदाहरण के लिए, नीचे दिया गया कोड दो यादृच्छिक मूल्यों के साथ एक दो आयामी चर बनाता है। डिफ़ॉल्ट रूप से, TensorFlow एक यादृच्छिक मूल्य देता है। आप वैरिएबल वर्जन को नाम देते हैं

# Create a Variable## Create 2 Randomized valuesvar = tf.get_variable("var", [1, 2])print(var.shape) 

उत्पादन

(1, 2) 

दूसरे उदाहरण में, आप एक पंक्ति और दो कॉलम के साथ एक चर बनाते हैं। चर का आयाम बनाने के लिए आपको [1,2] का उपयोग करने की आवश्यकता है

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

var_init_1 = tf.get_variable("var_init_1", [1, 2], dtype=tf.int32, initializer=tf.zeros_initializer)print(var_init_1.shape) 

उत्पादन

(1, 2) 

आप एक चर में एक निरंतर टेंसर के मूल्यों को पारित कर सकते हैं। आप विधि tf.constant () के साथ एक निरंतर टेंसर बनाएं। वैरिएबल को इनिशियलाइज़ करने के लिए आप इस टेंसर का इस्तेमाल करते हैं।

चर के पहले मान 10, 20, 30 और 40 हैं। नए टेंसर का आकार 2x2 होगा।

# Create a 2x2 matrixtensor_const = tf.constant([[10, 20],[30, 40]])# Initialize the first value of the tensor equals to tensor_constvar_init_2 = tf.get_variable("var_init_2", dtype=tf.int32, initializer=tensor_const)print(var_init_2.shape) 

उत्पादन

(2, 2) 

प्लेसहोल्डर

एक प्लेसहोल्डर का उद्देश्य टेंसर को खिलाने का है। प्लेसहोल्डर का उपयोग डेटा को इनिशियलाइज़ करने के लिए टेन्सर्स के अंदर प्रवाह करने के लिए किया जाता है। किसी प्लेसहोल्डर को आपूर्ति करने के लिए, आपको विधि feed_dict का उपयोग करना होगा। प्लेसहोल्डर को केवल एक सत्र के भीतर खिलाया जाएगा।

अगले उदाहरण में, आप देखेंगे कि कैसे विधि tf.placeholder के साथ एक प्लेसहोल्डर बनाया जाए। अगले सत्र में, आप एक प्लेसहोल्डर को वास्तविक टेंसर मूल्य के साथ खिलाया जाना सीखेंगे।

वाक्य रचना है:

tf.placeholder(dtype,shape=None,name=None )arguments:- `dtype`: Type of data- `shape`: dimension of the placeholder. Optional. By default, shape of the data- `name`: Name of the placeholder. Optionaldata_placeholder_a = tf.placeholder(tf.float32, name = "data_placeholder_a")print(data_placeholder_a) 

उत्पादन

Tensor("data_placeholder_a:0", dtype=float32) 

अधिवेशन

TensorFlow लगभग 3 मुख्य घटक काम करता है:

• ग्राफ़
• टेन्सर
• अधिवेशन

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

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

नीचे दिए गए उदाहरण में, आप करेंगे:

• दो टेनर्स बनाएं
• एक ऑपरेशन बनाएँ
• एक सत्र खोलें
• परिणाम प्रिंट करें

चरण 1) आप दो टेंसर्स x और y बनाते हैं

## Create, run and evaluate a sessionx = tf.constant([2])y = tf.constant([4]) 

चरण 2) आप एक्स और वाई को गुणा करके ऑपरेटर बनाते हैं

## Create operatormultiply = tf.multiply(x, y) 

चरण 3) आप एक सत्र खोलें। सभी गणना सत्र के भीतर होगी। जब आप कर लेते हैं, तो आपको सत्र बंद करने की आवश्यकता होती है।

## Create a session to run the codesess = tf.Session()result_1 = sess.run(multiply)print(result_1)sess.close() 

उत्पादन

[8] 

कोड स्पष्टीकरण

• tf.Session (): एक सत्र खोलें। सभी ऑपरेशन सत्रों के भीतर चलेंगे
• रन (गुणा): चरण 2 में बनाए गए ऑपरेशन को निष्पादित करें।
• प्रिंट (result_1): अंत में, आप परिणाम प्रिंट कर सकते हैं
• बंद (): सत्र बंद करें

परिणाम 8 दिखाता है, जो कि x और y का गुणन है।

सत्र बनाने का दूसरा तरीका एक ब्लॉक के अंदर है। लाभ यह है कि यह सत्र को स्वचालित रूप से बंद कर देता है।

with tf.Session() as sess:result_2 = multiply.eval()print(result_2) 

उत्पादन

[8] 

सत्र के संदर्भ में, आप ऑपरेशन को निष्पादित करने के लिए eval () विधि का उपयोग कर सकते हैं। यह चलाने के बराबर है ()। यह कोड को अधिक पठनीय बनाता है।

आप एक सत्र बना सकते हैं और आपके द्वारा अब तक बनाए गए टेंसरों के अंदर के मूल्यों को देख सकते हैं।

## Check the tensors created beforesess = tf.Session()print(sess.run(r1))print(sess.run(r2_matrix))print(sess.run(r3_matrix)) 

उत्पादन

1[[1 2][3 4]][[[1 2][3 4][5 6]]] 

वेरिएबल्स डिफ़ॉल्ट रूप से खाली होते हैं, भले ही आप टेंसर बनाते हैं। यदि आप वैरिएबल का उपयोग करना चाहते हैं तो आपको वैरिएबल को इनिशियलाइज़ करना होगा। ऑब्जेक्ट tf.global_variables_initializer () को एक चर के मूल्यों को शुरू करने के लिए बुलाया जाना चाहिए। यह ऑब्जेक्ट स्पष्ट रूप से सभी वेरिएबल्स को इनिशियलाइज़ करेगा। किसी मॉडल को प्रशिक्षित करने से पहले यह मददगार है।

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

sess.run(tf.global_variables_initializer())print(sess.run(var))print(sess.run(var_init_1))print(sess.run(var_init_2)) 

उत्पादन

[[-0.05356491 0.75867283]][[0 0]][[10 20][30 40]] 

आप पहले बनाए गए प्लेसहोल्डर का उपयोग कर सकते हैं और इसे वास्तविक मूल्य के साथ फीड कर सकते हैं। आपको डेटा को विधि feed_dict में पास करना होगा।

उदाहरण के लिए, आप प्लेसहोल्डर data_placeholder_a में से 2 की शक्ति लेंगे।

import numpy as nppower_a = tf.pow(data_placeholder_a, 2)with tf.Session() as sess:data = np.random.rand(1, 10)print(sess.run(power_a, feed_dict={data_placeholder_a: data})) # Will succeed. 

कोड स्पष्टीकरण

• np के रूप में numpy आयात करें: डेटा बनाने के लिए numpy लाइब्रेरी आयात करें
• tf.pow (data_placeholder_a, 2): ऑप्स बनाएँ
• np.random.rand (1, 10): डेटा का एक यादृच्छिक सरणी बनाएँ
• feed_dict = {data_placeholder_a: data}: प्लेसहोल्डर को डेटा के साथ फ़ीड करें

उत्पादन

[[0.05478134 0.27213147 0.8803037 0.0398424 0.21172127 0.01444725 0.02584014 0.3763949 0.66022706 0.7565559 ]] 

ग्राफ़

TensorFlow ऑपरेशन को प्रस्तुत करने के लिए एक प्रतिभाशाली दृष्टिकोण पर निर्भर करता है। सभी संगणनाएँ डेटाफ्लो योजना के साथ दर्शायी जाती हैं। व्यक्तिगत ऑपरेशन के बीच डेटा निर्भरता को देखने के लिए डेटाफ्लो ग्राफ विकसित किया गया है। गणितीय सूत्र या एल्गोरिदम कई क्रमिक संचालन से बने होते हैं। एक ग्राफ यह कल्पना करने का एक सुविधाजनक तरीका है कि कम्प्यूटेशन कैसे समन्वित होते हैं।

ग्राफ एक नोड और एक बढ़त दिखाता है । नोड एक ऑपरेशन का प्रतिनिधित्व है, यानी गणना की इकाई। बढ़त टेंसर है, यह एक नया टेंसर पैदा कर सकता है या इनपुट डेटा का उपभोग कर सकता है। यह व्यक्तिगत ऑपरेशन के बीच निर्भरता पर निर्भर करता है।

ग्राफ़ की संरचना एक साथ संचालन (यानी नोड्स) को जोड़ती है और जो ऑपरेशन होते हैं वे कैसे फ़ीड हैं। ध्यान दें कि ग्राफ़ ऑपरेशन के आउटपुट को प्रदर्शित नहीं करता है, यह केवल व्यक्तिगत संचालन के बीच कनेक्शन की कल्पना करने में मदद करता है।

एक उदाहरण देखते हैं।

कल्पना कीजिए कि आप निम्नलिखित फ़ंक्शन का मूल्यांकन करना चाहते हैं:

TensorFlow फ़ंक्शन को निष्पादित करने के लिए एक ग्राफ़ बनाएगा। ग्राफ इस तरह दिखता है:

TensorFlow ग्राफ़ उदाहरण

आप आसानी से उस रास्ते को देख सकते हैं जो अंतिम गंतव्य तक पहुंचने के लिए टेंसर्स ले जाएगा।

उदाहरण के लिए, आप देख सकते हैं कि ऑपरेशन जोड़ने से पहले और नहीं किया जा सकता है। ग्राफ बताता है कि यह होगा:

1. गणना और:
2. 1) एक साथ जोड़ें
3. 2 में जोड़ें)
4. को 3) जोड़ें

x = tf.get_variable("x", dtype=tf.int32, initializer=tf.constant([5]))z = tf.get_variable("z", dtype=tf.int32, initializer=tf.constant([6]))c = tf.constant([5], name = "constant")square = tf.constant([2], name = "square")f = tf.multiply(x, z) + tf.pow(x, square) + z + c 

कोड स्पष्टीकरण

• x: x नामक एक वैरिएबल को 5 के निरंतर मान के साथ प्रारंभ करें
• z: 6 के निरंतर मान के साथ z नामक एक चर को प्रारंभ करें
• c: 5 के निरंतर मान के साथ c नामक एक स्थिर टेंसर को प्रारंभ करें
• वर्गाकार: 2 के निरंतर मान के साथ वर्गाकार टेंसर नामक वर्ग को प्रारंभ करें
• एफ: ऑपरेटर का निर्माण

इस उदाहरण में, हम चर के मानों को नियत रखना चुनते हैं। हमने c नाम का एक स्थिर टेंसर भी बनाया है जो फंक्शन में निरंतर पैरामीटर है। यह 5 का निश्चित मान लेता है। ग्राफ़ में, आप इस पैरामीटर को टेंसर में देख सकते हैं जिसे स्थिर कहा जाता है।

हमने ऑपरेटर tf.pow () में पावर के लिए एक निरंतर टेंसर का भी निर्माण किया। यह आवश्यक नहीं है। हमने ऐसा इसलिए किया ताकि आप ग्राफ़ में टेंसर का नाम देख सकें। यह वर्ग कहलाता है।

ग्राफ से, आप समझ सकते हैं कि दसियों का क्या होगा और यह 66 का आउटपुट कैसे लौटा सकता है।

नीचे दिए गए कोड एक सत्र में फ़ंक्शन का मूल्यांकन करते हैं।

init = tf.global_variables_initializer() # prepare to initialize all variableswith tf.Session() as sess:init.run() # Initialize x and yfunction_result = f.eval()print(function_result) 

उत्पादन

[66] 

सारांश

TensorFlow चारों ओर काम करता है:

• ग्राफ़ : कम्प्यूटेशनल वातावरण जिसमें संचालन और टेंसर्स शामिल हैं
• सेंसर : उस डेटा (या मान) का प्रतिनिधित्व करता है जो ग्राफ में प्रवाहित होगा। यह ग्राफ में बढ़त है
• सत्र : संचालन के निष्पादन की अनुमति दें

एक स्थिर टेंसर बनाएं

स्थिर	वस्तु
D0	tf.constant (1, tf.int16)
डी 1	tf.constant ([1,3,5], tf.int16)
डी 2	tf.constant ([[१, २], [३, ४]], tf.int16)
डी 3	tf.constant ([[[१, २], [३, ४], [५, ६]]], tf.int16)

एक ऑपरेटर बनाएँ

एक ऑपरेटर बनाएँ	वस्तु
ए + बी	tf.add (ए, बी)
ए * बी	tf.multiply (ए, बी)

एक वैरिएबल टेंसर बनाएं

एक चर बनाएं	वस्तु
यादृच्छिक मूल्य	tf.get_variable ("var", [1, 2])
आरंभिक पहला मूल्य	tf.get_variable ("var_init_2", dtype = tf.int32, initializer = [[१, २], [३, ४]]]

एक सत्र खोलें

अधिवेशन	वस्तु
एक सत्र बनाएँ	tf.Session ()
एक सत्र चलाएं	tf.Session.run ()
एक टेंसर का मूल्यांकन करें	variable_name.eval ()
एक सत्र बंद करें	sess.close ()
ब्लॉक द्वारा सत्र	sf के रूप में tf.Session () के साथ: