प्रदर्शन युक्तियाँ

यह दस्तावेज़ TFDS-विशिष्ट प्रदर्शन युक्तियाँ प्रदान करता है। ध्यान दें कि TFDS रूप डेटासेट प्रदान करता है tf.data.Dataset , रों इतना से सलाह tf.data गाइड अभी भी लागू होता है।

बेंचमार्क डेटासेट

उपयोग tfds.benchmark(ds) बेंचमार्क के लिए किसी भी tf.data.Dataset वस्तु।

इंगित करने के लिए सुनिश्चित करें कि batch_size= (-> 3200 पूर्व / सेकंड जैसे 100 आईटीईआर / सेकंड) परिणामों को सामान्य बनाने में। किसी भी iterable के साथ यह काम करता है (उदाहरण के लिए tfds.benchmark(tfds.as_numpy(ds)) )।

ds = tfds.load('mnist', split='train').batch(32).prefetch()
# Display some benchmark statistics
tfds.benchmark(ds, batch_size=32)
# Second iteration is much faster, due to auto-caching
tfds.benchmark(ds, batch_size=32)

छोटे डेटासेट (<GB)

सभी TFDS डेटासेट में डिस्क पर डेटा स्टोर TFRecord प्रारूप। छोटे डेटासेट के लिए (जैसे Mnist, Cifar, ...), से पढ़ .tfrecord महत्वपूर्ण ओवरहेड जोड़ सकते हैं।

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

डेटासेट कैशिंग

यहां डेटा पाइपलाइन का एक उदाहरण दिया गया है जो छवियों को सामान्य करने के बाद डेटासेट को स्पष्ट रूप से कैश करता है।

def normalize_img(image, label):
  """Normalizes images: `uint8` -> `float32`."""
  return tf.cast(image, tf.float32) / 255., label


ds, ds_info = tfds.load(
    'mnist',
    split='train',
    as_supervised=True,  # returns `(img, label)` instead of dict(image=, ...)
    with_info=True,
)
# Applying normalization before `ds.cache()` to re-use it.
# Note: Random transformations (e.g. images augmentations) should be applied
# after both `ds.cache()` (to avoid caching randomness) and `ds.batch()` (for
# vectorization [1]).
ds = ds.map(normalize_img, num_parallel_calls=tf.data.experimental.AUTOTUNE)
ds = ds.cache()
# For true randomness, we set the shuffle buffer to the full dataset size.
ds = ds.shuffle(ds_info.splits['train'].num_examples)
# Batch after shuffling to get unique batches at each epoch.
ds = ds.batch(128)
ds = ds.prefetch(tf.data.experimental.AUTOTUNE)

इस डेटासेट पर पुनरावृति करते समय, कैशिंग के कारण दूसरा पुनरावृत्ति पहले वाले की तुलना में बहुत तेज़ होगा।

ऑटो-कैशिंग

डिफ़ॉल्ट रूप से, TFDS ऑटो कैश (साथ ds.cache() डेटासेट जो निम्नलिखित की कमी को पूरा):

  • कुल डेटासेट आकार (सभी विभाजन) परिभाषित हैं और <250 MiB
  • shuffle_files अक्षम किया गया है, या केवल एक ही ठीकरा पढ़ा जाता है

यह पारित करके ऑटो कैशिंग से बाहर निकलना संभव है try_autocaching=False को tfds.ReadConfig में tfds.load । यह देखने के लिए कि कोई विशिष्ट डेटासेट ऑटो-कैश का उपयोग करेगा या नहीं, डेटासेट कैटलॉग दस्तावेज़ीकरण पर एक नज़र डालें।

एकल Tensor के रूप में पूरा डेटा लोड हो रहा है

यदि आपका डेटासेट मेमोरी में फिट हो जाता है, तो आप संपूर्ण डेटासेट को एकल Tensor या NumPy सरणी के रूप में भी लोड कर सकते हैं। यह सेटिंग से ऐसा करना संभव है batch_size=-1 बैच के लिए एक एकल में सभी उदाहरण tf.Tensor । तब का उपयोग tfds.as_numpy से रूपांतरण के लिए tf.Tensor को np.array

(img_train, label_train), (img_test, label_test) = tfds.as_numpy(tfds.load(
    'mnist',
    split=['train', 'test'],
    batch_size=-1,
    as_supervised=True,
))

बड़े डेटासेट

