TensorFlow ट्यूटोरियल: 10 मिनट TensorFlow शुरुआत ट्यूटोरियल [अनुवाद]

नमस्कार, हेब्र! मैं आपके लिए अंकित सचान द्वारा "TensorFlow Tutorial: 10 मिनट प्रैक्टिकल टेनसफ़्लो सबक फॉर क्विक लर्नर्स" लेख का अनुवाद प्रस्तुत करता हूँ।

यह TensorFlow ट्यूटोरियल मशीन सीखने की बुनियादी समझ रखने वाले किसी भी व्यक्ति के लिए है और TensorFlow के साथ शुरुआत करने की कोशिश कर रहा है।

सबसे पहले, आपके पास TensorFlow स्थापित होना चाहिए। आप इसे इस गाइड में स्थापित कर सकते हैं। इस पाठ को दो भागों में विभाजित किया गया है: पहले भाग में हम एक काम करने वाले उदाहरण के साथ मूल बातें समझाते हैं, दूसरे भाग में हम एक रेखीय प्रतिगमन मॉडल का निर्माण करते हैं।

भाग 1. टेंसोरफ्लो मूल बातें

TensorFlow एक संख्यात्मक पुस्तकालय है जिसमें डेटा एक ग्राफ से गुजरता है। TensorFlow में डेटा n- आयामी सरणियों द्वारा दर्शाया गया है - दसियों। ग्राफ डेटा (दसियों) और गणितीय कार्यों से बना है।

ग्राफ के नोड्स में गणितीय संक्रियाएं हैं।

ग्राफ़ के किनारे दसियों का प्रतिनिधित्व करते हैं जो संचालन के बीच "प्रवाह" करते हैं।

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

चलो करके सीखना शुरू करते हैं। अजगर चलाएँ और TensorFlow आयात करें:

~$ python Python 2.7.6 (default, Oct 26 2016, 20:30:19) [GCC 4.8.4] on linux2 Type "help", "copyright", "credits" or "license" for more information. >>> >>>import tensorflow as tf 

एक ग्राफ का उपयोग ऑपरेशनों को परिभाषित करने के लिए किया जाता है, और सभी ऑपरेशन एक सत्र में किए जाते हैं। ग्राफ और सत्र एक-दूसरे से स्वतंत्र रूप से बनाए जाते हैं। एक निर्माण परियोजना के रूप में ग्राफ और एक निर्माण स्थल के रूप में सत्र को समझो।

1.1। TensorFlow में रेखांकन

एक ग्राफ TensorFlow का आधार है, सभी गणना (संचालन), चर ग्राफ पर हैं। कोड में जो कुछ भी होता है वह TensorFlow द्वारा प्रदान किए गए डिफ़ॉल्ट ग्राफ़ पर होता है। आप इस ग्राफ को इस प्रकार एक्सेस कर सकते हैं:

 graph = tf.get_default_graph() 

और इसलिए आप इस कॉलम में सभी ऑपरेशनों की सूची प्राप्त कर सकते हैं:

 graph.get_operations() 

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

 for op in graph.get_operations(): print(op.name) 

आउटपुट फिर से रिक्त हो जाएगा। भविष्य में, ग्राफ़ में संचालन जोड़ने के बाद, हम उनके नाम प्रदर्शित करने के लिए इस कोड का उपयोग करेंगे।

1.2। TensorFlow में सत्र

ग्राफ केवल गणना को परिभाषित करता है (परियोजना बनाता है), लेकिन कोई चर, कोई मूल्य नहीं है, जब तक कि हम सत्र में ग्राफ या ग्राफ के हिस्से को नहीं चलाते हैं।

आप इस तरह एक सत्र बना सकते हैं:

 sess=tf.Session() ... your code ... ... your code ... sess.close() 

यह मत भूलो कि एक सत्र शुरू करने के लिए आपको इसे समाप्त करने या इसके साथ उपयोग करने की आवश्यकता है ... ब्लॉक के रूप में , उदाहरण के लिए इस तरह:

 with tf.Session() as sess: sess.run(f) 

इस दृष्टिकोण का उपयोग करने का लाभ यह है कि सत्र को ब्लॉक के अंत में स्वचालित रूप से बंद कर दिया जाएगा

1.3। TensorFlow में सेंसर

TensorFlow डेटा को दसियों में संग्रहीत करता है - बहुआयामी सरणियों को numPy सरणियों के समान।

