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

इस पेज का अनुवाद 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

सिंहावलोकन

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

टीएफडीएस उन डेटासेट को एक मानक प्रारूप (बाहरी डेटा -> क्रमबद्ध फ़ाइलें) में संसाधित करता है, जिसे बाद में मशीन लर्निंग पाइपलाइन (क्रमबद्ध फ़ाइलें -> 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 फ़ाइल लिखना:

उद्धरण निर्देश के लिए डेटासेट वेबसाइट खोजें (बिबटेक्स प्रारूप में इसका उपयोग करें)।
arXiv पेपर के लिए: पेपर ढूंढें और दाईं ओर BibText लिंक पर क्लिक करें।
Google Scholar पर पेपर ढूंढें और शीर्षक के नीचे दोहरे उद्धरण चिह्न पर क्लिक करें और पॉपअप पर, BibTeX पर क्लिक करें।
यदि कोई संबद्ध दस्तावेज़ नहीं है (उदाहरण के लिए, बस एक वेबसाइट है), तो आप एक कस्टम BibTeX प्रविष्टि बनाने के लिए 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 विभाजन निर्दिष्ट करें। उपयोगकर्ता सबस्प्लिट एपीआई (उदाहरण के लिए 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 स्रोत डेटा से प्रत्येक विभाजन के लिए उदाहरण उत्पन्न करता है।

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

key : उदाहरण पहचानकर्ता. hash(key) का उपयोग करके उदाहरणों को निश्चित रूप से शफ़ल करने के लिए या शफ़लिंग अक्षम होने पर कुंजी द्वारा क्रमबद्ध करने के लिए उपयोग किया जाता है (अनुभाग डेटासेट क्रम बनाए रखें देखें)। होना चाहिए:
- अद्वितीय : यदि दो उदाहरण एक ही कुंजी का उपयोग करते हैं, तो एक अपवाद उठाया जाएगा।
- नियतात्मक : 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 क्लाउड स्टोरेज के साथ सीधे संगत पाथलिब-जैसी ऑब्जेक्ट लौटाता है:

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

json_path = path / 'data/file.json'

json.loads(json_path.read_text())

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

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

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

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

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

यदि आप टीएफडीएस रिपॉजिटरी में डेटासेट जोड़ रहे हैं, तो कृपया 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 उपयोग करें।

दूषित डेटा

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

डेटासेट कॉन्फ़िगरेशन/वेरिएंट (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 आवश्यक है।
डेटा जेनरेशन को कॉन्फ़िगर करने के लिए 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 s का उपयोग करने वाले डेटासेट के उदाहरण के लिए anli देखें।

संस्करण

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

"बाहरी" मूल डेटा संस्करण: उदाहरण के लिए COCO v2019, v2017,...
"आंतरिक" टीएफडीएस कोड संस्करण: उदाहरण के लिए 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') बढ़ानी चाहिए।

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

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

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 : डाउनलोड किए गए यूआरएल के चेकसम को रिकॉर्ड करें। इसका उपयोग केवल विकास के दौरान ही किया जाना चाहिए।

झंडों की पूरी सूची के लिए सीएलआई दस्तावेज़ देखें।

चेकसम

नियतिवाद की गारंटी देने, दस्तावेज़ीकरण में मदद करने के लिए आपके डेटासेट के चेकसम को रिकॉर्ड करने की अनुशंसा की जाती है... यह --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 पर अपनी प्रतिक्रिया साझा करें।