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

सभी टीएफडीएस डेटासेट विभिन्न डेटा विभाजन (उदाहरण के लिए 'train' , 'test' ) को उजागर करते हैं जिन्हें कैटलॉग में खोजा जा सकता है। all से अलग, किसी भी वर्णमाला स्ट्रिंग को विभाजित नाम के रूप में उपयोग किया जा सकता है (जो एक आरक्षित शब्द है जो सभी विभाजनों के संघ से मेल खाता है, नीचे देखें)।

"आधिकारिक" डेटासेट विभाजन के अलावा, टीएफडीएस विभाजन के स्लाइस और विभिन्न संयोजनों का चयन करने की अनुमति देता है।

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

स्लाइसिंग निर्देश 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%]' ): पूरे डेटा को समान स्लाइस में विभाजित करें। यदि डेटा समान रूप से विभाज्य नहीं है, तो कुछ प्रतिशत में अतिरिक्त उदाहरण हो सकते हैं। आंशिक प्रतिशत समर्थित हैं.
  • शार्ड ( 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']

पार सत्यापन

स्ट्रिंग एपीआई का उपयोग करके 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 एक गोलाकार तर्क भी है। यदि डेटासेट में उदाहरण की संख्या समान रूप से विभाजित नहीं है:

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

प्रतिलिपि प्रस्तुत करने योग्यता एवं नियतिवाद

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

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

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