TensorFlow में चरणों और युगों के बीच अंतर क्या है?

Question

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

1 युग के साथ 1000 कदम चलने और 10 युग के साथ 100 कदम चलने में क्या अंतर है? व्यवहार में कौन सा बेहतर है? लगातार युगों के बीच कोई तर्क बदलता है? डेटा फेरबदल?

Comments

Machinelearningmastery.com पर जेसन ब्राउनली के पास उस सवाल का बहुत अच्छा, विस्तृत जवाब है।

— बेमुगेस्ट

Answer 1

एक युग में आमतौर पर सभी प्रशिक्षण डेटा पर एक पुनरावृत्ति का अर्थ है। उदाहरण के लिए यदि आपके पास 20,000 चित्र हैं और 100 का बैच आकार है, तो युग में 20,000 / 100 = 200 चरण होने चाहिए। हालाँकि, मैं आमतौर पर एक निश्चित संख्या निर्धारित करता हूं जैसे कि 1000 प्रति युग, हालांकि मेरे पास बहुत बड़ा डेटा सेट है। युग के अंत में मैं औसत लागत की जांच करता हूं और अगर इसमें सुधार हुआ है तो मैं एक चौकी बचा सकता हूं। एक युग से दूसरे युग के चरणों में कोई अंतर नहीं है। मैं उन्हें सिर्फ चौकियों की तरह मानता हूं।

लोग अक्सर युगों के बीच निर्धारित आंकड़ों के आसपास फेरबदल करते हैं। मैं अपने युगों में प्रक्रिया के लिए डेटा चुनने के लिए random.sample फ़ंक्शन का उपयोग करना पसंद करता हूं। तो कहते हैं कि मैं 32 के बैच आकार के साथ 1000 कदम करना चाहता हूं। मैं प्रशिक्षण डेटा के पूल से केवल 32,000 नमूने लेगा।

Comments

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

— मारविन्द

Answer 2

एक प्रशिक्षण कदम एक क्रमिक अद्यतन है। एक चरण में batch_size कई उदाहरण संसाधित होते हैं।

एक युग में प्रशिक्षण डेटा के माध्यम से एक पूर्ण चक्र होता है। यह आमतौर पर कई चरणों है। एक उदाहरण के रूप में, यदि आपके पास 2,000 चित्र हैं और 10 के बैच आकार का उपयोग करते हैं, तो 2,000 चित्र / (10 चित्र / चरण) = 10 चरण होते हैं।

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

Comments

मैंने 200 चरणों की गणना के लिए एक संपादन किया, लेकिन लॉग इन करना भूल गया, इसलिए यदि आप "अज्ञात उपयोगकर्ता" से बात करना चाहते हैं ... मैं यहाँ हूँ

— क्रिस चियासन

Answer 3

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

द्वारा परिभाषित प्रशिक्षण चरण num_epochs: stepsस्पष्ट रूप से परिभाषित नहीं

estimator = tf.estimator.LinearRegressor(feature_columns=ft_cols)
train_input =  tf.estimator.inputs.numpy_input_fn({'x':x_train},y_train,batch_size=4,num_epochs=1,shuffle=True)
estimator.train(input_fn=train_input)

टिप्पणी: मैंने num_epochs=1प्रशिक्षण इनपुट के लिए निर्धारित किया है और numpy_input_fnमुझे "num_epochs: पूर्णांक: डेटा पर पुनरावृत्ति करने के लिए युगों की संख्या। मुझे Noneहमेशा के लिए चलेगा।" । साथ num_epochs=1ऊपर के उदाहरण में प्रशिक्षण वास्तव में चलाता है x_train.size / batch_size बार / कदम (मेरे मामले में यह 175000 कदम के रूप में था x_train700000 के एक आकार था और batch_size4) था।

द्वारा परिभाषित प्रशिक्षण कदम num_epochs: stepsस्पष्ट रूप से परिभाषित चरणों की संख्या से अधिक स्पष्ट रूप से परिभाषित किया गया हैnum_epochs=1

estimator = tf.estimator.LinearRegressor(feature_columns=ft_cols)
train_input =  tf.estimator.inputs.numpy_input_fn({'x':x_train},y_train,batch_size=4,num_epochs=1,shuffle=True)
estimator.train(input_fn=train_input, steps=200000)

टिप्पणी: num_epochs=1मेरे मामले में इसका मतलब होगा 175000 कदम ( x_train.size / batch_size with x_train.size = 700,000 और batch_size = 4 ) और यह ठीक कदमों की संख्या है, estimator.trainजिससे कदम पैरामीटर 200,000 पर सेट किया गया था estimator.train(input_fn=train_input, steps=200000)।

द्वारा परिभाषित प्रशिक्षण कदम steps

