Halaman ini diterjemahkan oleh Cloud Translation API.
Switch to English

Kiat kinerja

Dokumen ini memberikan tip kinerja khusus TFDS. Perhatikan bahwa TFDS menyediakan dataset sebagai tf.data.Dataset s, jadi saran dari panduan tf.data tetap berlaku.

Set data benchmark

Gunakan tfds.core.benchmark(ds) untuk mengukur objek tf.data.Dataset apa pun.

Pastikan untuk menunjukkan batch_size= untuk menormalkan hasil (misalnya 100 iter / detik -> 3200 ex / detik). 

ds = tfds.load('mnist', split='train').batch(32).prefetch()
# Display some benchmark statistics
tfds.core.benchmark(ds, batch_size=32)
# Second iteration is much faster, due to auto-caching
tfds.core.benchmark(ds, batch_size=32)

Set data kecil (<GB)

Semua set data TFDS menyimpan data pada disk dalam format TFRecord . Untuk set data kecil (mis. Mnist, Cifar, ...), membaca dari .tfrecord dapat menambah overhead yang signifikan.

Karena set data tersebut cocok dengan memori, dimungkinkan untuk meningkatkan kinerja secara signifikan dengan melakukan caching atau memuat sebelumnya set data tersebut. Perhatikan bahwa TFDS secara otomatis menyimpan kumpulan data kecil (lihat bagian selanjutnya untuk detailnya).

Meng-cache set data

Berikut adalah contoh pipeline data yang secara eksplisit menyimpan set data ke cache setelah menormalkan gambar. 

def normalize_img(image, label):
  """Normalizes images: `uint8` -> `float32`."""
  return tf.cast(image, tf.float32) / 255., label


ds, ds_info = tfds.load(
    'mnist',
    split='train',
    as_supervised=True,  # returns `(img, label)` instead of dict(image=, ...)
    with_info=True,
)
# Applying normalization before `ds.cache()` to re-use it.
# Note: Random transformations (e.g. images augmentations) should be applied
# after both `ds.cache()` (to avoid caching randomness) and `ds.batch()` (for
# vectorization [1]).
ds = ds.map(normalize_img, num_parallel_calls=tf.data.experimental.AUTOTUNE)
ds = ds.cache()
# For true randomness, we set the shuffle buffer to the full dataset size.
ds = ds.shuffle(ds_info.splits['train'].num_examples)
# Batch after shuffling to get unique batches at each epoch.
ds = ds.batch(128)
ds = ds.prefetch(tf.data.experimental.AUTOTUNE)

Saat melakukan iterasi pada kumpulan data ini, iterasi kedua akan jauh lebih cepat daripada yang pertama berkat caching.

Caching otomatis

Secara default, TFDS melakukan cache otomatis set data yang memenuhi batasan berikut:

  • Ukuran kumpulan data total (semua pemisahan) ditentukan dan <250 MiB
  • shuffle_files dinonaktifkan, atau hanya satu pecahan yang dibaca

Dimungkinkan untuk menyisih dari caching otomatis dengan meneruskan try_autocaching=False ke tfds.ReadConfig di tfds.load . Lihat dokumentasi katalog set data untuk melihat apakah set data tertentu akan menggunakan cache otomatis.

Memuat data lengkap sebagai satu Tensor

Jika kumpulan data Anda cocok dengan memori, Anda juga dapat memuat kumpulan data lengkap sebagai satu Tensor atau array NumPy. Anda dapat melakukannya dengan menyetel batch_size=-1 untuk batch_size=-1 semua contoh dalam satu tf.Tensor . Kemudian gunakan tfds.as_numpy untuk konversi dari tf.Tensor ke np.array . 

(img_train, label_train), (img_test, label_test) = tfds.as_numpy(tfds.load(
    'mnist',
    split=['train', 'test'],
    batch_size=-1,
    as_supervised=True,
))

Set data besar

Set data yang besar dipisahkan (dibagi menjadi beberapa file), dan biasanya tidak muat dalam memori sehingga tidak boleh disimpan dalam cache.

Acak dan latih

Selama pelatihan, penting untuk mengacak data dengan baik; data yang diacak dengan buruk dapat menyebabkan akurasi pelatihan lebih rendah.

Selain menggunakan ds.shuffle untuk mengacak record, Anda juga harus menyetel shuffle_files=True untuk mendapatkan perilaku pengacakan yang baik untuk kumpulan data yang lebih besar yang dipecah menjadi beberapa file. Jika tidak, epochs akan membaca pecahan dalam urutan yang sama, sehingga data tidak akan benar-benar diacak. 

ds = tfds.load('imagenet2012', split='train', shuffle_files=True)

Selain itu, ketika shuffle_files=True , TFDS menonaktifkan options.experimental_deterministic , yang mungkin memberikan sedikit peningkatan kinerja. Untuk mendapatkan pengocokan deterministik, dimungkinkan untuk menyisih dari fitur ini dengan tfds.ReadConfig : baik dengan menyetel read_config.shuffle_seed atau menimpa read_config.options.experimental_deterministic .

Secara otomatis membagi data Anda ke seluruh pekerja

Ketika pelatihan pada beberapa pekerja, Anda dapat menggunakan input_context argumen tfds.ReadConfig , sehingga setiap pekerja akan membaca subset data. 

input_context = tf.distribute.InputContext(
    input_pipeline_id=1,  # Worker id
    num_input_pipelines=4,  # Total number of workers
)
read_config = tfds.ReadConfig(
    input_context=input_context,
)
ds = tfds.load('dataset', split='train', read_config=read_config)

Ini melengkapi API subsplit. Pertama, subplit API diterapkan ( train[:50%] diubah menjadi daftar file untuk dibaca), kemudian op ds.shard() diterapkan pada file tersebut. Contoh: saat menggunakan train[:50%] dengan num_input_pipelines=2 , masing-masing dari 2 pekerja akan membaca 1/4 data.

Ketika shuffle_files=True , file shuffle_files=True dalam satu pekerja, tetapi tidak di seluruh pekerja. Setiap pekerja akan membaca subset file yang sama antar epoch.

Penguraian gambar lebih cepat

Secara default TFDS secara otomatis menerjemahkan gambar. Namun, ada kasus di mana akan lebih baik jika melewatkan decoding gambar dengan tfds.decode.SkipDecoding dan secara manual menerapkan op tf.io.decode_image :

  • Saat memfilter contoh (dengan ds.filter ), untuk memecahkan kode gambar setelah contoh difilter.
  • Saat memotong gambar, gunakan fusi tf.image.decode_and_crop_jpeg op.

Kode untuk kedua contoh tersedia di panduan dekode .