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

प्रदर्शन टिप्स

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

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

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

परिणाम सामान्य करने के लिए batch_size= इंगित करना सुनिश्चित करें (जैसे 100 iter / sec -> 3200 ex / sec)।

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

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

सभी TFDS डेटासेट TFRecord प्रारूप में डिस्क पर डेटा संग्रहीत करते हैं। छोटे डेटासेट के लिए (जैसे मेनिस्ट, सिफर, ...) .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 ऑटो-कैश डेटासेट जो निम्नलिखित बाधाओं को पूरा करते हैं:

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

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

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

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

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 read_config.shuffle_seed सेट read_config.options.experimental_deterministic

श्रमिकों में अपने डेटा को ऑटो-शार्द करें

कई कार्यकर्ताओं पर प्रशिक्षण, आप उपयोग कर सकते हैं जब 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)

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

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

तेज़ छवि डिकोडिंग

डिफ़ॉल्ट रूप से TFDS स्वचालित रूप से छवियों को डीकोड करता है। हालांकि, ऐसे मामले हैं जहां यह tfds.decode.SkipDecoding साथ छवि को डीकोड करने के लिए अधिक प्रदर्शन करने वाला हो सकता है और मैन्युअल रूप से tf.io.decode_image op लागू कर tf.io.decode_image :

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

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