एमएल समुदाय दिवस 9 नवंबर है! TensorFlow, JAX से नई जानकारी के लिए हमसे जुड़ें, और अधिक जानें

विभाजन और टुकड़ा करना

सभी TFDS डेटासेट विभिन्न डेटा विभाजन (जैसे बेनकाब 'train' , 'test' ) है, जिसमें पता लगाया जा सकता सूची

"आधिकारिक" डेटासेट स्प्लिट्स के अलावा, टीएफडीएस स्प्लिट (एस) और विभिन्न कॉम्बिनेशन के स्लाइस (एस) का चयन करने की अनुमति देता है।

स्लाइसिंग एपीआई

टुकड़ा करने की क्रिया निर्देशों में उल्लेख किया जाता है tfds.load या tfds.DatasetBuilder.as_dataset के माध्यम से split= kwarg।

ds = tfds.load('my_dataset', split='train[:75%]')
builder = tfds.builder('my_dataset')
ds = builder.as_dataset(split='test+train[:75%]')

विभाजन हो सकता है:

  • सादा विभाजन ( 'train' , 'test' ): चयनित स्प्लिट में मौजूद सभी उदाहरण।
  • स्लाइस: स्लाइस के रूप में ही अर्थ है अजगर टुकड़ा अंकन । स्लाइस हो सकते हैं:
    • निरपेक्ष ( 'train[123:450]' , train[:4000] ): (पढ़ने के आदेश के बारे में चेतावनी के लिए टिप्पणी bellow देखें)
    • प्रतिशत ( 'train[:75%]' , 'train[25%:75%]' ): 100 भी स्लाइस में पूर्ण डेटा विभाजित करें। यदि डेटा 100 से विभाज्य नहीं है, तो कुछ प्रतिशत में अतिरिक्त उदाहरण हो सकते हैं।
    • शार्ड ( train[:4shard] , train[4shard] ): अनुरोध ठीकरा में सभी उदाहरण का चयन करें। (देखें info.splits['train'].num_shards विभाजन के टुकड़े की संख्या प्राप्त करने)
  • विभाजन के संघ ( 'train+test' , 'train[:25%]+test' ): विभाजन एक साथ interleaved कर दिया जाएगा।
  • पूर्ण डाटासेट ( 'all' ): 'all' एक विशेष विभाजन सभी विभाजन के मिलन के लिए इसी का नाम (के बराबर है 'train+test+...' )।
  • विभाजन की सूची ( ['train', 'test'] ): एकाधिक tf.data.Dataset अलग से लौटा दिया जाता है:
# Returns both train and test split separately
train_ds, test_ds = tfds.load('mnist', split=['train', 'test[50%]'])

tfds.even_splits और बहु मेजबान प्रशिक्षण

tfds.even_splits एक ही आकार के गैर-अतिव्यापी उप विभाजन की एक सूची उत्पन्न करता है।

# Divide the dataset into 3 even parts, each containing 1/3 of the data
split0, split1, split2 = tfds.even_splits('train', n=3)

ds = tfds.load('my_dataset', split=split2)

वितरित सेटिंग में प्रशिक्षण के दौरान यह विशेष रूप से उपयोगी हो सकता है, जहां प्रत्येक होस्ट को मूल डेटा का एक टुकड़ा प्राप्त करना चाहिए। यहां जैक्स के साथ एक उदाहरण दिया गया है:

splits = tfds.even_splits('train', n=jax.process_count(), drop_remainder=True)
# The current `process_index` load only `1 / process_count` of the data.
ds = tfds.load('my_dataset', split=splits[jax.process_index()])

tfds.even_splits इनपुट के रूप में किसी भी विभाजन मूल्य पर स्वीकार करता है (उदाहरण के लिए 'train[75%:]+test' )

टुकड़ा करने की क्रिया और मेटाडेटा

यह विभाजन / subsplits पर अतिरिक्त जानकारी प्राप्त करने के लिए संभव है ( num_examples , file_instructions , ...) का उपयोग कर डाटासेट की जानकारी :

builder = tfds.builder('my_dataset')
builder.info.splits['train'].num_examples  # 10_000
builder.info.splits['train[:75%]'].num_examples  # 7_500 (also works with slices)
builder.info.splits.keys()  # ['train', 'test']

पार सत्यापन

स्ट्रिंग API का उपयोग करके 10-गुना क्रॉस-सत्यापन के उदाहरण:

vals_ds = tfds.load('mnist', split=[
    f'train[{k}%:{k+10}%]' for k in range(0, 100, 10)
])
trains_ds = tfds.load('mnist', split=[
    f'train[:{k}%]+train[{k+10}%:]' for k in range(0, 100, 10)
])

सत्यापन डेटासेट प्रत्येक को 10% होने जा रहे हैं: [0%:10%] , [10%:20%] , ..., [90%:100%] । : और प्रशिक्षण डेटासेट प्रत्येक पूरक 90% होने जा रहे हैं [10%:100%] (की इसी मान्यता सेट के लिए [0%:10%] , `[0%: 10%])

  • [20%: 100%] (for a validation set of [10%: 20%] `), ...

tfds.core.ReadInstruction और राउंडिंग

बजाय str , यह के रूप में विभाजन पारित करने के लिए संभव है tfds.core.ReadInstruction :

उदाहरण के लिए, split = 'train[50%:75%] + test' के बराबर है:

split = (
    tfds.core.ReadInstruction(
        'train',
        from_=50,
        to=75,
        unit='%',
    )

    + tfds.core.ReadInstruction('test')
)
ds = tfds.load('my_dataset', split=split)

unit हो सकता है:

  • abs : निरपेक्ष टुकड़ा करने की क्रिया
  • % : प्रतिशत टुकड़ा करने की क्रिया
  • shard : शार्ड टुकड़ा करने की क्रिया

tfds.ReadInstruction भी एक पूर्णांकन तर्क है। डेटासेट में उदाहरण की संख्या नहीं है, तो द्वारा समान रूप से विभाजित 100 :

  • rounding='closest' (डिफ़ॉल्ट): शेष उदाहरण, प्रतिशत के बीच वितरित कर रहे हैं ताकि कुछ प्रतिशत अतिरिक्त उदाहरण हो सकता है।
  • rounding='pct1_dropremainder' : शेष उदाहरण गिरा दिया जाता है, लेकिन यह गारंटी सब प्रतिशत उदाहरण के सटीक एक ही संख्या होती (जैसे: len(5%) == 5 * len(1%) )।

पुनरुत्पादकता और नियतत्ववाद

पीढ़ी के दौरान, किसी दिए गए डेटासेट संस्करण के लिए, TFDS गारंटी देता है कि उदाहरण डिस्क पर निश्चित रूप से फेरबदल किए जाते हैं। इसलिए डेटासेट को दो बार (2 अलग-अलग कंप्यूटरों में) जेनरेट करने से उदाहरण क्रम नहीं बदलेगा।

इसी तरह, subsplit एपीआई हमेशा एक ही चुन लिए जाएँगे set उदाहरण के यह मतलब, मंच, वास्तुकला, आदि की परवाह किए बिना set('train[:20%]') == set('train[:10%]') + set('train[10%:20%]')

हालांकि, जिस क्रम में उदाहरण पढ़ा जाता है निर्धारित करने योग्य नहीं हो सकता है। यह अन्य मापदंडों पर निर्भर करता है (जैसे कि क्या shuffle_files=True )।