estimator = tf.estimator.LinearRegressor(feature_columns=ft_cols)
train_input =  tf.estimator.inputs.numpy_input_fn({'x':x_train},y_train,batch_size=4,num_epochs=1,shuffle=True)
estimator.train(input_fn=train_input, steps=1000)

टिप्पणी: हालांकि मैं निर्धारित किया है num_epochs=1जब बुला numpy_input_fn1000 चरणों के बाद प्रशिक्षण बंद हो जाता है। इसका कारण यह है है steps=1000में estimator.train(input_fn=train_input, steps=1000)अधिलेखित कर देता है num_epochs=1में tf.estimator.inputs.numpy_input_fn({'x':x_train},y_train,batch_size=4,num_epochs=1,shuffle=True)।

निष्कर्ष : जो कुछ भी मानकों num_epochsके लिए tf.estimator.inputs.numpy_input_fnऔर stepsके लिए estimator.trainपरिभाषित करते हैं, लोअर बाउंड चरणों के माध्यम से जो चलाया जाएगा की संख्या निर्धारित करता है।

Answer 4

आसान शब्दों में
युग: एपोच को संपूर्ण डेटासेट से एक पास की संख्या के रूप में माना जाता है
: टेनसफ़्लो में एक कदम को बैच आकार द्वारा विभाजित उदाहरणों से गुणा किए गए युगों की संख्या माना जाता है।

steps = (epoch * examples)/batch size
For instance
epoch = 100, examples = 1000 and batch_size = 1000
steps = 100

Comments

उमर, मुझे आपके फॉर्मूले का उपयोग करके एक बेहतर परिणाम मिला है लेकिन आप सोच रहे हैं कि हर किसी का फॉर्मूला अलग क्यों होता है? जैसा कि ऊपर अन्य सभी कहते हैं, चरण = (चित्रों की कुल संख्या) / बैच आकार।

— सत्येंद्र सहनी

@SatyendraSahani मुझे यह फॉर्मूला जीसीपी कोर्स के इंस्ट्रक्टर में से एक से मिला है जो कि सेसर में पेश किया जाता है, हो सकता है कि यह वही हो जो आपको बेहतर परिणाम मिले।

— मुहम्मद उमर अमानत

@ उमर, लेकिन कुछ समय में नमूनों की संख्या बहुत बड़ी है। जैसे हमारे मामले में हमारे पास 99,000 नमूने हैं। यदि हम एक बैच आकार 8 और युग 20 चुनते हैं, तो कुल step_size की संख्या (20 * 99000) / 8 = 247,500 है। जो वास्तव में एक उच्च संख्या है। वहाँ मुझे इस विधि पर संदेह होने लगा।

— सत्येंद्र सहानी ०

Answer 5

एपोच: एक प्रशिक्षण युग ग्रैडिएंट्स गणना और अनुकूलन (मॉडल को प्रशिक्षित) के लिए सभी प्रशिक्षण डेटा का पूर्ण उपयोग दर्शाता है।

चरण: प्रशिक्षण चरण का अर्थ है मॉडल को प्रशिक्षित करने के लिए एक बैच आकार के प्रशिक्षण डेटा का उपयोग करना।

प्रति युग प्रशिक्षण चरणों की संख्या: total_number_of_training_examples/ batch_size।

प्रशिक्षण चरणों की कुल संख्या: number_of_epochsx Number of training steps per epoch।

Answer 6

चूंकि अभी तक कोई स्वीकृत उत्तर नहीं है: डिफ़ॉल्ट रूप से आपके सभी प्रशिक्षण डेटा पर एक युग चलता है। इस मामले में आपके पास n कदम है, n = Training_lenght / batch_size के साथ।

अपने प्रशिक्षण डेटा बहुत बड़ा है, तो आप एक युग के दौरान चरणों की संख्या सीमित करने के लिए तय कर सकते हैं। [ Https://www.tensorflow.org/tutorials/structured_data/time_series?_sm_byp=iVVF1rD6n2Q68VSN]

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

जैसे कि 1 युग के लिए 1000 कदम या 10 युगों के साथ 100 चरणों को सेट करना बेहतर है, मुझे नहीं पता कि क्या कोई सीधा जवाब है। लेकिन यहाँ TensorFlow timeseries डेटा ट्यूटोरियल्स का उपयोग करके दोनों दृष्टिकोणों के साथ CNN का प्रशिक्षण दिया गया है:

इस मामले में, दोनों दृष्टिकोण बहुत समान भविष्यवाणी की ओर ले जाते हैं, केवल प्रशिक्षण प्रोफाइल भिन्न होती है।

चरण = 20 / युग = 100

चरण = 200 / युग = 10