टीएफडीएस अब क्रोइसैन 🥐 प्रारूप का समर्थन करता है! अधिक जानने के लिए दस्तावेज़ पढ़ें.

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

कस्टम डेटासेट लिखना

टीएफडीएस में या अपनी खुद की रिपॉजिटरी में नया डेटासेट बनाने के लिए इस गाइड का पालन करें।

हमारी डेटासेट सूची देखें कि क्या आप जिस डेटासेट को चाहते हैं वह पहले से मौजूद है।

संक्षेप में

नया डेटासेट लिखने का सबसे आसान तरीका TFDS CLI का उपयोग करना है:

cd path/to/my/project/datasets/
tfds new my_dataset  # Create `my_dataset/my_dataset.py` template files
# [...] Manually modify `my_dataset/my_dataset_dataset_builder.py` to implement your dataset.
cd my_dataset/
tfds build  # Download and prepare the dataset to `~/tensorflow_datasets/`

नए डेटासेट को tfds.load('my_dataset') के साथ उपयोग करने के लिए:

tfds.load स्वचालित रूप से ~/tensorflow_datasets/my_dataset/ में उत्पन्न डेटासेट (उदाहरण के लिए tfds build द्वारा) का पता लगाएगा और उसे लोड करेगा।
वैकल्पिक रूप से, आप अपने डेटासेट को पंजीकृत करने के लिए import my.project.datasets.my_dataset कर सकते हैं:

import my.project.datasets.my_dataset  # Register `my_dataset`

ds = tfds.load('my_dataset')  # `my_dataset` registered

अवलोकन

डेटासेट कई तरह के फॉर्मेट में और कई तरह के स्थानों पर वितरित होते हैं, और वे हमेशा ऐसे फॉर्मेट में संग्रहीत नहीं होते जो मशीन लर्निंग पाइपलाइन में फीड करने के लिए तैयार हो। यहीं पर TFDS काम आता है।

TFDS इन डेटासेट को एक मानक प्रारूप (बाह्य डेटा -> क्रमबद्ध फ़ाइलें) में संसाधित करता है, जिसे बाद में मशीन लर्निंग पाइपलाइन (क्रमबद्ध फ़ाइलें -> tf.data.Dataset ) के रूप में लोड किया जा सकता है। क्रमबद्धीकरण केवल एक बार किया जाता है। बाद में उपयोग करने पर डेटा सीधे इन पूर्व-संसाधित फ़ाइलों से पढ़ा जाएगा।

अधिकांश प्रीप्रोसेसिंग स्वचालित रूप से की जाती है। प्रत्येक डेटासेट tfds.core.DatasetBuilder के एक सबक्लास को इम्प्लीमेंट करता है, जो निम्नलिखित निर्दिष्ट करता है:

डेटा कहाँ से आ रहा है (अर्थात उसके यूआरएल);
डेटासेट कैसा दिखता है (अर्थात उसकी विशेषताएं);
डेटा को किस प्रकार विभाजित किया जाना चाहिए (उदाहरण के लिए TRAIN और TEST );
और डेटासेट में मौजूद अलग-अलग उदाहरण।

अपना डेटासेट लिखें

डिफ़ॉल्ट टेम्पलेट: `tfds new`

आवश्यक टेम्पलेट पायथन फ़ाइलें बनाने के लिए TFDS CLI का उपयोग करें।

cd path/to/project/datasets/  # Or use `--dir=path/to/project/datasets/` below
tfds new my_dataset

यह कमांड निम्नलिखित संरचना के साथ एक नया my_dataset/ फ़ोल्डर बनाएगा:

my_dataset/
    __init__.py
    README.md # Markdown description of the dataset.
    CITATIONS.bib # Bibtex citation for the dataset.
    TAGS.txt # List of tags describing the dataset.
    my_dataset_dataset_builder.py # Dataset definition
    my_dataset_dataset_builder_test.py # Test
    dummy_data/ # (optional) Fake data (used for testing)
    checksum.tsv # (optional) URL checksums (see `checksums` section).

यहां TODO(my_dataset) खोजें और उसके अनुसार बदलाव करें।

डेटासेट उदाहरण

