Kiat kinerja

Dokumen ini memberikan tip kinerja khusus TensorFlow Datasets (TFDS). Perhatikan bahwa TFDS menyediakan kumpulan data sebagai objek tf.data.Dataset , sehingga saran dari panduan tf.data tetap berlaku.

Kumpulan data tolok ukur

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

Pastikan untuk menunjukkan batch_size= untuk menormalkan hasil (mis. 100 iter/dtk -> 3200 ex/dtk). Ini bekerja dengan semua iterable (misalnya tfds.benchmark(tfds.as_numpy(ds)) ).

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

Kumpulan data kecil (kurang dari 1 GB)

Semua dataset TFDS menyimpan data pada disk dalam format TFRecord . Untuk kumpulan data kecil (mis. MNIST, CIFAR-10/-100), membaca dari .tfrecord dapat menambah overhead yang signifikan.

Karena set data tersebut muat dalam memori, kinerja dapat ditingkatkan secara signifikan dengan melakukan caching atau pra-pemuatan dataset. Perhatikan bahwa TFDS secara otomatis menyimpan kumpulan data kecil (bagian berikut memiliki detailnya).

Meng-cache kumpulan data

Berikut adalah contoh jalur pipa data yang secara eksplisit menyimpan dataset 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.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 mengulangi dataset ini, iterasi kedua akan jauh lebih cepat daripada yang pertama berkat caching.

Caching otomatis

Secara default, TFDS auto-cache (dengan ds.cache() ) 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 keluar dari cache otomatis dengan meneruskan try_autocaching=False ke tfds.ReadConfig di tfds.load . Lihat dokumentasi katalog kumpulan data untuk melihat apakah kumpulan data tertentu akan menggunakan cache otomatis.

Memuat data lengkap sebagai Tensor tunggal

Jika set data Anda sesuai dengan memori, Anda juga dapat memuat set data lengkap sebagai array Tensor atau NumPy tunggal. Dimungkinkan untuk melakukannya dengan menyetel batch_size=-1 untuk mengelompokkan 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,
))

Kumpulan data besar

Kumpulan data besar dipecah (dibagi dalam beberapa file) dan biasanya tidak muat di memori, sehingga tidak boleh di-cache.

Acak dan pelatihan

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

Selain menggunakan ds.shuffle untuk mengacak catatan, Anda juga harus mengatur shuffle_files=True untuk mendapatkan perilaku mengacak yang baik untuk kumpulan data yang lebih besar yang dipecah menjadi beberapa file. Jika tidak, epoch akan membaca shard 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.deterministic , yang mungkin memberikan sedikit peningkatan kinerja. Untuk mendapatkan pengacakan deterministik, dimungkinkan untuk memilih keluar dari fitur ini dengan tfds.ReadConfig : baik dengan menyetel read_config.shuffle_seed atau menimpa read_config.options.deterministic .

Auto-shard data Anda di seluruh pekerja (TF)

Saat melatih beberapa pekerja, Anda dapat menggunakan argumen input_context dari 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, API subplit diterapkan: train[:50%] diubah menjadi daftar file untuk dibaca. Kemudian, operasi ds.shard() diterapkan pada file-file itu. Misalnya, saat menggunakan train[:50%] dengan num_input_pipelines=2 , masing-masing dari 2 pekerja akan membaca 1/4 data.

Saat shuffle_files=True , file diacak dalam satu pekerja, tetapi tidak di seluruh pekerja. Setiap pekerja akan membaca subset file yang sama antara zaman.

Auto-shard data Anda ke seluruh pekerja (Jax)

Dengan Jax, Anda dapat menggunakan tfds.split_for_jax_process atau tfds.even_splits API untuk mendistribusikan data Anda ke seluruh pekerja. Lihat panduan API terpisah .

split = tfds.split_for_jax_process('train', drop_remainder=True)
ds = tfds.load('my_dataset', split=split)

tfds.split_for_jax_process adalah alias sederhana untuk:

# The current `process_index` loads only `1 / process_count` of the data.
splits = tfds.even_splits('train', n=jax.process_count(), drop_remainder=True)
split = splits[jax.process_index()]

Penguraian gambar lebih cepat

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

Kode untuk kedua contoh tersedia di panduan decode .

Lewati fitur yang tidak digunakan

Jika Anda hanya menggunakan sebagian fitur, Anda dapat melewatkan beberapa fitur sepenuhnya. Jika kumpulan data Anda memiliki banyak fitur yang tidak digunakan, tidak mendekodekannya dapat meningkatkan kinerja secara signifikan. Lihat https://www.tensorflow.org/datasets/decode#only_decode_a_sub-set_of_the_features