एमएल समुदाय दिवस 9 नवंबर है! TensorFlow, JAX से नई जानकारी के लिए हमसे जुड़ें, और अधिक जानें

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

एक नया डेटासेट बनाने के लिए इस गाइड का पालन करें (या तो TFDS में या अपने स्वयं के भंडार में)।

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

टीएल; डीआर

सबसे आसान तरीका है एक नया डाटासेट लिखने के लिए उपयोग करने के लिए है 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.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 एक मानक प्रारूप में उन डेटासेट (> धारावाहिक फ़ाइलें बाह्य डेटा) को संसाधित tf.data.Dataset )। क्रमांकन केवल एक बार किया जाता है। बाद की पहुंच उन पूर्व-संसाधित फ़ाइलों से सीधे पढ़ी जाएगी।

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

  • डेटा कहां से आ रहा है (अर्थात इसके URL);
  • डेटासेट कैसा दिखता है (यानी इसकी विशेषताएं);
  • कैसे डेटा विभाजन (उदाहरण के लिए होना चाहिए 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
    my_dataset.py # Dataset definition
    my_dataset_test.py # (optional) Test
    dummy_data/ # (optional) Fake data (used for testing)
    checksum.tsv # (optional) URL checksums (see `checksums` section).

के लिए खोज TODO(my_dataset) यहाँ और तदनुसार संशोधित।

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

सभी डेटासेट के रूप में लागू किया जाता है tfds.core.GeneratorBasedBuilder , का एक उपवर्ग tfds.core.DatasetBuilder जो सबसे बॉयलरप्लेट का ख्याल रखता है। यह समर्थन करता है:

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

यहाँ डेटासेट वर्ग का एक न्यूनतम उदाहरण है:

class MyDataset(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 tfds.core.DatasetInfo(
        builder=self,
        features=tfds.features.FeaturesDict({
            'image': tfds.features.Image(shape=(256, 256, 3)),
            'label': tfds.features.ClassLabel(names=['no', 'yes']),
        }),
    )

  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):
  return tfds.core.DatasetInfo(
      builder=self,
      # Description and homepage used for documentation
      description="""
      Markdown description of the dataset. The text will be automatically
      stripped and dedent.
      """,
      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,
      # Bibtex citation for the dataset
      citation=r"""
      @article{my-awesome-dataset-2020,
               author = {Smith, John},}
      """,
  )

अधिकांश क्षेत्र स्व-व्याख्यात्मक होने चाहिए। कुछ सटीक:

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

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

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

def _info(self):
  return tfds.core.DatasetInfo(
    # [...]
    disable_shuffling=True,
    # [...]
  )

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

_split_generators : डाउनलोड और विभाजन डेटा

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

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

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

सभी उन तरीकों रिटर्न tfds.core.ReadOnlyPath है, जो कर रहे हैं 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 विभाजन), उन रहते हैं। अन्यथा, केवल एक ही निर्दिष्ट tfds.Split.TRAIN विभाजन। उपयोगकर्ता गतिशील रूप से अपने स्वयं के subsplits बना सकते हैं subsplit एपीआई (जैसे split='train[80%:]' )।

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) tuples:

  • key : उदाहरण पहचानकर्ता। निर्धारणात्मक लिए उपयोग किए थे उदाहरण शफ़ल hash(key) जब पुथल अक्षम किया गया है कुंजी द्वारा या प्रकार के (देखें अनुभाग डाटासेट क्रम बनाए रखें )। होना चाहिए:
    • अद्वितीय: दो उदाहरण एक ही कुंजी का उपयोग करते हैं, एक अपवाद बढ़ा दी जाएगी।
    • नियतात्मक: चाहिए पर निर्भर नहीं download_dir , os.path.listdir आदेश, ... उत्पन्न डेटा दो बार एक ही कुंजी उपज चाहिए।
    • तुलनीय: अगर पुथल अक्षम किया गया है कुंजी डाटासेट सॉर्ट करने के लिए इस्तेमाल किया जाएगा।
  • feature_dict : एक dict उदाहरण मान हैं।
    • संरचना से मेल खाना चाहिए features= संरचना में परिभाषित tfds.core.DatasetInfo
    • जटिल डेटा प्रकार (छवि, वीडियो, ऑडियो,...) स्वचालित रूप से एन्कोड किए जाएंगे।
    • प्रत्येक सुविधा अक्सर कई इनपुट प्रकार स्वीकार (जैसे वीडियो स्वीकार /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 ops के उपयोग से बचें।

इसके बजाय, dl_manager रिटर्न pathlib की तरह वस्तुओं सीधे 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 के बजाय एपीआई में निर्मित फ़ाइल के संचालन के लिए:

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

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

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

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

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

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

भ्रष्ट डेटा

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

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

कुछ डेटासेट में कई प्रकार हो सकते हैं, या डेटा को पूर्व-संसाधित और डिस्क पर कैसे लिखा जाता है इसके विकल्प हो सकते हैं। उदाहरण के लिए, cycle_gan वस्तु जोड़े (प्रति एक config है cycle_gan/horse2zebra , cycle_gan/monet2photo , ...)।

इस माध्यम से किया जाता tfds.core.BuilderConfig रों:

  1. का एक उपवर्ग के रूप में अपने विन्यास वस्तु को परिभाषित करें tfds.core.BuilderConfig । उदाहरण के लिए, MyDatasetConfig

    @dataclasses.dataclass
    class MyDatasetConfig(tfds.core.BuilderConfig):
      img_size: Tuple[int, int] = (0, 0)
    
  2. परिभाषित करें BUILDER_CONFIGS = [] में वर्ग के सदस्य MyDataset कि सूचियों 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
    
  3. उपयोग self.builder_config में MyDataset कॉन्फ़िगर डेटा पीढ़ी के लिए (जैसे shape=self.builder_config.img_size )। इस में विभिन्न मूल्यों की स्थापना शामिल हो सकते हैं _info() या बदलते डाउनलोड डेटा का उपयोग।

टिप्पणियाँ:

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

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

संस्करण

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

  • "बाहरी" मूल डेटा संस्करण: जैसे 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

सामान्य कार्यान्वयन गोचास के लिए जाँच करें

के लिए जांच करें सामान्य कार्यान्वयन gotchas

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

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

डाटासेट उत्पन्न करने के लिए चलाने के tfds build से my_dataset/ निर्देशिका:

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

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

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

देखें CLI प्रलेखन झंडे की पूरी सूची के।

चेकसम

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

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

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

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

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


class MyDatasetTest(tfds.testing.DatasetBuilderTestCase):
  """Tests for my_dataset dataset."""
  DATASET_CLASS = my_dataset.MyDataset
  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 dummy_data/my_dataset dir.
      'name2': 'file2',
  }


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

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

python my_dataset_test.py

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

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