सभी डेटासेट tfds.core.DatasetBuilder के कार्यान्वित उपवर्ग हैं, जो अधिकांश आवश्यक कोड को संभालता है। यह निम्नलिखित का समर्थन करता है:

छोटे/मध्यम आकार के डेटासेट जिन्हें एक ही मशीन पर उत्पन्न किया जा सकता है (यह ट्यूटोरियल)।
बहुत बड़े डेटासेट जिनके लिए वितरित जनरेशन की आवश्यकता होती है ( अपैची बीम का उपयोग करके, हमारी विशाल डेटासेट गाइड देखें)

यहां tfds.core.GeneratorBasedBuilder पर आधारित डेटासेट बिल्डर का एक न्यूनतम उदाहरण दिया गया है:

class Builder(tfds.core.GeneratorBasedBuilder):
  """DatasetBuilder for my_dataset dataset."""

  VERSION = tfds.core.Version('1.0.0')
  RELEASE_NOTES = {
      '1.0.0': 'Initial release.',
  }

  def _info(self) -> tfds.core.DatasetInfo:
    """Dataset metadata (homepage, citation,...)."""
    return self.dataset_info_from_configs(
        features=tfds.features.FeaturesDict({
            'image': tfds.features.Image(shape=(256, 256, 3)),
            'label': tfds.features.ClassLabel(
                names=['no', 'yes'],
                doc='Whether this is a picture of a cat'),
        }),
    )

  def _split_generators(self, dl_manager: tfds.download.DownloadManager):
    """Download the data and define splits."""
    extracted_path = dl_manager.download_and_extract('http://data.org/data.zip')
    # dl_manager returns pathlib-like objects with `path.read_text()`,
    # `path.iterdir()`,...
    return {
        'train': self._generate_examples(path=extracted_path / 'train_images'),
        'test': self._generate_examples(path=extracted_path / 'test_images'),
    }

  def _generate_examples(self, path) -> Iterator[Tuple[Key, Example]]:
    """Generator of examples for each split."""
    for img_path in path.glob('*.jpeg'):
      # Yields (key, example)
      yield img_path.name, {
          'image': img_path,
          'label': 'yes' if img_path.name.startswith('yes_') else 'no',
      }

कृपया ध्यान दें कि कुछ विशिष्ट डेटा प्रारूपों के लिए, हम अधिकांश डेटा प्रोसेसिंग का ध्यान रखने के लिए तैयार-टू-यूज़ डेटासेट बिल्डर प्रदान करते हैं।

आइए ओवरराइट करने के 3 अमूर्त तरीकों को विस्तार से देखें।

`_info` : डेटासेट मेटाडेटा

_info tfds.core.DatasetInfo लौटाता है जिसमें डेटासेट मेटाडेटा होता है।

def _info(self):
  # The `dataset_info_from_configs` base method will construct the
  # `tfds.core.DatasetInfo` object using the passed-in parameters and
  # adding: builder (self), description/citations/tags from the config
  # files located in the same package.
  return self.dataset_info_from_configs(
      homepage='https://dataset-homepage.org',
      features=tfds.features.FeaturesDict({
          'image_description': tfds.features.Text(),
          'image': tfds.features.Image(),
          # Here, 'label' can be 0-4.
          'label': tfds.features.ClassLabel(num_classes=5),
      }),
      # If there's a common `(input, target)` tuple from the features,
      # specify them here. They'll be used if as_supervised=True in
      # builder.as_dataset.
      supervised_keys=('image', 'label'),
      # Specify whether to disable shuffling on the examples. Set to False by default.
      disable_shuffling=False,
  )

अधिकांश क्षेत्र स्वतः स्पष्ट होने चाहिए। कुछ स्पष्टीकरण:

features : ये डेटासेट की संरचना, आकार आदि को निर्दिष्ट करती हैं। जटिल डेटा प्रकारों (ऑडियो, वीडियो, नेस्टेड सीक्वेंस आदि) का समर्थन करती हैं। अधिक जानकारी के लिए उपलब्ध विशेषताएं या फीचर कनेक्टर गाइड देखें।
disable_shuffling : डेटासेट क्रम बनाए रखें अनुभाग देखें।

BibText CITATIONS.bib फ़ाइल लिखना:

