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

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

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

ทำตามคำแนะนำนี้เพื่อสร้างชุดข้อมูลใหม่ (ทั้งใน 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_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 ซึ่งระบุ:

แหล่งที่มาของข้อมูล (เช่น 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 ออนไลน์ เพื่อสร้างรายการ BibTeX แบบกำหนดเองได้ (เมนูแบบเลื่อนลงมีประเภทรายการ Online )

กำลังอัปเดตไฟล์ TAGS.txt :

แท็กที่อนุญาตทั้งหมดจะถูกกรอกไว้ล่วงหน้าในไฟล์ที่สร้างขึ้นแล้ว
ลบแท็กทั้งหมดที่ไม่เกี่ยวข้องกับชุดข้อมูลออก
แท็กที่ถูกต้องจะแสดงอยู่ในไฟล์ tensorflow_datasets/core/valid_tags.txt
หากต้องการเพิ่มแท็กในรายการดังกล่าว โปรดส่ง Pull Request (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) หรือเพื่อเรียงลำดับตาม 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 ในตัวของ 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())

หรืออีกทางเลือกหนึ่งคือใช้ API tf.io.gfile แทนฟังก์ชันในตัวสำหรับการดำเนินการกับไฟล์:

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

ควรเลือกใช้ Pathlib แทน tf.io.gfile (ดู เหตุผลประกอบ )

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

ชุดข้อมูลบางชุดต้องการไลบรารี 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 )

ดูตัวอย่างชุดข้อมูลที่ใช้ 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`

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

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

ธงบางส่วนที่มีประโยชน์สำหรับการพัฒนา:

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

โปรดดู เอกสารประกอบการใช้งาน CLI สำหรับรายการแฟล็กทั้งหมด

ผลรวมตรวจสอบ

ขอแนะนำให้บันทึกค่าตรวจสอบความถูกต้อง (checksum) ของชุดข้อมูลของคุณ เพื่อรับประกันความแน่นอน ช่วยในการจัดทำเอกสาร ฯลฯ สามารถทำได้โดยการสร้างชุดข้อมูลด้วยตัวเลือก --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