बड़े डेटासेट को शार्प किया जाता है (कई फाइलों में विभाजित), और आमतौर पर मेमोरी में फिट नहीं होते हैं इसलिए उन्हें कैश नहीं किया जाना चाहिए।

फेरबदल और प्रशिक्षण

प्रशिक्षण के दौरान, डेटा को अच्छी तरह से फेरबदल करना महत्वपूर्ण है; खराब रूप से फेरबदल किए गए डेटा के परिणामस्वरूप प्रशिक्षण सटीकता कम हो सकती है।

उपयोग करने के अलावा ds.shuffle रिकॉर्ड शफ़ल करने के लिए, आप भी स्थापित करना चाहिए shuffle_files=True बड़े डेटासेट कि एकाधिक फ़ाइलों में sharded कर रहे हैं के लिए अच्छा पुथल व्यवहार मिलता है। अन्यथा, युग उसी क्रम में शार्क को पढ़ेगा, और इसलिए डेटा वास्तव में यादृच्छिक नहीं होगा।

ds = tfds.load('imagenet2012', split='train', shuffle_files=True)

इसके अतिरिक्त, जब shuffle_files=True , TFDS को निष्क्रिय options.experimental_deterministic है, जो एक मामूली प्रदर्शन को बढ़ावा देने सकता है। नियतात्मक की उथल पाने के लिए, यह संभव ऑप्ट-आउट के साथ इस सुविधा के लिए है tfds.ReadConfig या तो सेट करके: read_config.shuffle_seed या अधिलेखित read_config.options.experimental_deterministic

कर्मचारियों के बीच अपने डेटा को ऑटो-शेयर करें (TF)

कई कार्यकर्ताओं पर प्रशिक्षण, आप उपयोग कर सकते हैं जब input_context का तर्क tfds.ReadConfig , इसलिए प्रत्येक कार्यकर्ता डेटा का एक उप पढ़ा जाएगा।

input_context = tf.distribute.InputContext(
    input_pipeline_id=1,  # Worker id
    num_input_pipelines=4,  # Total number of workers
)
read_config = tfds.ReadConfig(
    input_context=input_context,
)
ds = tfds.load('dataset', split='train', read_config=read_config)

यह सबस्प्लिट एपीआई का पूरक है। सबसे पहले subplit एपीआई लागू किया जाता है ( train[:50%] पढ़ने के लिए फ़ाइलों की एक सूची में बदल जाता है), तो एक ds.shard() सेशन उन फ़ाइलों पर लागू किया जाता है। उदाहरण: का उपयोग करते समय train[:50%] के साथ num_input_pipelines=2 , 2 कार्यकर्ता की प्रत्येक डेटा का 1/4 पढ़ा जाएगा।

जब shuffle_files=True , फ़ाइलें एक कार्यकर्ता के भीतर shuffled हैं, लेकिन कार्यकर्ताओं के पार नहीं। प्रत्येक कार्यकर्ता युगों के बीच फाइलों का एक ही सबसेट पढ़ेगा।

कर्मचारियों के बीच अपने डेटा को ऑटो-शेयर करें (जैक्स)

Jax के साथ, आप उपयोग कर सकते हैं tfds.even_splits एपीआई कार्यकर्ताओं पर अपना डेटा वितरित करने के लिए। देखें विभाजन API मार्गदर्शिका

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 स्वचालित रूप से छवियों को डीकोड करता है। हालांकि, वहाँ मामलों में जहां इसके साथ डिकोडिंग छवि को छोड़ने के लिए अधिक performant हो सकता है tfds.decode.SkipDecoding और मैन्युअल रूप से लागू होते हैं tf.io.decode_image सेशन:

  • जब उदाहरण छानने (साथ ds.filter ), छवियों को डिकोड करने के बाद उदाहरण फ़िल्टर कर दिए गए।
  • जब छवियों फसल, आपस में जुड़े उपयोग करने के लिए tf.image.decode_and_crop_jpeg सेशन।

दोनों उदाहरण के लिए कोड में उपलब्ध है डिकोड गाइड

अप्रयुक्त सुविधाओं को छोड़ें

यदि आप केवल सुविधाओं के सबसेट का उपयोग कर रहे हैं, तो कुछ सुविधाओं को पूरी तरह से छोड़ना संभव है। यदि आपके डेटासेट में कई अप्रयुक्त विशेषताएं हैं, तो उन्हें डीकोड न करने से प्रदर्शन में उल्लेखनीय सुधार हो सकता है। देखें https://www.tensorflow.org/datasets/decode#only_decode_a_sub-set_of_the_features