डेटासेट की वेबसाइट पर उद्धरण संबंधी निर्देश खोजें (इसे BibTex प्रारूप में उपयोग करें)।
arXiv पर उपलब्ध शोध पत्रों के लिए: शोध पत्र खोजें और दाईं ओर स्थित BibText लिंक पर क्लिक करें।
गूगल स्कॉलर पर पेपर ढूंढें और शीर्षक के नीचे दिए गए दोहरे उद्धरण चिह्न पर क्लिक करें और पॉपअप में, BibTeX पर क्लिक करें।
यदि कोई संबद्ध शोधपत्र नहीं है (उदाहरण के लिए, केवल एक वेबसाइट है), तो आप कस्टम बिबटेक्स प्रविष्टि बनाने के लिए बिबटेक्स ऑनलाइन संपादक का उपयोग कर सकते हैं (ड्रॉप-डाउन मेनू में एक Online प्रविष्टि प्रकार है)।

TAGS.txt फ़ाइल को अपडेट करना:

सभी अनुमत टैग उत्पन्न फाइल में पहले से भरे होते हैं।
उन सभी टैग्स को हटा दें जो डेटासेट पर लागू नहीं होते हैं।
मान्य टैग tensorflow_datasets/core/valid_tags.txt में सूचीबद्ध हैं।
उस सूची में टैग जोड़ने के लिए, कृपया एक पीआर भेजें।

डेटासेट का क्रम बनाए रखें

