tensorflow - english - acronym meaning in hindi




एक्रोनिम का अर्थ Dat_ (4)

buffer_size में buffer_size महत्व shuffle()

मैं tf.data.Dataset.shuffle() में tf.data.Dataset.shuffle() के महत्व पर buffer_size देने के लिए @mrry से पिछले उत्तर का अनुसरण करना चाहता था।

कम buffer_size होने से आपको कुछ मामलों में सिर्फ हीनता नहीं होगी: यह आपके पूरे प्रशिक्षण को गड़बड़ कर सकता है।

एक व्यावहारिक उदाहरण: कैट क्लासिफायरियर

उदाहरण के लिए मान लीजिए कि आप चित्रों पर कैट क्लासिफायरशिप का प्रशिक्षण ले रहे हैं, और आपका डेटा निम्न तरीके से व्यवस्थित है (प्रत्येक श्रेणी में 10000 चित्र के साथ):

train/
    cat/
        filename_00001.jpg
        filename_00002.jpg
        ...
    not_cat/
        filename_10001.jpg
        filename_10002.jpg
        ...

tf.data साथ डेटा इनपुट करने का एक मानक तरीका फ़ाइल नाम की सूची और संबंधित लेबल की एक सूची हो सकती है, और डेटासेट बनाने के लिए tf.data.Dataset.from_tensor_slices() का उपयोग करें:

filenames = ["filename_00001.jpg", "filename_00002.jpg", ..., 
             "filename_10001.jpg", "filename_10002.jpg", ...]
labels = [1, 1, ..., 0, 0...]  # 1 for cat, 0 for not_cat

dataset = tf.data.Dataset.from_tensor_slices((filenames, labels))
dataset = dataset.shuffle(buffer_size=1000)  # 1000 should be enough right?
dataset = dataset.map(...)  # transform to images, preprocess, repeat, batch...

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

यहाँ यह सुनिश्चित करना है कि buffer_size 20000 से बड़ा है, या एडवांस filenames और labels में फेरबदल करना है (स्पष्ट रूप से एक ही सूचक के साथ)।

चूँकि मेमोरी में सभी फाइलनाम और लेबल को स्टोर करना कोई समस्या नहीं है, हम वास्तव में buffer_size = len(filenames) का उपयोग यह सुनिश्चित करने के लिए कर सकते हैं कि सब कुछ एक साथ मिला दिया जाएगा। भारी परिवर्तनों को लागू करने से पहले tf.data.Dataset.shuffle() को कॉल करना सुनिश्चित करें (जैसे छवियों को पढ़ना, उन्हें संसाधित करना, बैच करना ...)।

dataset = tf.data.Dataset.from_tensor_slices((filenames, labels))
dataset = dataset.shuffle(buffer_size=len(filenames)) 
dataset = dataset.map(...)  # transform to images, preprocess, repeat, batch...

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

TensorFlow documentation अनुसार, tf.contrib.data.Dataset वर्ग के tf.contrib.data.Dataset और map विधियाँ, दोनों में buffer_size नामक एक पैरामीटर है।

buffer_size विधि के लिए, पैरामीटर को buffer_size और प्रलेखन के अनुसार जाना जाता है:

बफर_साइज़: एक tf.int64 स्केलर tf.Tensor, अधिकतम संख्या तत्वों का प्रतिनिधित्व करता है जो प्रीफ़ैचिंग होने पर बफ़र्ड होंगे।

map विधि के लिए, पैरामीटर output_buffer_size और प्रलेखन के अनुसार जाना जाता है:

output_buffer_size: (वैकल्पिक) एक tf.int64 स्केलर tf.Tensor, बफ़र किए जाने वाले संसाधित तत्वों की अधिकतम संख्या का प्रतिनिधित्व करेगा।

इसी तरह shuffle विधि के लिए, एक ही मात्रा प्रकट होती है और प्रलेखन के अनुसार:

बफर_साइज़: एक tf.int64 स्केलर tf.Tensor, इस डेटासेट से उन तत्वों की संख्या का प्रतिनिधित्व करता है जिनसे नया डेटासेट सैंपल करेगा।

