TFDS รองรับ รูปแบบ Croissant 🥐 แล้ว! อ่าน เอกสาร เพื่อทราบข้อมูลเพิ่มเติม

หน้านี้ได้รับการแปลโดย Cloud Translation API

การเขียนชุดข้อมูลที่กำหนดเอง

ทำตามคำแนะนำนี้เพื่อสร้างชุดข้อมูลใหม่ (ใน TFDS หรือในที่เก็บของคุณเอง)

ตรวจสอบ รายการชุดข้อมูล ของเราเพื่อดูว่าชุดข้อมูลที่คุณต้องการมีอยู่แล้วหรือไม่

TL;ดร

วิธีที่ง่ายที่สุดในการเขียนชุดข้อมูลใหม่คือการใช้ 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

ภาพรวม

ชุดข้อมูลได้รับการเผยแพร่ในทุกรูปแบบและทุกที่ และไม่ได้จัดเก็บไว้ในรูปแบบที่พร้อมป้อนเข้าสู่ไปป์ไลน์ของ Machine Learning เสมอไป ป้อน TFDS

TFDS ประมวลผลชุดข้อมูลเหล่านั้นเป็นรูปแบบมาตรฐาน (ข้อมูลภายนอก -> ไฟล์ซีเรียลไลซ์) ซึ่งสามารถโหลดเป็นไปป์ไลน์การเรียนรู้ของเครื่อง (ไฟล์ซีเรียลไลซ์ -> tf.data.Dataset ) การทำให้เป็นอนุกรมทำได้เพียงครั้งเดียวเท่านั้น การเข้าถึงครั้งต่อไปจะอ่านจากไฟล์ที่ประมวลผลล่วงหน้าเหล่านั้นโดยตรง

การประมวลผลล่วงหน้าส่วนใหญ่จะเสร็จสิ้นโดยอัตโนมัติ ชุดข้อมูลแต่ละชุดใช้คลาสย่อยของ tfds.core.DatasetBuilder ซึ่งระบุ:

ข้อมูลมาจากไหน (เช่น URL)
ชุดข้อมูลมีลักษณะอย่างไร (เช่น คุณสมบัติของชุดข้อมูล)
ควรแบ่งข้อมูลอย่างไร (เช่น TRAIN และ TEST );
และตัวอย่างแต่ละรายการในชุดข้อมูล

เขียนชุดข้อมูลของคุณ

เทมเพลตเริ่มต้น: `tfds new`

ใช้ TFDS CLI เพื่อสร้างไฟล์เทมเพลต Python ที่จำเป็น

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 ซึ่งดูแลส่วนสำเร็จรูปส่วนใหญ่ รองรับ:

ชุดข้อมูลขนาดเล็ก/กลางที่สามารถสร้างได้ในเครื่องเดียว (บทช่วยสอนนี้)
ชุดข้อมูลขนาดใหญ่มากซึ่งต้องมีการสร้างแบบกระจาย (โดยใช้ Apache Beam ดู คำแนะนำชุดข้อมูลขนาดใหญ่ ของเรา)

นี่คือตัวอย่างขั้นต่ำของตัวสร้างชุดข้อมูลที่อิงจาก 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 ทางด้านขวามือ
ค้นหาบทความบน Google Scholar แล้วคลิกเครื่องหมายคำพูดคู่ใต้ชื่อเรื่อง และบนป๊อปอัป คลิก BibTeX
หากไม่มีรายงานที่เกี่ยวข้อง (เช่น มีเพียงเว็บไซต์) คุณสามารถใช้ BibTeX Online Editor เพื่อสร้างรายการ BibTeX แบบกำหนดเองได้ (เมนูแบบเลื่อนลงมีประเภทรายการ Online )

การอัปเดตไฟล์ TAGS.txt :

แท็กที่อนุญาตทั้งหมดจะถูกกรอกไว้ล่วงหน้าในไฟล์ที่สร้างขึ้น
ลบแท็กทั้งหมดที่ไม่เกี่ยวข้องกับชุดข้อมูล
แท็กที่ถูกต้องจะแสดงอยู่ใน tensorflow_datasets/core/valid_tags.txt
หากต้องการเพิ่มแท็กในรายการนั้น โปรดส่ง PR

รักษาลำดับชุดข้อมูล

ตามค่าเริ่มต้น บันทึกของชุดข้อมูลจะถูกสับเปลี่ยนเมื่อจัดเก็บเพื่อทำให้การกระจายคลาสต่างๆ สม่ำเสมอทั่วทั้งชุดข้อมูล เนื่องจากบ่อยครั้งที่บันทึกที่เป็นของคลาสเดียวกันจะต่อเนื่องกัน เพื่อระบุว่าชุดข้อมูลควรจัดเรียงตามคีย์ที่สร้างโดย _generate_examples ควรตั้งค่าฟิลด์ disable_shuffling เป็น True โดยค่าเริ่มต้นจะถูกตั้งค่าเป็น False

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

โปรดทราบว่าการปิดใช้การสับเปลี่ยนจะส่งผลต่อประสิทธิภาพ เนื่องจากไม่สามารถอ่านชาร์ดแบบขนานได้อีกต่อไป