डिफ़ॉल्ट रूप से, डेटासेट के रिकॉर्ड को संग्रहीत करते समय फेरबदल किया जाता है ताकि डेटासेट में कक्षाओं का वितरण अधिक समान हो सके, क्योंकि अक्सर एक ही कक्षा से संबंधित रिकॉर्ड एक साथ होते हैं। यदि आप यह निर्दिष्ट करना चाहते हैं कि डेटासेट को _generate_examples द्वारा प्रदान की गई कुंजी के आधार पर क्रमबद्ध किया जाए, तो disable_shuffling फ़ील्ड को ` True पर सेट करें। डिफ़ॉल्ट रूप से यह False पर सेट होता है।

def _info(self):
  return self.dataset_info_from_configs(
    # [...]
    disable_shuffling=True,
    # [...]
  )

ध्यान रखें कि शफलिंग को अक्षम करने से प्रदर्शन पर प्रभाव पड़ता है क्योंकि अब शार्ड्स को समानांतर रूप से नहीं पढ़ा जा सकता है।

`_split_generators` : डेटा डाउनलोड करता है और उसे विभाजित करता है

स्रोत डेटा डाउनलोड करना और निकालना

अधिकांश डेटासेट को वेब से डेटा डाउनलोड करने की आवश्यकता होती है। यह _split_generators के tfds.download.DownloadManager इनपुट आर्गुमेंट का उपयोग करके किया जाता है। dl_manager में निम्नलिखित विधियाँ हैं:

download : http(s):// और ftp(s):// को सपोर्ट करता है
extract : वर्तमान में .zip , .gz और .tar फ़ाइलों का समर्थन करता है।
download_and_extract : dl_manager.extract(dl_manager.download(urls)) के समान

ये सभी विधियाँ tfds.core.Path ( epath.Path के उपनाम) लौटाती हैं, जो pathlib.Path जैसी वस्तुएँ हैं।

ये विधियाँ किसी भी प्रकार की नेस्टेड संरचना ( list , dict ) का समर्थन करती हैं, जैसे:

extracted_paths = dl_manager.download_and_extract({
    'foo': 'https://example.com/foo.zip',
    'bar': 'https://example.com/bar.zip',
})
# This returns:
assert extracted_paths == {
    'foo': Path('/path/to/extracted_foo/'),
    'bar': Path('/path/extracted_bar/'),
}

मैन्युअल डाउनलोड और एक्सट्रैक्शन

कुछ डेटा स्वचालित रूप से डाउनलोड नहीं किया जा सकता है (उदाहरण के लिए, लॉगिन की आवश्यकता होती है), इस मामले में, उपयोगकर्ता स्रोत डेटा को मैन्युअल रूप से डाउनलोड करेगा और इसे manual_dir/ में रखेगा (डिफ़ॉल्ट रूप से ~/tensorflow_datasets/downloads/manual/ )।

इसके बाद फाइलों को dl_manager.manual_dir के माध्यम से एक्सेस किया जा सकता है:

class MyDataset(tfds.core.GeneratorBasedBuilder):

  MANUAL_DOWNLOAD_INSTRUCTIONS = """
  Register into https://example.org/login to get the data. Place the `data.zip`
  file in the `manual_dir/`.
  """

  def _split_generators(self, dl_manager):
    # data_path is a pathlib-like `Path('<manual_dir>/data.zip')`
    archive_path = dl_manager.manual_dir / 'data.zip'
    # Extract the manually downloaded `data.zip`
    extracted_path = dl_manager.extract(archive_path)
    ...

manual_dir स्थान tfds build --manual_dir= का उपयोग करके या tfds.download.DownloadConfig का उपयोग करके अनुकूलित किया जा सकता है।

आर्काइव को सीधे पढ़ें

dl_manager.iter_archive आर्काइव फ़ाइलों को निकाले बिना उन्हें क्रमानुसार पढ़ता है। इससे कुछ फ़ाइल सिस्टम पर स्टोरेज स्पेस की बचत हो सकती है और परफॉर्मेंस में सुधार हो सकता है।

for filename, fobj in dl_manager.iter_archive('path/to/archive.zip'):
  ...

fobj में वही विधियाँ हैं जो with open('rb') as fobj: (उदाहरण के लिए fobj.read() )

डेटासेट विभाजन निर्दिष्ट करना

यदि डेटासेट में पूर्वनिर्धारित विभाजन (जैसे MNIST में train और test विभाजन हैं) मौजूद हैं, तो उन्हें ही रखें। अन्यथा, केवल एक ही all निर्दिष्ट करें। उपयोगकर्ता सबस्प्लिट API का उपयोग करके गतिशील रूप से अपने स्वयं के उप-विभाजन बना सकते हैं (उदाहरण के लिए split='train[80%:]' )। ध्यान दें कि उपर्युक्त all के अलावा किसी भी वर्णानुक्रमिक स्ट्रिंग का उपयोग विभाजन नाम के रूप में किया जा सकता है।

def _split_generators(self, dl_manager):
  # Download source data
  extracted_path = dl_manager.download_and_extract(...)

  # Specify the splits
  return {
      'train': self._generate_examples(
          images_path=extracted_path / 'train_imgs',
          label_path=extracted_path / 'train_labels.csv',
      ),
      'test': self._generate_examples(
          images_path=extracted_path / 'test_imgs',
          label_path=extracted_path / 'test_labels.csv',
      ),
  }

`_generate_examples` : उदाहरण जनरेटर

_generate_examples स्रोत डेटा से प्रत्येक विभाजन के लिए उदाहरण उत्पन्न करता है।

यह विधि आम तौर पर स्रोत डेटासेट कलाकृतियों (जैसे कि एक CSV फ़ाइल) को पढ़ेगी और (key, feature_dict) टुपल्स उत्पन्न करेगी:

key : उदाहरण पहचानकर्ता। इसका उपयोग hash(key) का उपयोग करके उदाहरणों को निश्चित रूप से शफल करने के लिए या शफलिंग अक्षम होने पर key के अनुसार सॉर्ट करने के लिए किया जाता है ( डेटासेट क्रम बनाए रखें अनुभाग देखें)। यह होना चाहिए:
- unique : यदि दो उदाहरण एक ही कुंजी का उपयोग करते हैं, तो एक अपवाद उत्पन्न होगा।
- नियतात्मक : यह download_dir , os.path.listdir क्रम आदि पर निर्भर नहीं होना चाहिए। डेटा को दो बार जनरेट करने पर एक ही कुंजी प्राप्त होनी चाहिए।
- तुलनीय : यदि शफलिंग अक्षम है, तो डेटासेट को सॉर्ट करने के लिए कुंजी का उपयोग किया जाएगा।
feature_dict : एक dict जिसमें उदाहरण मान शामिल हैं।
- यह संरचना tfds.core.DatasetInfo में परिभाषित features= संरचना से मेल खानी चाहिए।
- जटिल डेटा प्रकार (छवि, वीडियो, ऑडियो,...) स्वचालित रूप से एन्कोड किए जाएंगे।
- प्रत्येक फ़ीचर अक्सर कई इनपुट प्रकारों को स्वीकार करता है (उदाहरण के लिए वीडियो /path/to/vid.mp4 , np.array(shape=(l, h, w, c)) , List[paths] , List[np.array(shape=(h, w, c)] , List[img_bytes] स्वीकार करता है)।
- अधिक जानकारी के लिए फीचर कनेक्टर गाइड देखें।

def _generate_examples(self, images_path, label_path):
  # Read the input data out of the source files
  with label_path.open() as f:
    for row in csv.DictReader(f):
      image_id = row['image_id']
      # And yield (key, feature_dict)
      yield image_id, {
          'image_description': row['description'],
          'image': images_path / f'{image_id}.jpeg',
          'label': row['label'],
      }

फ़ाइल एक्सेस और `tf.io.gfile`

क्लाउड स्टोरेज सिस्टम को सपोर्ट करने के लिए, पायथन के बिल्ट-इन I/O ऑपरेशंस का उपयोग करने से बचें।

इसके बजाय, dl_manager सीधे Google क्लाउड स्टोरेज के साथ संगत pathlib-जैसे ऑब्जेक्ट लौटाता है:

path = dl_manager.download_and_extract('http://some-website/my_data.zip')

json_path = path / 'data/file.json'

json.loads(json_path.read_text())

वैकल्पिक रूप से, फ़ाइल संचालन के लिए अंतर्निहित API के बजाय tf.io.gfile API का उपयोग करें:

open -> tf.io.gfile.GFile
os.rename -> tf.io.gfile.rename
...

tf.io.gfile की जगह Pathlib को प्राथमिकता दी जानी चाहिए (देखें rational .

अतिरिक्त निर्भरताएँ

कुछ डेटासेट को जनरेट करने के दौरान ही अतिरिक्त पायथन निर्भरताओं की आवश्यकता होती है। उदाहरण के लिए, SVHN डेटासेट कुछ डेटा लोड करने के लिए scipy का उपयोग करता है।

यदि आप TFDS रिपॉजिटरी में डेटासेट जोड़ रहे हैं, तो कृपया tensorflow-datasets पैकेज का आकार छोटा रखने के लिए tfds.core.lazy_imports उपयोग करें। उपयोगकर्ता आवश्यकतानुसार ही अतिरिक्त निर्भरताएँ स्थापित करेंगे।

lazy_imports उपयोग करने के लिए:

setup.py में DATASET_EXTRAS में अपने डेटासेट के लिए एक प्रविष्टि जोड़ें। इससे उपयोगकर्ता अतिरिक्त निर्भरताओं को स्थापित करने के लिए, उदाहरण के लिए, pip install 'tensorflow-datasets[svhn]' उपयोग कर सकेंगे।
अपने आयात के लिए LazyImporter और LazyImportsTest में एक प्रविष्टि जोड़ें।
अपने DatasetBuilder में निर्भरता (उदाहरण के लिए, tfds.core.lazy_imports.scipy ) तक पहुँचने के लिए tfds.core.lazy_imports उपयोग करें।

दूषित डेटा

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

डेटासेट कॉन्फ़िगरेशन/वेरिएंट (tfds.core.BuilderConfig)

कुछ डेटासेट में कई प्रकार के वेरिएंट या डेटा को प्रीप्रोसेस करने और डिस्क पर लिखने के कई विकल्प हो सकते हैं। उदाहरण के लिए, cycle_gan में प्रत्येक ऑब्जेक्ट जोड़ी के लिए एक कॉन्फ़िगरेशन होता है ( cycle_gan/horse2zebra , cycle_gan/monet2photo , ...)।

यह tfds.core.BuilderConfig s के माध्यम से किया जाता है:

अपने कॉन्फ़िगरेशन ऑब्जेक्ट को tfds.core.BuilderConfig के सबक्लास के रूप में परिभाषित करें। उदाहरण के लिए, MyDatasetConfig ।
```
@dataclasses.dataclass
class MyDatasetConfig(tfds.core.BuilderConfig):
  img_size: Tuple[int, int] = (0, 0)
