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

सभी 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] ): (पढ़ने के आदेश के बारे में चेतावनी के लिए नीचे नोट देखें)
    • प्रतिशत ( 'train[:75%]' , 'train[25%:75%]' ): पूरे डेटा को 100 सम स्लाइस में विभाजित करें। यदि डेटा 100 से विभाज्य नहीं है, तो कुछ प्रतिशत में अतिरिक्त उदाहरण हो सकते हैं।
    • Shard ( train[:4shard] , train[4shard] ): अनुरोधित शार्द में सभी उदाहरणों का चयन करें। (विभाजन के टुकड़ों की संख्या प्राप्त करने के लिए info.splits['train'].num_shards देखें)
  • विभाजनों का संघ ( 'train+test' , 'train[:25%]+test' ): स्प्लिट्स को एक साथ इंटरलीव किया जाएगा।
  • पूर्ण डेटासेट ( '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)

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

Jax के साथ, इसे tfds.split_for_jax_process का उपयोग करके और भी सरल बनाया जा सकता है:

split = tfds.split_for_jax_process('train', drop_remainder=True)
ds = tfds.load('my_dataset', split=split)

tfds.split_for_jax_process इसके लिए एक साधारण उपनाम है:

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

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

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

डेटासेट जानकारी का उपयोग करके स्प्लिट्स/सबस्प्लिट्स ( 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 ),...

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 अलग-अलग कंप्यूटरों में) जेनरेट करने से उदाहरण क्रम नहीं बदलेगा।

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

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