`_split_generators` : ดาวน์โหลดและแยกข้อมูล

การดาวน์โหลดและแยกข้อมูลต้นฉบับ

ชุดข้อมูลส่วนใหญ่จำเป็นต้องดาวน์โหลดข้อมูลจากเว็บ ซึ่งทำได้โดยใช้อาร์กิวเมนต์อินพุต tfds.download.DownloadManager ของ _split_generators 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) หรือเพื่อเรียงลำดับตามคีย์เมื่อปิดใช้งานการสับเปลี่ยน (ดูส่วน การรักษาลำดับชุดข้อมูล ) ควรเป็น:
- Unique : หากสองตัวอย่างใช้คีย์เดียวกัน ข้อยกเว้นจะเกิดขึ้น
- deterministic : ไม่ควรขึ้นอยู่กับ download_dir , คำสั่ง os.path.listdir ,... การสร้างข้อมูลสองครั้งควรให้คีย์เดียวกัน
- เทียบเคียงได้ : หากปิดใช้งานการสับเปลี่ยน คีย์จะถูกใช้เพื่อเรียงลำดับชุดข้อมูล
feature_dict : dict ที่มีค่าตัวอย่าง
- โครงสร้างควรตรงกับ features= โครงสร้างที่กำหนดใน tfds.core.DatasetInfo
- ประเภทข้อมูลที่ซับซ้อน (รูปภาพ วิดีโอ เสียง...) จะถูกเข้ารหัสโดยอัตโนมัติ
- แต่ละฟีเจอร์มักจะยอมรับอินพุตหลายประเภท (เช่น video Accept /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 ในตัวของ Python

dl_manager ส่งคืนวัตถุ ที่คล้าย pathlib ที่เข้ากันได้โดยตรงกับที่เก็บข้อมูล Google Cloud แทน:

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 (ดู ไฟล์ rational .

การพึ่งพาเพิ่มเติม

ชุดข้อมูลบางชุดต้องการการพึ่งพา Python เพิ่มเติมระหว่างการสร้างเท่านั้น ตัวอย่างเช่น ชุดข้อมูล 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 มีหนึ่งการกำหนดค่าต่อคู่อ็อบเจ็กต์ ( cycle_gan/horse2zebra , cycle_gan/monet2photo ,...)

ซึ่งทำได้ผ่าน tfds.core.BuilderConfig :

กำหนดอ็อบเจ็กต์การกำหนดค่าของคุณเป็นคลาสย่อยของ tfds.core.BuilderConfig ตัวอย่างเช่น MyDatasetConfig
```
@dataclasses.dataclass
class MyDatasetConfig(tfds.core.BuilderConfig):
  img_size: Tuple[int, int] = (0, 0)
```
หมายเหตุ: จำเป็นต้องมีค่าเริ่มต้นเนื่องจาก https://bugs.python.org/issue33129

กำหนดสมาชิกคลาส 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

ใช้ self.builder_config ใน MyDataset เพื่อกำหนดค่าการสร้างข้อมูล (เช่น shape=self.builder_config.img_size ) ซึ่งอาจรวมถึงการตั้งค่าที่แตกต่างกันใน _info() หรือการเปลี่ยนแปลงการเข้าถึงข้อมูลการดาวน์โหลด

หมายเหตุ:

แต่ละการกำหนดค่ามีชื่อไม่ซ้ำกัน ชื่อแบบเต็มของการกำหนดค่าคือ dataset_name/config_name (เช่น coco/2017 )
หากไม่ได้ระบุ การกำหนดค่าแรกใน BUILDER_CONFIGS จะถูกใช้ (เช่น tfds.load('c4') มีค่าเริ่มต้นเป็น c4/en )

ดู anli สำหรับตัวอย่างของชุดข้อมูลที่ใช้ BuilderConfig s

เวอร์ชัน

Version สามารถอ้างถึงสองความหมายที่แตกต่างกัน:

เวอร์ชันข้อมูลดั้งเดิม "ภายนอก": เช่น 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 การใช้งานทั่วไป

โปรดตรวจสอบ gotchas การใช้งานทั่วไป

ทดสอบชุดข้อมูลของคุณ

ดาวน์โหลดและเตรียม: `tfds build`

หากต้องการสร้างชุดข้อมูล ให้รัน tfds build จากไดเร็กทอรี my_dataset/ :

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

แฟล็กที่มีประโยชน์สำหรับการพัฒนา:

--pdb : เข้าสู่โหมดการดีบักหากมีข้อยกเว้นเกิดขึ้น
--overwrite : ลบไฟล์ที่มีอยู่หากชุดข้อมูลถูกสร้างขึ้นแล้ว
--max_examples_per_split : สร้างเฉพาะตัวอย่าง X แรกเท่านั้น (ค่าเริ่มต้นคือ 1) แทนที่จะเป็นชุดข้อมูลทั้งหมด
--register_checksums : บันทึกการตรวจสอบของ URL ที่ดาวน์โหลด ควรใช้ในระหว่างการพัฒนาเท่านั้น

ดู เอกสารประกอบของ 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_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