इन मापदंडों के बीच क्या संबंध है?

मान लीजिए कि मैं एक Dataset ऑब्जेक्ट निम्नानुसार बनाता हूं:

 tr_data = TFRecordDataset(trainfilenames)
    tr_data = tr_data.map(providefortraining, output_buffer_size=10 * trainbatchsize, num_parallel_calls\
=5)
    tr_data = tr_data.shuffle(buffer_size= 100 * trainbatchsize)
    tr_data = tr_data.prefetch(buffer_size = 10 * trainbatchsize)
    tr_data = tr_data.batch(trainbatchsize)

उपरोक्त स्निपेट में buffer मापदंडों द्वारा क्या भूमिका निभाई जा रही है?


कोड

import tensorflow as tf
def shuffle():
    ds = list(range(0,1000))
    dataset = tf.data.Dataset.from_tensor_slices(ds)
    dataset=dataset.shuffle(buffer_size=500)
    dataset = dataset.batch(batch_size=1)
    iterator = dataset.make_initializable_iterator()
    next_element=iterator.get_next()
    init_op = iterator.initializer
    with tf.Session() as sess:
        sess.run(init_op)
        for i in range(100):
            print(sess.run(next_element), end='')

shuffle()

उत्पादन

[298] [326] [2] [351] [92] [398] [72] [134] [404] [378] [238] [131] [369] [324] [35] [182] [441 ] [370] [372] [144] [77] [11] [199] [65] [346] [418] [493] [343] [444] [470] [222] [83] [61] [ 81] [३६६] [४ ९] [३ ९ ५] [३ ९९] [१ [[] [५० 36] [२ 38]] [५२४] [३ ]६] [३ ]६] [89 ]१] [३ ]१] [४9 ९] [१ ]२] [१५ ९] [१ ९ ५] [२३२] [१६०] [३५२] [४ ९ ५] [२४१] [३४४] [१२]] [३ ]२] [४२ ९] [३ ]२] [४9 ९] [५१ ९] [११६] [३ ९ ५] [१६५] [२३३] ] [३ [] [४ [६] [५५३] [१११] [170५०] [१ 57५] [५ ]१] [२१५] [५३०] [४ [] [२ ९ १] [५५] ] [२१] [२४५] [५१४] [१०३] [ ४५] [५४५] [२१ ९] [४६ [] [३३ [] [३ ९ २] [५४] [१३ ९] [३३ ९] [४४9] [४1१] [५] ९] [३२१] [३२१] [३११] [२३४] [३१४]


मैंने पाया कि @ ओलिवर-मोइन्ड्रॉट वास्तव में सही है, मैंने @ हेक्सो द्वारा बताए गए संशोधनों का उपयोग करते हुए @Houtarou Oreki द्वारा प्रदान किए गए कोड की कोशिश की। मेरे द्वारा उपयोग किया गया कोड निम्नलिखित था:

fake_data = np.concatenate((np.arange(1,500,1),np.zeros(500)))

dataset = tf.data.Dataset.from_tensor_slices(fake_data)
dataset=dataset.shuffle(buffer_size=100)
dataset = dataset.batch(batch_size=10)
iterator = dataset.make_initializable_iterator()
next_element=iterator.get_next()

init_op = iterator.initializer

with tf.Session() as sess:
    sess.run(init_op)
    for i in range(50):
        print(i)
        salida = np.array(sess.run(next_element))
        print(salida)
        print(salida.max())

कोड आउटपुट वास्तव में 1 से लेकर (बफर_साइज़ + (i * बैच_साइज़)) तक की संख्या है, जहाँ मैं आपके द्वारा अगली बार चलाने की संख्या है। मुझे लगता है कि जिस तरह से यह काम कर रहा है वह निम्नलिखित है। सबसे पहले, नकली_डेटा से बफर_साइज़ नमूने लिए जाते हैं। फिर एक-एक करके बैच_साइज के नमूने बफर से उठाए जाते हैं। हर बार जब बैच का नमूना बफर से लिया जाता है तो उसे नकली_डाटा से क्रम में लिया जाता है। मैंने निम्नलिखित कोड का उपयोग करके इस अंतिम चीज़ का परीक्षण किया:

aux = 0
for j in range (10000):
    with tf.Session() as sess:
        sess.run(init_op)
        salida = np.array(sess.run(next_element))
        if salida.max() > aux:
            aux = salida.max()

print(aux)

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

मैंने यह भी परीक्षण किया कि @mrry ने प्रदर्शन के बारे में क्या कहा, मैंने पाया कि बैच_साइज़ नमूनों की मात्रा को स्मृति में बदल देगा। मैंने निम्नलिखित कोड का उपयोग करके इसका परीक्षण किया:

dataset = dataset.shuffle(buffer_size=20)
dataset = dataset.prefetch(10)
dataset = dataset.batch(batch_size=5)

डेटासेट बदलने के कारण डेटा (RAM) का उपयोग करने से मेमोरी (RAM) में कोई परिवर्तन नहीं होता है। यह महत्वपूर्ण है जब आपका डेटा रैम में फिट नहीं होता है। मुझे लगता है कि सबसे अच्छा तरीका है कि आप अपने डेटा / file_names को फेरबदल करने से पहले उन्हें tf.dataset पर फीड करें, और फिर बफर_साइज़ का उपयोग करके बफर साइज़ को नियंत्रित करें।


TL, DR , उनके समान नामों के बावजूद, इन तर्कों का काफी अंतर है। Dataset.shuffle() में Dataset.shuffle() आपके डेटासेट की यादृच्छिकता को प्रभावित कर सकता है, और इसलिए वह क्रम जिसमें तत्वों का उत्पादन होता है। Dataset.prefetch() में Dataset.prefetch() केवल उस समय को प्रभावित करता है, जिसमें अगले तत्व का उत्पादन होता है।

buffer_size । अधिकांश buffer_size तत्वों, और पृष्ठभूमि में उस बफर को भरने के लिए एक पृष्ठभूमि धागा। (ध्यान दें कि हमने output_buffer_size से Dataset.map() output_buffer_size तर्क को हटा दिया Dataset.map() जब यह tf.contrib.data से tf.contrib.data पर tf.data । नया कोड Dataset.prefetch() map() बाद map() को समान व्यवहार प्राप्त करने के लिए उपयोग करना चाहिए।)

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

इसके विपरीत, tf.data.Dataset.shuffle() लिए buffer_size तर्क परिवर्तन की यादृच्छिकता को प्रभावित करता है। हमने डेटासेट को संभालने के लिए Dataset.shuffle() ट्रांसफ़ॉर्मेशन (जैसे tf.train.shuffle_batch() फंक्शन को tf.train.shuffle_batch() जो मेमोरी में फिट होने के लिए बहुत बड़े हैं। संपूर्ण डेटासेट में फेरबदल करने के बजाय, यह buffer_size तत्वों के एक बफर को बनाए रखता है, और बेतरतीब ढंग से उस बफ़र से अगले तत्व का चयन करता है (यदि कोई उपलब्ध है, तो अगले इनपुट तत्व के साथ इसे प्रतिस्थापित करता है)। buffer_size के मूल्य को बदलना यह buffer_size है कि फेरबदल कितना समान है: यदि buffer_size डेटासेट में तत्वों की संख्या से अधिक है, तो आपको एक समान फेरबदल मिलता है; अगर यह 1 तो आपको इसमें कोई फेरबदल नहीं करना है। बहुत बड़े डेटासेट के लिए, एक विशिष्ट "अच्छा पर्याप्त" दृष्टिकोण है कि प्रशिक्षण से पहले एक बार डेटा को कई फाइलों में बेतरतीब ढंग से शार्प किया जाए, फिर फाइलनामों को समान रूप से फेरबदल किया जाए और फिर एक छोटे फेरबदल बफर का उपयोग किया जाए। हालांकि, उपयुक्त विकल्प आपके प्रशिक्षण कार्य की सटीक प्रकृति पर निर्भर करेगा।