Dokumen ini memberikan tip kinerja khusus TFDS. Perhatikan bahwa TFDS menyediakan dataset sebagaitf.data.Dataset s, jadi saran dari panduan tf.data tetap berlaku.
Benchmark dataset
Gunakan tfds.benchmark(ds) untuk mengukur objektf.data.Dataset apa pun.
Pastikan untuk menunjukkan batch_size= untuk menormalkan hasil (misalnya 100 iter / detik -> 3200 ex / detik). Ini bekerja dengan semua iterable (mis. 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)
Set data kecil (<GB)
Semua dataset TFDS menyimpan data pada disk dalam format TFRecord . Untuk set data kecil (misalnya Mnist, Cifar, ...), membaca dari .tfrecord dapat menambah overhead yang signifikan.
Karena set data tersebut sesuai dengan memori, sangat mungkin 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 meng-cache set data 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 atas 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_filesdinonaktifkan, 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,
))
Kumpulan data besar
Set data besar dipisah-pisahkan (dibagi menjadi beberapa file), dan biasanya tidak muat dalam memori sehingga tidak boleh di-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 dibagi 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_jpegop.
Kode untuk kedua contoh tersedia di panduan dekode .