a) लगातार ऐसे मान हैं जिन्हें बदला नहीं जा सकता है। उन्हें निम्नानुसार परिभाषित किया गया है:

 a=tf.constant(1.0) 

हालाँकि, जब आप आउटपुट की कोशिश करते हैं, तो आपको निम्नलिखित मिलते हैं:

 print(a) <tf.Tensor'Const:0' shape=() dtype=float32> print(a) Tensor("Const:0", shape=(), dtype=float32) 

जैसा कि आप देख सकते हैं, यह अन्य प्रोग्रामिंग भाषाओं से अलग है, जैसे कि अजगर। जब तक आप सत्र शुरू नहीं करते तब आप निरंतर प्रिंट या एक्सेस नहीं कर सकते। ऐसा करते हैं:

 with tf.Session() as sess: print(sess.run(a)) 

यह कोड 1.0 आउटपुट करेगा

ख) चर भी दसियों हैं जो अन्य प्रोग्रामिंग भाषाओं में चर की तरह हैं:

 >>>b = tf.Variable(2.0,name="test_var") >>>b <tensorflow.python.ops.variables.Variable object at 0x7f37ebda1990> 

स्थिरांक के विपरीत, चर अपनी सामग्री को बदल सकते हैं। हालाँकि, TensorFlow में वैरिएबल को एक अलग इनिशियलाइज़ेशन ऑपरेशन में आरंभीकृत किया जाना चाहिए। सभी वेरिएबल्स को इनिशियलाइज़ करने में काफी समय लग सकता है, लेकिन TensorFlow सभी वेरिएबल्स को एक साथ शुरू करने के लिए एक तंत्र प्रदान करता है:

 init_op = tf.global_variables_initializer() 

चर को एक्सेस करने का प्रयास करने से पहले अब आपको इनिशियलाइज़ेशन ऑपरेशन शुरू करने की आवश्यकता है:

 with tf.Session() as sess: sess.run(init_op) print(sess.run(b)) 

यह कोड 2.0 आउटपुट करेगा
यदि आप अब ग्राफ़ में ऑपरेशन प्रिंट करने का प्रयास करते हैं

 graph = tf.get_default_graph() for op in graph.get_operations(): print(op.name) 

आपको निम्न आउटपुट मिलेगा:

 Const test_var/initial_value test_var test_var/Assign test_var/read init 

जैसा कि आप देख सकते हैं, हमने "ए" को कास्ट घोषित किया और इसे चार्ट में जोड़ा गया। इसी तरह, वेरिएबल b के लिए, कई test_var राज्यों को TensorFlow ग्राफ में जोड़ा गया, जैसे test_var / initial_value, test_var / read, आदि। आप TensorBoard का उपयोग करके पूरे नेटवर्क की कल्पना कर सकते हैं, जो TensorFlow ग्राफ और सीखने की प्रक्रिया को समझने के लिए एक उपकरण है। ।

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

 a = tf.placeholder("float") b = tf.placeholder("float") y = tf.multiply(a, b) fd = {a: 2, b: 3} with tf.Session() as sess: print(sess.run(y, fd)) 

यह कोड 6.0 आउटपुट करेगा

1.4। TensorFlow में उपकरण

TensorFlow में GPU, CPU या क्लस्टर पर अपना कोड चलाने के लिए बहुत शक्तिशाली अंतर्निहित विशेषताएं हैं। यह आपको उस डिवाइस को चुनने का अवसर देता है जिस पर आप अपना कोड चलाना चाहते हैं। हालाँकि, यह सोचने वाली बात नहीं है कि आप टीएफ के साथ शुरुआत कब कर रहे हैं।
तो यहाँ एक पूरी तस्वीर है कि TensorFlow में गणना कैसे काम करती है:

भाग 2. TensorFlow ट्यूटोरियल एक सरल उदाहरण के साथ

इस भाग में, हम रैखिक प्रतिगमन को चलाने के लिए कोड को देखेंगे। इससे पहले, आइए कुछ बुनियादी TensorFlow कार्यों को देखें जिन्हें हम कोड में उपयोग करेंगे।

एक यादृच्छिक सामान्य वितरण बनाना:

सामान्य वितरण से यादृच्छिक मान बनाने के लिए random_normal का उपयोग करें। इस उदाहरण में, w 0.01 के मानक विचलन के साथ यादृच्छिक मूल्यों के साथ 784 * 10 आयाम का एक चर है।

 w=tf.Variable(tf.random_normal([784, 10], stddev=0.01)) 