```
नोट: https://bugs.python.org/issue33129 के कारण डिफ़ॉल्ट मान आवश्यक हैं।
MyDataset में BUILDER_CONFIGS = [] क्लास मेंबर को परिभाषित करें जो उन MyDatasetConfig को सूचीबद्ध करता है जिन्हें डेटासेट उजागर करता है।
```
class MyDataset(tfds.core.GeneratorBasedBuilder):
  VERSION = tfds.core.Version('1.0.0')
  # pytype: disable=wrong-keyword-args
  BUILDER_CONFIGS = [
      # `name` (and optionally `description`) are required for each config
      MyDatasetConfig(name='small', description='Small ...', img_size=(8, 8)),
      MyDatasetConfig(name='big', description='Big ...', img_size=(32, 32)),
  ]
  # pytype: enable=wrong-keyword-args
```
नोट: # pytype: disable=wrong-keyword-args आवश्यक है क्योंकि डेटाक्लास इनहेरिटेंस के साथ Pytype में एक बग है ।
डेटा जनरेशन को कॉन्फ़िगर करने के लिए MyDataset में self.builder_config उपयोग करें (उदाहरण के लिए shape=self.builder_config.img_size )। इसमें _info() में अलग-अलग मान सेट करना या डाउनलोड डेटा एक्सेस को बदलना शामिल हो सकता है।

टिप्पणियाँ:

प्रत्येक कॉन्फ़िगरेशन का एक अद्वितीय नाम होता है। कॉन्फ़िगरेशन का पूर्ण नाम dataset_name/config_name होता है (उदाहरण के लिए coco/2017 )।
यदि निर्दिष्ट नहीं किया गया है, तो BUILDER_CONFIGS में पहला कॉन्फ़िगरेशन उपयोग किया जाएगा (उदाहरण के लिए tfds.load('c4') डिफ़ॉल्ट रूप से c4/en पर लागू होता है)।

BuilderConfig का उपयोग करने वाले डेटासेट के उदाहरण के लिए anli देखें।

संस्करण

संस्करण के दो अलग-अलग अर्थ हो सकते हैं:

"बाह्य" मूल डेटा संस्करण: उदाहरण के लिए COCO v2019, v2017,...
TFDS कोड का "आंतरिक" संस्करण: उदाहरण के लिए, tfds.features.FeaturesDict में किसी फ़ीचर का नाम बदलना, _generate_examples में किसी बग को ठीक करना।

डेटासेट को अपडेट करने के लिए:

"बाहरी" डेटा अपडेट के लिए: कई उपयोगकर्ता एक ही समय में किसी विशिष्ट वर्ष/संस्करण तक पहुंचना चाह सकते हैं। यह प्रत्येक संस्करण के लिए एक tfds.core.BuilderConfig (जैसे coco/2017 , coco/2019 ) या प्रत्येक संस्करण के लिए एक क्लास (जैसे Voc2007 , Voc2012 ) का उपयोग करके किया जाता है।
आंतरिक कोड अपडेट के लिए: उपयोगकर्ता केवल नवीनतम संस्करण डाउनलोड करें। किसी भी कोड अपडेट में VERSION क्लास विशेषता को बढ़ाना चाहिए (उदाहरण के लिए 1.0.0 से VERSION = tfds.core.Version('2.0.0') तक) सिमेंटिक वर्ज़निंग का पालन करते हुए।

पंजीकरण के लिए आयात जोड़ें

अपने प्रोजेक्ट के __init__ में डेटासेट मॉड्यूल को आयात करना न भूलें ताकि यह tfds.load और tfds.builder में स्वचालित रूप से पंजीकृत हो जाए।

import my_project.datasets.my_dataset  # Register MyDataset

ds = tfds.load('my_dataset')  # MyDataset available

उदाहरण के लिए, यदि आप tensorflow/datasets में योगदान दे रहे हैं, तो मॉड्यूल आयात को इसकी उपनिर्देशिका के __init__.py में जोड़ें (जैसे image/__init__.py )।

सामान्य कार्यान्वयन संबंधी समस्याओं की जाँच करें

कृपया कार्यान्वयन में आने वाली सामान्य समस्याओं की जांच करें।

अपने डेटासेट का परीक्षण करें

डाउनलोड करें और तैयार करें: `tfds build`

डेटासेट जनरेट करने के लिए, my_dataset/ डायरेक्टरी से tfds build चलाएँ:

cd path/to/datasets/my_dataset/
tfds build --register_checksums

विकास के लिए कुछ उपयोगी संकेत:

--pdb : यदि कोई अपवाद उत्पन्न होता है तो डिबगिंग मोड में प्रवेश करें।
--overwrite : यदि डेटासेट पहले से ही जनरेट हो चुका है तो मौजूदा फाइलों को हटा दें।
--max_examples_per_split : पूरे डेटासेट के बजाय केवल पहले X उदाहरण (डिफ़ॉल्ट रूप से 1) उत्पन्न करें।
--register_checksums : डाउनलोड किए गए यूआरएल के चेकसम रिकॉर्ड करता है। इसका उपयोग केवल विकास के दौरान ही किया जाना चाहिए।

फ्लैग की पूरी सूची के लिए CLI दस्तावेज़ देखें।

चेकसम

डेटासेट की सटीकता सुनिश्चित करने, दस्तावेज़ीकरण में सहायता आदि के लिए उनके चेकसम रिकॉर्ड करने की सलाह दी जाती है। यह --register_checksums कमांड का उपयोग करके डेटासेट जनरेट करके किया जाता है (पिछला अनुभाग देखें)।

यदि आप अपने डेटासेट को PyPI के माध्यम से जारी कर रहे हैं, तो checksums.tsv फ़ाइलों को निर्यात करना न भूलें (उदाहरण के लिए, अपने setup.py के package_data में)।

अपने डेटासेट का यूनिट-टेस्ट करें

tfds.testing.DatasetBuilderTestCase एक आधारभूत TestCase है जो किसी डेटासेट का पूर्ण परीक्षण करने के लिए बनाया गया है। यह टेस्ट डेटा के रूप में "डमी डेटा" का उपयोग करता है जो स्रोत डेटासेट की संरचना की नकल करता है।

परीक्षण डेटा को my_dataset/dummy_data/ निर्देशिका में रखा जाना चाहिए और यह डाउनलोड और एक्सट्रैक्ट किए गए स्रोत डेटासेट के समान होना चाहिए। इसे मैन्युअल रूप से या स्क्रिप्ट की सहायता से स्वचालित रूप से बनाया जा सकता है ( उदाहरण स्क्रिप्ट )।
अपने परीक्षण डेटा विभाजन में अलग-अलग डेटा का उपयोग करना सुनिश्चित करें, क्योंकि यदि आपके डेटासेट विभाजन ओवरलैप होते हैं तो परीक्षण विफल हो जाएगा।
परीक्षण डेटा में किसी भी प्रकार की कॉपीराइट सामग्री नहीं होनी चाहिए । यदि संदेह हो, तो मूल डेटासेट की सामग्री का उपयोग करके डेटा तैयार न करें।

import tensorflow_datasets as tfds
from . import my_dataset_dataset_builder


class MyDatasetTest(tfds.testing.DatasetBuilderTestCase):
  """Tests for my_dataset dataset."""
  DATASET_CLASS = my_dataset_dataset_builder.Builder
  SPLITS = {
      'train': 3,  # Number of fake train example
      'test': 1,  # Number of fake test example
  }

  # If you are calling `download/download_and_extract` with a dict, like:
  #   dl_manager.download({'some_key': 'http://a.org/out.txt', ...})
  # then the tests needs to provide the fake output paths relative to the
  # fake data directory
  DL_EXTRACT_RESULT = {
      'name1': 'path/to/file1',  # Relative to my_dataset/dummy_data dir.
      'name2': 'file2',
  }


if __name__ == '__main__':
  tfds.testing.test_main()

डेटासेट का परीक्षण करने के लिए निम्न कमांड चलाएँ।

python my_dataset_test.py

हमें फीडबैक भेजें

हम डेटासेट निर्माण प्रक्रिया को बेहतर बनाने के लिए लगातार प्रयासरत हैं, लेकिन ऐसा तभी संभव है जब हमें समस्याओं की जानकारी हो। डेटासेट बनाते समय आपको किन समस्याओं या त्रुटियों का सामना करना पड़ा? क्या कोई हिस्सा उलझन भरा था, या पहली बार में ठीक से काम नहीं कर रहा था?

कृपया GitHub पर अपनी प्रतिक्रिया साझा करें।