Performans ipuçları

Bu belge, TensorFlow Veri Kümelerine (TFDS) özel performans ipuçları sağlar. TFDS'nin veri kümelerini tf.data.Dataset nesneleri olarak sağladığını unutmayın, bu nedenle tf.data kılavuzundaki tavsiyeler hala geçerlidir.

Karşılaştırma veri kümeleri

Herhangi bir tf.data.Dataset nesnesini kıyaslamak için tfds.benchmark(ds) kullanın.

Sonuçları normalleştirmek için batch_size= 'ı belirttiğinizden emin olun (örn. 100 iter/sn -> 3200 ex/sn). Bu, herhangi bir yinelenebilir ile çalışır (örneğin 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)

Küçük veri kümeleri (1 GB'den az)

Tüm TFDS veri kümeleri, verileri diskte TFRecord formatında saklar. Küçük veri kümeleri için (örn. MNIST, CIFAR-10/-100), .tfrecord okumak önemli bir ek yük getirebilir.

Bu veri kümeleri belleğe sığdığından, veri kümesini önbelleğe alarak veya önceden yükleyerek performansı önemli ölçüde artırmak mümkündür. TFDS'nin küçük veri kümelerini otomatik olarak önbelleğe aldığını unutmayın (aşağıdaki bölümde ayrıntılar vardır).

Veri kümesini önbelleğe alma

Burada, görüntüleri normalleştirdikten sonra veri kümesini açıkça önbelleğe alan bir veri hattı örneği verilmiştir.

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)

• [1] Haritalamayı vektörleştirme

Bu veri kümesi üzerinde yineleme yapıldığında, önbelleğe alma sayesinde ikinci yineleme ilkinden çok daha hızlı olacaktır.

Otomatik önbelleğe alma

Varsayılan olarak, TFDS, aşağıdaki kısıtlamaları karşılayan veri kümelerini ds.cache() ile) otomatik olarak önbelleğe alır:

• Toplam veri kümesi boyutu (tüm bölümler) tanımlanır ve < 250 MiB
• shuffle_files devre dışı bırakıldı veya yalnızca tek bir parça okundu

tfds.ReadConfig içindeki tfds.load try_autocaching=False öğesini tfds.ReadConfig öğesine ileterek otomatik önbelleğe almayı devre dışı bırakmak mümkündür. Belirli bir veri kümesinin otomatik önbellek kullanıp kullanmayacağını görmek için veri kümesi kataloğu belgelerine bakın.

Tüm verileri tek bir Tensör olarak yükleme

Veri kümeniz belleğe sığıyorsa, tüm veri kümesini tek bir Tensör veya NumPy dizisi olarak da yükleyebilirsiniz. Bunu, tüm örnekleri tek bir tf.Tensor toplu olarak toplu batch_size=-1 ayarlayarak yapmak mümkündür. Ardından tfds.as_numpy dönüştürme için tf.Tensor 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,
))

Büyük veri kümeleri

Büyük veri kümeleri parçalanır (birden çok dosyaya bölünür) ve genellikle belleğe sığmaz, bu nedenle önbelleğe alınmamaları gerekir.

Karıştırma ve eğitim

Eğitim sırasında verileri iyi karıştırmak önemlidir - kötü karıştırılmış veriler daha düşük eğitim doğruluğuna neden olabilir.

Kayıtları karıştırmak için ds.shuffle kullanmaya ek olarak, birden çok dosyaya bölünmüş daha büyük veri kümeleri için iyi karıştırma davranışı elde etmek için shuffle_files=True değerini de ayarlamalısınız. Aksi takdirde, dönemler parçaları aynı sırayla okuyacak ve bu nedenle veriler gerçekten rastgele olmayacaktır.

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

Ek olarak, shuffle_files=True olduğunda, TFDS options.deterministic öğesini devre dışı bırakır, bu da hafif bir performans artışı sağlayabilir. Deterministik karıştırma elde etmek için, tfds.ReadConfig ile bu özelliği devre dışı bırakmak mümkündür: ya read_config.shuffle_seed ayarlayarak ya da read_config.options.deterministic üzerine yazarak.

Verilerinizi çalışanlar arasında otomatik olarak paylaşın (TF)

Birden çok çalışan üzerinde eğitim verirken, tfds.ReadConfig input_context bağımsız değişkenini kullanabilirsiniz, böylece her çalışan verilerin bir alt kümesini okuyacaktır.

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)

Bu, alt bölünmüş API'nin tamamlayıcısıdır. İlk olarak, alt bölüm API'si uygulanır: train[:50%] , okunacak bir dosya listesine dönüştürülür. Ardından, bu dosyalara bir ds.shard() uygulanır. Örneğin, num_input_pipelines=2 ile train[:50%] kullanıldığında, 2 çalışanın her biri verilerin 1/4'ünü okuyacaktır.

shuffle_files=True olduğunda, dosyalar bir çalışan içinde karıştırılır, ancak çalışanlar arasında karıştırılmaz. Her çalışan, dönemler arasında aynı dosya alt kümesini okuyacaktır.

Verilerinizi çalışanlar arasında otomatik olarak parçalayın (Jax)

Jax ile verilerinizi çalışanlar arasında dağıtmak için tfds.split_for_jax_process veya tfds.even_splits API'sini kullanabilirsiniz. Bölünmüş API kılavuzuna bakın.

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

tfds.split_for_jax_process , aşağıdakiler için basit bir diğer addır:

# 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()]

Daha hızlı görüntü kod çözme

Varsayılan olarak, TFDS görüntüleri otomatik olarak çözer. Ancak, tfds.decode.SkipDecoding ile görüntü kod çözme işlemini atlamanın ve tfds.decode.SkipDecoding tf.io.decode_image olarak uygulamanın daha performanslı olabileceği durumlar vardır:

• Örnekleri filtrelerken ( tf.data.Dataset.filter ile), örnekler filtrelendikten sonra görüntülerin kodunu çözmek için.
• Görüntüleri kırparken, kaynaşmış tf.image.decode_and_crop_jpeg kullanmak için.

Her iki örneğin kodu, kod çözme kılavuzunda mevcuttur.

Kullanılmayan özellikleri atla

Özelliklerin yalnızca bir alt kümesini kullanıyorsanız, bazı özellikleri tamamen atlamak mümkündür. Veri kümenizde kullanılmayan birçok özellik varsa, bunların kodunu çözmemek performansı önemli ölçüde iyileştirebilir. https://www.tensorflow.org/datasets/decode#only_decode_a_sub-set_of_the_features'a bakın