Reduce_mean - किसी सरणी के औसत मान की गणना करता है

 b = tf.Variable([10,20,30,40,50,60],name='t') with tf.Session() as sess: sess.run(tf.initialize_all_variables()) sess.run(tf.reduce_mean(b)) 

यह कोड 35 आउटपुट करेगा

argmax - पायथन में argmax के समान। निर्दिष्ट अक्ष के साथ टेंसर से अधिकतम मूल्य प्राप्त करता है।

 a=[ [0.1, 0.2, 0.3 ], [20, 2, 3 ] ] b = tf.Variable(a,name='b') with tf.Session() as sess: sess.run(tf.initialize_all_variables()) sess.run(tf.argmax(b,1)) 

एक सरणी ([2, 0]) प्रिंट करें जो प्रत्येक पंक्ति में अधिकतम मान का सूचकांक दिखाता है।

रैखिक प्रतिगमन समस्या

समस्या कथन: बड़ी संख्या में डेटा बिंदु हैं, जो उनके साथ एक सीधी रेखा से मेल खाने की कोशिश कर रहे हैं। इस उदाहरण के लिए, हम 100 डेटा पॉइंट बनाएंगे और उनके साथ लाइन का मिलान करने का प्रयास करेंगे।

2.1। एक प्रशिक्षण डेटासेट बनाएं

ट्रेनएक्स में -1 और 1 के बीच मान होते हैं, और ट्रेन में ट्रेनएक्स के मूल्य से 3 गुना अधिक और कुछ यादृच्छिक चर होते हैं:

 import tensorflow as tf import numpy as np trainX = np.linspace(-1, 1, 101) trainY = 3 * trainX + np.random.randn(*trainX.shape) * 0.33 

2.2। प्लेसहोल्डर

 X = tf.placeholder("float") Y = tf.placeholder("float") 

2.3। मोडलिंग

रैखिक प्रतिगमन मॉडल का रूप है

$$

$$यमोडेल = w * x$$

- हमें w के मूल्य की गणना करनी चाहिए। आइए w को शून्य करें और इस समस्या को हल करने के लिए एक मॉडल बनाएं। हम लागत समारोह को परिभाषित करते हैं

$$

$$(Y-y__model) ^ 2$$

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

 w = tf.Variable(0.0, name="weights") y_model = tf.multiply(X, w) cost = (tf.pow(Y-y_model, 2)) train_op = tf.train.GradientDescentOptimizer(0.01).minimize(cost) 

2.4। ट्रेनिंग

इस बिंदु तक, हमने केवल एक ग्राफ को परिभाषित किया है। कोई गणना नहीं हुई है, TensorFlow चर में से कोई भी बात नहीं है। इस ग्राफ़ को चलाने के लिए, हमें एक सत्र बनाने और इसे निष्पादित करने की आवश्यकता है। इससे पहले, हमें सभी चर के लिए एक इनिशियलाइज़ेशन ऑपरेशन बनाने की आवश्यकता है:

 init = tf.initialize_all_variables() with tf.Session() as sess: sess.run(init) for i in range(100): for (x, y) in zip(trainX, trainY): sess.run(train_op, feed_dict={X: x, Y: y}) print(sess.run(w)) 

ध्यान दें कि पहली बात यह थी कि सत्र .run () के भीतर init को कॉल करके वेरिएबल्स को इनिशियलाइज़ करना था। बाद में हम उसे feed_dict खिलाकर train_op चलाते हैं । अंत में, हम w (फिर से sess.run ()) के मान को प्रिंट करते हैं, जो लगभग 3 होना चाहिए।

व्यायाम:

यदि आप इस कोड के बाद एक नया सत्र बनाते हैं और w को प्रिंट करने का प्रयास करते हैं, तो आउटपुट क्या होगा?

 with tf.Session() as sess: sess.run(init) print(sess.run(w)) 

हां, आपने सही तरीके से समझा, 0.0 प्रदर्शित किया जाएगा। जैसे ही हमने पहले बनाए गए सत्र को छोड़ दिया, सभी ऑपरेशनों का अस्तित्व समाप्त हो गया।

मुझे उम्मीद है कि यह ट्यूटोरियल आपको TensorFlow के साथ एक त्वरित शुरुआत देता है। कृपया टिप्पणी में अपने सवाल पूछने के लिए स्वतंत्र महसूस करें। पूरा कोड यहां डाउनलोड किया जा सकता है ।