TensorFlow मूल बातें: Tensor, आकार, प्रकार, सत्र और Operaमरोड़
एवलिन क्लार्क
टेंसर क्या है?
टेंसरफ्लो का नाम सीधे इसके मुख्य ढांचे से लिया गया है: टेंसर। टेंसरफ्लो में, सभी गणनाओं में टेंसर शामिल होते हैं। टेंसर n-आयामों का एक वेक्टर या मैट्रिक्स होता है जो सभी प्रकार के डेटा का प्रतिनिधित्व करता है। टेंसर में सभी मान एक ज्ञात (या आंशिक रूप से ज्ञात) आकार के साथ समान डेटा प्रकार रखते हैं। डेटा का आकार मैट्रिक्स या सरणी की आयामीता है।
टेंसर की उत्पत्ति इनपुट डेटा या गणना के परिणाम से हो सकती है। TensorFlow में, सभी ऑपरेशन एक ग्राफ के अंदर किए जाते हैं। ग्राफ गणनाओं का एक सेट है जो क्रमिक रूप से होता है। प्रत्येक ऑपरेशन को ऑप नोड कहा जाता है और वे एक दूसरे से जुड़े होते हैं।
ग्राफ नोड्स के बीच ऑप्स और कनेक्शन को रेखांकित करता है। हालाँकि, यह मान प्रदर्शित नहीं करता है। नोड्स का किनारा टेंसर है, यानी, डेटा के साथ ऑपरेशन को पॉप्युलेट करने का एक तरीका है।
मशीन लर्निंग में, मॉडल को फीचर वेक्टर नामक ऑब्जेक्ट की सूची के साथ फीड किया जाता है। एक फीचर वेक्टर किसी भी डेटा प्रकार का हो सकता है। फीचर वेक्टर आमतौर पर टेंसर को पॉप्युलेट करने के लिए प्राथमिक इनपुट होगा। ये मान टेंसर के माध्यम से एक ऑप नोड में प्रवाहित होंगे और इस ऑपरेशन/कंप्यूटेशन का परिणाम एक नया टेंसर बनाएगा जिसका उपयोग बदले में एक नए ऑपरेशन में किया जाएगा। इन सभी ऑपरेशनों को ग्राफ में देखा जा सकता है।
टेंसर का प्रतिनिधित्व
TensorFlow में, टेंसर n-आयामों के फ़ीचर वैक्टर (यानी, सरणी) का एक संग्रह है। उदाहरण के लिए, यदि हमारे पास 2 से 3 तक के मानों वाला 1×6 मैट्रिक्स है, तो हम लिखते हैं:
TensorFlow इस मैट्रिक्स को इस प्रकार दर्शाता है:
[[1, 2, 3], [4, 5, 6]]
यदि हम 1 से 8 तक के मानों वाला एक त्रि-आयामी मैट्रिक्स बनाते हैं, तो हमें यह प्राप्त होता है:
TensorFlow इस मैट्रिक्स को इस प्रकार दर्शाता है:
[ [[1, 2],
[[3, 4],
[[5, 6],
[[7,8] ]
नोट: टेंसर को स्केलर के साथ दर्शाया जा सकता है या इसका आकार तीन से ज़्यादा आयामों का हो सकता है। उच्च आयाम स्तर को देखना बस ज़्यादा जटिल है।
टेंसर के प्रकार
TensorFlow में, सभी गणनाएँ एक या अधिक टेंसर से होकर गुजरती हैं। tf.tensor एक ऑब्जेक्ट है जिसमें तीन गुण होते हैं:
- एक अद्वितीय लेबल (नाम)
- एक आयाम (आकार)
- डेटा प्रकार (dtype)
TensorFlow के साथ आप जो भी ऑपरेशन करेंगे, उसमें टेंसर का हेरफेर शामिल होगा। आप चार मुख्य टेंसर प्रकार बना सकते हैं:
- tf.चर
- tf.स्थिरांक
- tf.प्लेसहोल्डर
- tf.स्पार्सटेन्सर
इस ट्यूटोरियल में, आप सीखेंगे कि tf.constant और tf.Variable कैसे बनाएं।
ट्यूटोरियल में आगे बढ़ने से पहले, सुनिश्चित करें कि आपने TensorFlow के साथ conda वातावरण को सक्रिय कर लिया है। हमने इस वातावरण का नाम hello-tf रखा है।
MacOS उपयोगकर्ता के लिए:
source activate hello-tf
के लिए Windows उपयोगकर्ता:
activate hello-tf
ऐसा करने के बाद, आप tensorflow को आयात करने के लिए तैयार हैं
# Import tf import tensorflow as tf
N-आयाम का एक टेंसर बनाएं
आप एक आयाम वाले टेंसर, अर्थात् स्केलर, के निर्माण से शुरुआत करते हैं।
टेंसर बनाने के लिए, आप 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 name r1 = tf.constant(1, tf.int16) print(r1)
उत्पादन
Tensor("Const:0", shape=(), dtype=int16)
# Named my_scalar r2 = tf.constant(1, tf.int16, name = "my_scalar") print(r2)
उत्पादन
Tensor("my_scalar:0", shape=(), dtype=int16)
प्रत्येक टेंसर को टेंसर नाम से प्रदर्शित किया जाता है। प्रत्येक टेंसर ऑब्जेक्ट को टेंसर विशेषताओं जैसे कि एक अद्वितीय लेबल (नाम), एक आयाम (आकार) और TensorFlow डेटा प्रकार (dtype) के साथ परिभाषित किया जाता है।
आप डेटा का प्रकार बदलकर टेंसर को दशमलव मानों या स्ट्रिंग के साथ परिभाषित कर सकते हैं।
# Decimal
r1_decimal = tf.constant(1.12345, tf.float32)
print(r1_decimal)
# String
r1_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 टेंसर आयामों की एक सरणी बनाने के लिए, आपको प्रत्येक पंक्ति के बाद कोष्ठक बंद करने की आवश्यकता है। नीचे दिए गए केरास टेंसर आकार उदाहरण को देखें
## Rank 2
r2_matrix = tf.constant([ [1, 2],
[3, 4] ],tf.int16)
print(r2_matrix)
उत्पादन
Tensor("Const_5:0", shape=(2, 2), dtype=int16)
मैट्रिक्स में 2 पंक्तियाँ और 2 कॉलम हैं जो 1, 2, 3, 4 मानों से भरे हैं।
कोष्ठकों के साथ एक और स्तर जोड़कर 3 आयामों वाला एक मैट्रिक्स बनाया जाता है।
## Rank 3
r3_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 tensor
m_shape = tf.constant([ [10, 11],
[12, 13],
[14, 15] ]
)
m_shape.shape
उत्पादन
TensorShape([Dimension(3), Dimension(2)])
मैट्रिक्स में 3 पंक्तियाँ और 2 कॉलम हैं।
TensorFlow में 0 या 1 से भरा वेक्टर या मैट्रिक्स बनाने के लिए उपयोगी कमांड हैं। उदाहरण के लिए, यदि आप 1 के विशिष्ट आकार के साथ 10-डी टेंसर बनाना चाहते हैं, जो 0 से भरा हो, तो आप नीचे दिए गए कोड को चला सकते हैं:
# Create a vector of 0 print(tf.zeros(10))
उत्पादन
Tensor("zeros:0", shape=(10,), dtype=float32)
यह गुण मैट्रिक्स के लिए भी काम करता है। यहाँ, आप 10 से भरा 10×1 मैट्रिक्स बनाते हैं
# Create a vector of 1 print(tf.ones([10, 10]))
उत्पादन
Tensor("ones:0", shape=(10, 10), dtype=float32)
आप किसी दिए गए मैट्रिक्स के आकार का उपयोग करके एक का सदिश बना सकते हैं। मैट्रिक्स m_shape 3×2 आयाम है। आप निम्न कोड के साथ एक टेंसर बना सकते हैं जिसमें 3 पंक्तियाँ हों और एक से भरी हों:
# Create a vector of ones with the same number of rows as m_shape print(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_shape print(tf.ones(m_shape.shape[1]))
उत्पादन
Tensor("ones_2:0", shape=(2,), dtype=float32)
अंत में, आप केवल एक के साथ एक मैट्रिक्स 3 × 2 बना सकते हैं
print(tf.ones(m_shape.shape))
उत्पादन
Tensor("ones_3:0", shape=(3, 2), dtype=float32)
डेटा का प्रकार
टेंसर की दूसरी प्रॉपर्टी डेटा का प्रकार है। टेंसर में एक समय में सिर्फ़ एक ही प्रकार का डेटा हो सकता है। टेंसर में सिर्फ़ एक ही प्रकार का डेटा हो सकता है। आप प्रॉपर्टी dtype के साथ प्रकार लौटा सकते हैं।
print(m_shape.dtype)
उत्पादन
<dtype: 'int32'>
कुछ अवसरों पर, आप डेटा का प्रकार बदलना चाहते हैं। TensorFlow में, यह tf.cast विधि से संभव है।
उदाहरण
नीचे, एक फ्लोट टेंसर को कास्ट विधि का उपयोग करके पूर्णांक में परिवर्तित किया गया है।
# Change type of data type_float = tf.constant(3.123456789, tf.float32) type_int = tf.cast(type_float, dtype=tf.int32) print(type_float.dtype) print(type_int.dtype)
उत्पादन
<dtype: 'float32'> <dtype: 'int32'>
टेंसर के निर्माण के दौरान जब तर्क निर्दिष्ट नहीं किया जाता है, तो टेंसरफ़्लो स्वचालित रूप से डेटा का प्रकार चुनता है। टेंसरफ़्लो अनुमान लगाएगा कि डेटा का सबसे संभावित प्रकार क्या है। उदाहरण के लिए, यदि आप कोई टेक्स्ट पास करते हैं, तो यह अनुमान लगाएगा कि यह एक स्ट्रिंग है और इसे स्ट्रिंग में बदल देगा।
ऑपरेटर बनाना
कुछ उपयोगी TensorFlow ऑपरेटर
आप जानते हैं कि TensorFlow के साथ टेंसर कैसे बनाया जाता है। अब समय है गणितीय संक्रियाएँ करना सीखने का।
TensorFlow में सभी बुनियादी ऑपरेशन शामिल हैं। आप एक सरल ऑपरेशन से शुरुआत कर सकते हैं। आप किसी संख्या का वर्ग निकालने के लिए TensorFlow विधि का उपयोग करेंगे। यह ऑपरेशन सीधा है क्योंकि टेंसर बनाने के लिए केवल एक तर्क की आवश्यकता होती है।
किसी संख्या का वर्ग tf.sqrt(x) से बनाया जाता है, जिसमें 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.गुणा(ए, बी)
- tf.div(ए, बी)
- tf.pow(ए, बी)
- tf.exp(ए)
- tf.sqrt(ए)
उदाहरण
# Add tensor_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 वाला एक टेंसर
आप दोनों टेंसरों को जोड़िए।
नोटिस: दोनों टेंसरों का आकार एक जैसा होना चाहिए। आप दो टेंसरों पर गुणन कर सकते हैं।
# Multiply tensor_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. Optional If initializer is specified, there is no need to include the `values` as the shape of `initializer` is used.
उदाहरण के लिए, नीचे दिया गया कोड दो यादृच्छिक मानों वाला एक द्वि-आयामी चर बनाता है। डिफ़ॉल्ट रूप से, TensorFlow एक यादृच्छिक मान लौटाता है। आप चर का नाम var रखते हैं
# Create a Variable
## Create 2 Randomized values
var = 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 हैं। नये टेंसर का आकार 2×2 होगा।
# Create a 2x2 matrixtensor_const = tf.constant([[10, 20],
[30, 40]])
# Initialize the first value of the tensor equals to tensor_const
var_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. Optional data_placeholder_a = tf.placeholder(tf.float32, name = "data_placeholder_a") print(data_placeholder_a)
उत्पादन
Tensor("data_placeholder_a:0", dtype=float32)
अधिवेशन
TensorFlow तीन मुख्य घटकों पर काम करता है:
- ग्राफ
- टेन्सर
- अधिवेशन
| अवयव | वर्णन |
|---|---|
| ग्राफ | TensorFlow में ग्राफ मूलभूत है। सभी गणितीय ऑपरेशन (ऑप्स) एक ग्राफ के अंदर किए जाते हैं। आप ग्राफ को एक प्रोजेक्ट के रूप में कल्पना कर सकते हैं जहाँ हर ऑपरेशन किया जाता है। नोड्स इन ऑप्स का प्रतिनिधित्व करते हैं, वे नए टेंसर को अवशोषित या बना सकते हैं। |
| टेन्सर | टेंसर उन डेटा को दर्शाता है जो ऑपरेशन के बीच आगे बढ़ते हैं। आपने पहले देखा कि टेंसर को कैसे आरंभ किया जाता है। स्थिरांक और चर के बीच का अंतर यह है कि चर के प्रारंभिक मान समय के साथ बदलेंगे। |
| अधिवेशन | एक सत्र ग्राफ से ऑपरेशन निष्पादित करेगा। टेंसर के मानों के साथ ग्राफ को फीड करने के लिए, आपको एक सत्र खोलना होगा। एक सत्र के अंदर, आपको आउटपुट बनाने के लिए एक ऑपरेटर चलाना होगा। |
ग्राफ़ और सत्र स्वतंत्र हैं। आप एक सत्र चला सकते हैं और आगे की गणनाओं के लिए बाद में उपयोग करने के लिए मान प्राप्त कर सकते हैं।
नीचे दिए गए उदाहरण में, आप:
- दो टेंसर बनाएं
- एक ऑपरेशन बनाएँ
- एक सत्र खोलें
- परिणाम प्रिंट करें
चरण 1) आप दो टेंसर x और y बनाते हैं
## Create, run and evaluate a session x = tf.constant([2]) y = tf.constant([4])
चरण 2) आप x और y को गुणा करके ऑपरेटर बनाते हैं
## Create operator multiply = tf.multiply(x, y)
चरण 3) आप एक सत्र खोलते हैं। सभी गणनाएँ सत्र के भीतर ही होंगी। जब आपका काम पूरा हो जाए, तो आपको सत्र बंद करना होगा।
## Create a session to run the code sess = tf.Session()result_1 = sess.run(multiply) print(result_1) sess.close()
उत्पादन
[8]
कोड स्पष्टीकरण
- tf.Session(): सत्र खोलें। सभी ऑपरेशन सत्रों के भीतर ही चलेंगे
- run(multiply): चरण 2 में बनाए गए ऑपरेशन को निष्पादित करें।
- प्रिंट(परिणाम_1): अंत में, आप परिणाम प्रिंट कर सकते हैं
- close(): सत्र बंद करें
परिणाम 8 दर्शाता है, जो x और y का गुणनफल है।
सत्र बनाने का दूसरा तरीका ब्लॉक के अंदर है। इसका फ़ायदा यह है कि यह सत्र को स्वचालित रूप से बंद कर देता है।
with tf.Session() as sess: result_2 = multiply.eval() print(result_2)
उत्पादन
[8]
सत्र के संदर्भ में, आप ऑपरेशन को निष्पादित करने के लिए eval() विधि का उपयोग कर सकते हैं। यह run() के बराबर है। यह कोड को अधिक पठनीय बनाता है।
आप एक सत्र बना सकते हैं और अब तक आपके द्वारा बनाए गए टेंसर के अंदर के मान देख सकते हैं।
## Check the tensors created before sess = 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 np
power_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.
कोड स्पष्टीकरण
- numpy को np के रूप में आयात करें: आयात करें 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 फ़ंक्शन को निष्पादित करने के लिए एक ग्राफ़ बनाएगा। ग्राफ़ इस तरह दिखता है:
आप आसानी से देख सकते हैं कि टेंसर अंतिम गंतव्य तक पहुंचने के लिए कौन सा रास्ता अपनाएगा।
उदाहरण के लिए, आप देख सकते हैं कि add ऑपरेशन और से पहले नहीं किया जा सकता है। ग्राफ बताता है कि यह:
- गणना करें और:
- 1) को एक साथ जोड़ें
- 2 में जोड़ें)
- 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: z नामक चर को 6 के स्थिर मान के साथ आरंभ करें
- c: c नामक एक स्थिर टेंसर को 5 के स्थिर मान के साथ आरंभ करें
- वर्ग: 2 के स्थिर मान के साथ वर्ग नामक एक स्थिर टेंसर को आरंभ करें
- f: ऑपरेटर का निर्माण करें
इस उदाहरण में, हम चर के मानों को स्थिर रखना चुनते हैं। हमने c नामक एक स्थिर टेंसर भी बनाया है जो फ़ंक्शन f में स्थिर पैरामीटर है। यह 5 का एक निश्चित मान लेता है। ग्राफ़ में, आप इस पैरामीटर को स्थिर नामक टेंसर में देख सकते हैं।
हमने ऑपरेटर tf.pow() में पावर के लिए एक स्थिर टेंसर भी बनाया है। यह आवश्यक नहीं है। हमने ऐसा इसलिए किया ताकि आप ग्राफ में टेंसर का नाम देख सकें। यह वह वृत्त है जिसे वर्ग कहते हैं।
ग्राफ से आप समझ सकते हैं कि टेंसर का क्या होगा और यह कैसे 66 का आउटपुट दे सकता है।
नीचे दिया गया कोड एक सत्र में फ़ंक्शन का मूल्यांकन करता है।
init = tf.global_variables_initializer() # prepare to initialize all variables
with tf.Session() as sess:
init.run() # Initialize x and y
function_result = f.eval()
print(function_result)
उत्पादन
[66]
सारांश
TensorFlow इसके आसपास काम करता है:
- ग्राफ: संचालन और टेंसर युक्त कम्प्यूटेशनल वातावरण
- tensors: ग्राफ़ में प्रवाहित होने वाले डेटा (या मान) को दर्शाता है। यह ग्राफ़ में किनारा है
- सत्र: परिचालनों के निष्पादन की अनुमति दें
एक स्थिर टेंसर बनाएं
| स्थिर | वस्तु |
|---|---|
| D0 | tf.स्थिरांक(1, tf.int16) |
| D1 | tf.स्थिर([1,3,5], tf.int16) |
| D2 | tf.constant([ [1, 2], [3, 4] ],tf.int16) |
| D3 | tf.constant([ [[1, 2],[3, 4], [5, 6]] ], tf.int16) |
एक ऑपरेटर बनाएं
| एक ऑपरेटर बनाएं | वस्तु |
|---|---|
| ए + बी | tf.add(ए, बी) |
| ए * बी | tf.गुणा(ए, बी) |
एक परिवर्तनीय टेंसर बनाएँ
| एक चर बनाएँ | वस्तु |
|---|---|
| यादृच्छिक मूल्य | tf.get_variable(“var”, [1, 2]) |
| आरंभीकृत प्रथम मान | tf.get_variable(“var_init_2”, dtype=tf.int32, आरंभकर्ता=[ [1, 2], [3, 4] ]) |
एक सत्र खोलें
| अधिवेशन | वस्तु |
|---|---|
| सत्र बनाएं | tf.सत्र() |
| सत्र चलाएँ | tf.सत्र.रन() |
| टेंसर का मूल्यांकन करें | variable_name.eval() |
| सत्र बंद करें | सत्र.बंद() |
| ब्लॉक के अनुसार सत्र | tf.Session() को sess के रूप में उपयोग करते हुए: |