इस पेज का अनुवाद Cloud Translation API से किया गया है.

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

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

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

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

परिणामों को सामान्य करने के लिए batch_size= इंगित करना सुनिश्चित करें (उदाहरण के लिए 100 iter/sec -> 3200 ex/sec)। यह किसी भी चलने योग्य (जैसे 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)

छोटे डेटासेट (1 जीबी से कम)

सभी TFDS डेटासेट डेटा को TFRecord प्रारूप में डिस्क पर संग्रहीत करते हैं। छोटे डेटासेट (जैसे MNIST, CIFAR-10/-100) के लिए, .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.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)

[1] वेक्टराइजिंग मैपिंग

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

ऑटो-कैशिंग

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

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

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

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

यदि आपका डेटासेट मेमोरी में फिट हो जाता है, तो आप संपूर्ण डेटासेट को एकल Tensor या NumPy सरणी के रूप में भी लोड कर सकते हैं। एक tf.Tensor में सभी उदाहरणों को बैचने के लिए बैच_साइज batch_size=-1 सेट करके ऐसा करना संभव है। फिर tf.Tensor से tf.Tensor में रूपांतरण के लिए tfds.as_numpy का 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 भी सेट करना चाहिए। अन्यथा, युग उसी क्रम में शार्क को पढ़ेगा, और इसलिए डेटा वास्तव में यादृच्छिक नहीं होगा।

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

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

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

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

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)

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

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

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

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

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

उदाहरणों को फ़िल्टर करते समय ( tf.data.Dataset.filter के साथ), उदाहरणों को फ़िल्टर करने के बाद छवियों को डीकोड करने के लिए।
छवियों को क्रॉप करते समय, tf.image.decode_and_crop_jpeg op का उपयोग करने के लिए।

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

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

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