TPU hızında veri ardışık düzenleri: tf.data.Dataset ve TFRecords

1. Genel Bakış

TPU'lar çok hızlıdır. Eğitim verileri akışı, eğitim hızlarına ayak uydurmalıdır. Bu laboratuvarda, TPU'nuzu beslemek için tf.data.Dataset API ile GCS'den nasıl veri yükleyeceğinizi öğreneceksiniz.

Bu laboratuvar, "TPU'da Keras" serisinin 1. Bölümüdür. Bu işlemleri aşağıdaki sırayla veya bağımsız olarak yapabilirsiniz.

ca8cc21f6838eccc.png

Neler öğreneceksiniz?

  • Eğitim verilerini yüklemek üzere tf.data.Dataset API'yi kullanmak için
  • Eğitim verilerini GCS'den verimli bir şekilde yüklemek üzere TFRecord biçimini kullanmak için

Geri bildirim

Bu kod laboratuvarında bir sorun görürseniz lütfen bize bildirin. Geri bildirim, GitHub sorunları [geri bildirim bağlantısı] üzerinden gönderilebilir.

2. Google Colaboratory hızlı başlangıç kılavuzu

Bu laboratuvarda Google Ortak Çalışması kullanılmaktadır ve sizin herhangi bir kurulum yapmanız gerekmez. Colaboratory, eğitim amaçlı bir online not defteri platformudur. Ücretsiz CPU, GPU ve TPU eğitimi sunar.

688858c21e3beff2.png

Bu örnek not defterini açıp Colaboratory hakkında bilgi edinmek için birkaç hücreyi inceleyebilirsiniz.

c3df49e90e5a654f.png Welcome to Colab.ipynb

TPU arka ucu seçme

8832c6208c99687d.png

Colab menüsünde, Çalışma zamanı > Çalışma zamanı türünü değiştir'i, ardından TPU'yu seçin. Bu kod laboratuvarında, donanım hızlandırmalı eğitim için desteklenen güçlü bir TPU (Tensör İşleme Birimi) kullanacaksınız. Çalışma zamanına bağlantı, ilk çalıştırma sırasında otomatik olarak kurulur veya sağ üst köşedeki "Bağlan" düğmesini kullanabilirsiniz.

Not defteri yürütme

76d05caa8b4db6da.png

Bir hücreyi tıklayıp Üst Karakter-ENTER tuşlarını kullanarak hücreleri tek tek yürütün. Ayrıca, Çalışma zamanı > Tümünü çalıştır seçeneğini kullanarak not defterinin tamamını da çalıştırabilirsiniz.

İçindekiler

429f106990037ec4.png

Tüm not defterlerinin bir içindekiler tablosu vardır. Soldaki siyah oku kullanarak açabilirsiniz.

Gizli hücreler

edc3dba45d26f12a.png

Bazı hücrelerde yalnızca başlık gösterilir. Bu, Colab'a özgü bir not defteri özelliğidir. Üzerlerini çift tıklayarak içindeki kodu görebilirsiniz, ancak bu durum genellikle pek de ilgi çekici değildir. Genellikle destek veya görselleştirme işlevleridir. İçerideki işlevlerin tanımlanması için bu hücreleri çalıştırmanız gerekir.

Kimlik Doğrulama

cdd4b41413100543.png

Yetkili bir hesapla kimlik doğrulama yaptığınızda Colab'ın gizli Google Cloud Storage paketlerinize erişmesi mümkündür. Yukarıdaki kod snippet'i bir kimlik doğrulama sürecini tetikler.

3. [BİLGİ] Tensor İşleme Birimleri (TPU'lar) nedir?

Özet

f88cf6facfc70166.png

Keras'ta TPU'da model eğitme (ve TPU yoksa GPU veya CPU kullanma) kodu:

try: # detect TPUs
    tpu = tf.distribute.cluster_resolver.TPUClusterResolver.connect()
    strategy = tf.distribute.TPUStrategy(tpu)
except ValueError: # detect GPUs
    strategy = tf.distribute.MirroredStrategy() # for CPU/GPU or multi-GPU machines

# use TPUStrategy scope to define model
with strategy.scope():
  model = tf.keras.Sequential( ... )
  model.compile( ... )

# train model normally on a tf.data.Dataset
model.fit(training_dataset, epochs=EPOCHS, steps_per_epoch=...)

Bu eğitimde, çiçek sınıflandırıcıyı etkileşimli hızlarda (eğitim çalıştırma başına dakika) oluşturmak ve optimize etmek için TPU'ları kullanacağız.

688858c21e3beff2.png

Neden TPU'ları kullanmalısınız?

Modern GPU'lar, programlanabilir "çekirdekler" etrafında düzenlenmiştir. Bu, 3D oluşturma, derin öğrenme, fiziksel simülasyonlar gibi çeşitli görevleri gerçekleştirmelerine olanak tanıyan çok esnek bir mimaridir. Öte yandan TPU'lar, klasik bir vektör işlemcisini özel bir matris çarpma birimi ile eşleştirir ve büyük matris çarpmalarının hakim olduğu tüm görevlerde (ör. sinir ağları) mükemmel performans gösterir.

8eb3e718b8e2ed08.png

Görsel: Matris çarpımı olarak yoğun bir nöral ağ katmanı. Bu katmanda, sekiz resimden oluşan bir grup aynı anda nöral ağ üzerinden işlenir. Bir resmin tüm piksel değerlerinin ağırlıklı toplamını yaptığını doğrulamak için lütfen bir satır x sütun çarpım işlemini gerçekleştirin. Dalgalar katmanları, biraz daha karmaşık olsa da matris çarpımları olarak da temsil edilebilir ( 1. bölümde açıklama).

Donanım

MXU ve VPU

TPU v2 çekirdeği, matris çarpma işlemlerini yürüten bir Matris Çarpma Birimi (MXU) ve etkinleştirme, yumuşak maksimum vb. gibi diğer tüm görevler için bir Vektör İşleme Birimi'nden (VPU) oluşur. VPU, float32 ve int32 hesaplamalarını yönetir. Diğer yandan MXU, karma hassasiyetli 16-32 bit kayan nokta biçiminde çalışır.

7d68944718f76b18.png

Karma hassasiyetli kayan nokta ve bfloat16

MXU, bfloat16 girişlerini ve float32 çıkışlarını kullanarak matris çarpımlarını hesaplar. Ara birikimler, float32 hassasiyetinde gerçekleştirilir.

19c5fc432840c714.png

Sinir ağı eğitimi genellikle daha düşük kayan nokta hassasiyetinden kaynaklanan gürültüye karşı dirençlidir. Gürültünün optimize edicinin yakınlaşmasına bile yardımcı olduğu durumlar vardır. 16 bit kayan nokta hassasiyeti, hesaplamaları hızlandırmak için geleneksel olarak kullanılmıştır ancak float16 ve float32 biçimlerinin aralıkları çok farklıdır. Hassasiyetin float32'den float16'ya düşürülmesi, genellikle fazla ve az akışlara yol açar. Bunun için çeşitli çözümler mevcuttur ancak float16'nın çalışması için genellikle ek işlemler gerekir.

Google'ın TPU'larda bfloat16 biçimini kullanıma sunmasının nedeni budur. bfloat16, float32 ile tam olarak aynı üs bitlerine ve aralığa sahip, kısaltılmış bir float32'dir. Buna ek olarak TPU'lar, matris çarpımlarını bfloat16 girişleriyle ancak float32 çıkışlarıyla karışık hassasiyetle hesaplıyordur, böylece daha düşük hassasiyetten faydalanmak için genellikle hiçbir kod değişikliği gerekmez.

Sistolik dizi

MXU, veri öğelerinin bir dizi donanım hesaplama birimi üzerinden aktığı "sistolik dizi" mimarisi kullanarak matris çarpma işlemlerini donanımda uygular. (Tıpta "sistolik", kalp kasılmalarını ve kan akışını ifade eder. Burada ise veri akışını ifade eder.)

Matris çarpımının temel öğesi, bir matristeki satır ile diğer matristeki sütun arasındaki nokta çarpımıdır (bu bölümün üst kısmındaki resme bakın). Y=X*W matris çarpımı için sonucun bir öğesi şu şekilde olur:

Y[2,0] = X[2,0]*W[0,0] + X[2,1]*W[1,0] + X[2,2]*W[2,0] + ... + X[2,n]*W[n,0]

GPU'da bu nokta çarpımı bir GPU "çekirdeği"ne programlanır ve ardından elde edilen matrisin her değerini aynı anda hesaplamaya çalışmak için paralel olarak kullanılabilen tüm "çekirdeklerde" yürütülür. Elde edilen matris 128x128 boyutundaysa 128x128=16K "çekirdek"in kullanılabilir olması gerekir. Bu da genellikle mümkün değildir. En büyük GPU'lar yaklaşık 4.000 çekirdeğe sahiptir. TPU'da ise MXU'daki işlem birimleri için minimum donanım kullanılır: Yalnızca bfloat16 x bfloat16 => float32 çarpma toplayıcısı kullanılır, başka hiçbir şey yoktur. Bu üniteler o kadar küçüktür ki bir TPU, 128x128 MXU'da 16.000 tane uygulayabilir ve bu matris çarpımını tek seferde işleyebilir.

f1b283fc45966717.gif

Görsel: MXU sistolik dizisi. İşlem öğeleri çarpma toplayıcılardır. Bir matrisin değerleri diziye (kırmızı noktalar) yüklenir. Diğer matrisin değerleri diziden akar (gri noktalar). Dikey çizgiler, değerleri yukarı doğru yayar. Yatay çizgiler kısmi toplamları dağıtır. Veriler dizi boyunca akarken sağ taraftan çıkan matris çarpımının sonucunu aldığınızı doğrulamak kullanıcıya bırakılmıştır.

Buna ek olarak, skaler çarpımlar bir MXU'da hesaplanırken ara toplamlar bitişik hesaplama birimleri arasında kolayca akar. Depolanmaları ve belleğe, hatta bir kayıt dosyasına/belgeden alınmalarına gerek yoktur. Sonuçta TPU sistolik dizi mimarisi önemli bir yoğunluk ve güç avantajına sahip olmanın yanı sıra matris çarpımlarını hesaplarken GPU'ya göre göz ardı edilemez bir hız avantajına sahiptir.

Cloud TPU

Google Cloud Platform'da bir "Cloud TPU v2" isteğinde bulunduğunuzda, PCI'ye bağlı TPU kartı olan bir sanal makine elde edersiniz. TPU kartında dört adet çift çekirdekli TPU çipi bulunur. Her TPU çekirdeğinde bir VPU (Vektör İşleme Birimi) ve 128x128 MXU (Matris Çarpma Birimi) bulunur. Bu "Cloud TPU" daha sonra genellikle ağ üzerinden istek gönderen sanal makineye bağlanır. Tam tablo şöyle görünür:

dfce5522ed644ece.png

Çizim: Ağa bağlı "Cloud TPU" hızlandırıcıya sahip sanal makineniz. "Cloud TPU", üzerinde dört adet çift çekirdekli TPU çipi bulunan PCI bağlı bir TPU kartına sahip bir sanal makineden oluşur.

TPU kapsülleri

Google'ın veri merkezlerinde TPU'lar, yüksek performanslı bilgi işlem (HPC) ara bağlantısına bağlıdır. Bu bağlantı, TPU'ların çok büyük bir hızlandırıcı gibi görünmesini sağlayabilir. Google bunlara kapsül adını verir ve en fazla 512 TPU v2 çekirdek veya 2048 TPU v3 çekirdeklerini kapsayabilir.

2ec1e0d341e7fc34.jpeg

Görsel: TPU v3 kapsülü. HPC Interconnect üzerinden bağlı TPU kartları ve raflar.

Eğitim sırasında, tamamen azaltma algoritması kullanılarak TPU çekirdekleri arasında gradyanlar değiştirilir ( tüm azaltmaların iyi açıklamasını burada bulabilirsiniz). Eğitilen model, büyük toplu boyutlar üzerinde eğitim yaparak donanımdan yararlanabilir.

d97b9cc5d40fdb1d.gif

Çizim: Google TPU'nun 2D toroidal örgü HPC ağında tamamen azaltma algoritması kullanılarak eğitim sırasında gradyanların senkronizasyonu.

Yazılım

Büyük gruplar için eğitim

TPU'lar için ideal toplu boyut, TPU çekirdeği başına 128 veri öğesidir ancak donanım, TPU çekirdeği başına 8 veri öğesi ile bile iyi bir kullanım gösterebilir. Cloud TPU'da 8 çekirdek olduğunu unutmayın.

Bu kod laboratuvarında Keras API'yi kullanacağız. Keras'ta belirttiğiniz grup, TPU'nun tamamı için genel grup boyutudur. Gruplarınız otomatik olarak 8'e bölünür ve TPU'nun 8 çekirdeğinde çalıştırılır.

da534407825f01e3.png

Ek performans ipuçları için TPU Performans Kılavuzu'na bakın. Çok büyük toplu reklam boyutları için bazı modellerde özel dikkat gösterilmesi gerekebilir. Daha fazla ayrıntı için LARSOptimizer bölümüne bakın.

Perde arkası: XLA

Tensorflow programları hesaplama grafiklerini tanımlar. TPU, doğrudan Python kodunu değil, Tensorflow programınız tarafından tanımlanan hesaplama grafiğini çalıştırır. Arka planda, XLA (hızlandırılmış doğrusal cebir derleyicisi) adlı bir derleyici, işleme düğümlerinin Tensorflow grafiğini TPU makine koduna dönüştürür. Bu derleyici, kodunuzda ve bellek düzeninizde birçok gelişmiş optimizasyon da gerçekleştirir. İş TPU'ya gönderilirken derleme otomatik olarak gerçekleşir. Derleme zincirinize açıkça XLA eklemeniz gerekmez.

edce61112cd57972.png

Çizim: TPU'da çalıştırmak için Tensorflow programınız tarafından tanımlanan hesaplama grafiği önce XLA (hızlandırılmış doğrusal Cebir derleyici) temsiline dönüştürülür, ardından XLA tarafından TPU makine koduna derlenir.

Keras'ta TPU'ları kullanma

TPU'lar, Tensorflow 2.1 itibarıyla Keras API aracılığıyla desteklenmektedir. Keras desteği, TPU'larda ve TPU kapsüllerinde çalışır. TPU, GPU ve CPU'da çalışan bir örnek aşağıda verilmiştir:

try: # detect TPUs
    tpu = tf.distribute.cluster_resolver.TPUClusterResolver.connect()
    strategy = tf.distribute.TPUStrategy(tpu)
except ValueError: # detect GPUs
    strategy = tf.distribute.MirroredStrategy() # for CPU/GPU or multi-GPU machines

# use TPUStrategy scope to define model
with strategy.scope():
  model = tf.keras.Sequential( ... )
  model.compile( ... )

# train model normally on a tf.data.Dataset
model.fit(training_dataset, epochs=EPOCHS, steps_per_epoch=...)

Bu kod snippet'inde:

  • TPUClusterResolver().connect(), ağdaki TPU'yu bulur. Çoğu Google Cloud sisteminde (AI Platform işleri, Colaboratory, Kubeflow, "ctpu up" yardımcı programıyla oluşturulan derin öğrenme sanal makineleri) parametre olmadan çalışır. Bu sistemler, TPU_NAME ortam değişkeni sayesinde TPU'larının nerede olduğunu bilir. TPU'yu manuel olarak oluşturursanız TPU_NAME ortam değişkenini, kullandığınız sanal makinede ayarlayın veya TPUClusterResolver'yi açık parametrelerle çağırın: TPUClusterResolver(tp_uname, zone, project)
  • TPUStrategy, dağıtım ve "tüm azalt" gradyan senkronizasyon algoritmasını uygulayan kısımdır.
  • Strateji bir kapsam aracılığıyla uygulanır. Model, strategy scope() içinde tanımlanmalıdır.
  • tpu_model.fit işlevi, TPU eğitimi için giriş olarak bir tf.data.Dataset nesnesi bekler.

TPU'ya aktarmayla ilgili yaygın görevler

  • Bir Tensorflow modeline veri yüklemenin birçok yolu olsa da TPU'lar için tf.data.Dataset API'nin kullanılması gerekir.
  • TPU'lar çok hızlıdır ve üzerinde çalışırken veri kullanımı genellikle performans sorunlarına yol açar. TPU Performans Kılavuzu'nda, veri sorunlarını tespit etmek için kullanabileceğiniz araçlar ve diğer performans ipuçlarını bulabilirsiniz.
  • int8 veya int16 sayıları, int32 olarak kabul edilir. TPU'da 32 bitten az çalışan tam sayı donanımı yoktur.
  • Bazı Tensorflow işlemleri desteklenmez. Listeyi burada bulabilirsiniz. Neyse ki bu sınırlama, yalnızca eğitim kodu (modelinizde ileri ve geri geçiş) için geçerlidir. CPU'da yürütüleceğinden, veri giriş ardışık düzeninizdeki tüm Tensorflow işlemlerini kullanmaya devam edebilirsiniz.
  • tf.py_func, TPU'da desteklenmez.

4. Veriler Yükleniyor

c0ecb860e4cad0a9.jpeg cc4781a7739c49ae.jpeg 81236b00f8bbf39e.jpeg 961e2228974076bb.jpeg 7517dc163bdffcd5.jpeg 96392df4767f566d.png

Çiçek resimleri veri kümesiyle çalışacağız. Amaç, bu bitkileri 5 çiçek türüne ayırmayı öğrenmek. Veri yükleme işlemi tf.data.Dataset API kullanılarak gerçekleştirilir. Öncelikle API'yi tanıyalım.

Uygulamalı

Lütfen aşağıdaki not defterini açın, hücreleri yürütün (Üst Karakter-ENTER) ve "İŞ GEREKLİ" etiketini gördüğünüz her yerde talimatları uygulayın.

c3df49e90e5a654f.png Fun with tf.data.Dataset (playground).ipynb

Ek bilgiler

"flowers" veri kümesi hakkında

Veri kümesi 5 klasörde düzenlenmiştir. Her klasörde bir türden çiçekler bulunur. Klasörler ayçiçeği, papatya, karahindiba, lale ve gül olarak adlandırılmıştır. Veriler, Google Cloud Storage'da herkese açık bir pakette barındırılır. Alıntı:

gs://flowers-public/sunflowers/5139971615_434ff8ed8b_n.jpg
gs://flowers-public/daisy/8094774544_35465c1c64.jpg
gs://flowers-public/sunflowers/9309473873_9d62b9082e.jpg
gs://flowers-public/dandelion/19551343954_83bb52f310_m.jpg
gs://flowers-public/dandelion/14199664556_188b37e51e.jpg
gs://flowers-public/tulips/4290566894_c7f061583d_m.jpg
gs://flowers-public/roses/3065719996_c16ecd5551.jpg
gs://flowers-public/dandelion/8168031302_6e36f39d87.jpg
gs://flowers-public/sunflowers/9564240106_0577e919da_n.jpg
gs://flowers-public/daisy/14167543177_cd36b54ac6_n.jpg

Neden tf.data.Dataset?

Keras ve Tensorflow, tüm eğitim ve değerlendirme işlevlerinde veri kümelerini kabul eder. Bir veri kümesine veri yüklediğinizde API, nöral ağ eğitimi verileri için yararlı olabilecek tüm yaygın işlevleri sunar:

dataset = ... # load something (see below)
dataset = dataset.shuffle(1000) # shuffle the dataset with a buffer of 1000
dataset = dataset.cache() # cache the dataset in RAM or on disk
dataset = dataset.repeat() # repeat the dataset indefinitely
dataset = dataset.batch(128) # batch data elements together in batches of 128
AUTOTUNE = tf.data.AUTOTUNE
dataset = dataset.prefetch(AUTOTUNE) # prefetch next batch(es) while training

Performansla ilgili ipuçları ve veri kümesi en iyi uygulamalarını bu makalede bulabilirsiniz. Referans belgeleri burada bulabilirsiniz.

tf.data.Dataset ile ilgili temel bilgiler

Veriler genellikle birden fazla dosyada (burada resimler) gelir. Aşağıdakileri çağırarak dosya adlarından oluşan bir veri kümesi oluşturabilirsiniz:

filenames_dataset = tf.data.Dataset.list_files('gs://flowers-public/*/*.jpg')
# The parameter is a "glob" pattern that supports the * and ? wildcards.

Daha sonra her bir dosya adına bir işlev "eşlersiniz". Bu işlev genellikle dosyayı yükleyip kodu çözerek bellekteki gerçek verilere dönüştürür:

def decode_jpeg(filename):
  bits = tf.io.read_file(filename)
  image = tf.io.decode_jpeg(bits)
  return image

image_dataset = filenames_dataset.map(decode_jpeg)
# this is now a dataset of decoded images (uint8 RGB format)

Bir veri kümesini yinelemek için:

for data in my_dataset:
  print(data)

Tuple'ların veri kümeleri

Gözetimli öğrenmede eğitim veri kümesi genellikle eğitim verileri ve doğru yanıtlardan oluşur. Buna izin vermek için kod çözme işlevi demetleri döndürebilir. Daha sonra, üzerinde iterasyon yaptığınızda tuple ve tuplelardan oluşan bir veri kümeniz olur. Döndürülen değerler, modeliniz tarafından kullanılmaya hazır Tensorflow tenzorlarıdır. Ham değerleri görmek için bu işlevleri .numpy() ile çağırabilirsiniz:

def decode_jpeg_and_label(filename):
  bits = tf.read_file(filename)
  image = tf.io.decode_jpeg(bits)
  label = ... # extract flower name from folder name
  return image, label

image_dataset = filenames_dataset.map(decode_jpeg_and_label)
# this is now a dataset of (image, label) pairs 

for image, label in dataset:
  print(image.numpy().shape, label.numpy())

Sonuç:Resimleri tek tek yüklemek uzun sürüyor!

Bu veri kümesini iterasyonla ilerlerken saniyede 1-2 resim yükleyebileceğinizi görürsünüz. Bu çok yavaş! Eğitim için kullanacağımız donanım hızlandırıcılar bu hızı birkaç kat sürdürebilir. Bunu nasıl başaracağımızı görmek için sonraki bölüme geçin.

Çözüm

Çözüm not defterini burada bulabilirsiniz. Sorun yaşadığınızda bu özelliği kullanabilirsiniz.

c3df49e90e5a654f.png Fun with tf.data.Dataset (solution).ipynb

İşlediklerimiz

  • 🤔 tf.data.Dataset.list_files
  • 🤔 tf.data.Dataset.map
  • 🤔 Tuple'ların veri kümeleri
  • 😀 Veri kümelerinde iterasyon

Lütfen bir dakikanızı ayırarak bu yapılacaklar listesini zihninizde inceleyin.

5. Veriler hızlı yükleniyor

Bu laboratuvarda kullanacağımız Tensor İşleme Birimi (TPU) donanım hızlandırıcıları çok hızlıdır. Buradaki zorluk, genellikle onları meşgul edecek kadar hızlı veri beslemektir. Google Cloud Storage (GCS), çok yüksek işleme hızını sürdürebilir ancak tüm bulut depolama sistemlerinde olduğu gibi, bağlantı başlatmak için bazı ağlar arasında bağlantı kurmanız gerekir. Bu nedenle, verilerimizin binlerce ayrı dosya halinde depolanması ideal değildir. Bunları daha az sayıda dosya halinde gruplandıracağız ve paralel olarak birden çok dosyadan okuma yapmak için tf.data.Dataset'in gücünü kullanacağız.

Okuma

Resim dosyalarını yükleyen, ortak bir boyuta yeniden boyutlandıran ve ardından 16 TFRecord dosyasında depolayan kod aşağıdaki not defterindedir. Lütfen hızlıca okuyun. Codelab'in geri kalanı için TFRecord biçimindeki veriler doğru şekilde sağlanacağından bu işlemin yürütülmesi gerekmez.

c3df49e90e5a654f.png Flower pictures to TFRecords.ipynb

Optimum GCS işleme hızı için ideal veri düzeni

TFRecord dosya biçimi

Verileri depolamak için Tensorflow'un tercih ettiği dosya biçimi protobuf tabanlı TFRecord biçimidir. Diğer serileştirme biçimleri de işe yarar ancak aşağıdakileri yazarak doğrudan TFRecord dosyalarından veri kümesi yükleyebilirsiniz:

filenames = tf.io.gfile.glob(FILENAME_PATTERN)
dataset = tf.data.TFRecordDataset(filenames)
dataset = dataset.map(...) # do the TFRecord decoding here - see below

En iyi performans için birden fazla TFRecord dosyasını aynı anda okumak üzere aşağıdaki daha karmaşık kodu kullanmanız önerilir. Bu kod, N dosyadan paralel olarak veri okur ve okuma hızı için veri sırasını dikkate almaz.

AUTOTUNE = tf.data.AUTOTUNE
ignore_order = tf.data.Options()
ignore_order.experimental_deterministic = False

filenames = tf.io.gfile.glob(FILENAME_PATTERN)
dataset = tf.data.TFRecordDataset(filenames, num_parallel_reads=AUTOTUNE)
dataset = dataset.with_options(ignore_order)
dataset = dataset.map(...) # do the TFRecord decoding here - see below

TFRecord ile ilgili yardımcı kısa bilgiler

TFRecords'ta üç tür veri depolanabilir: bayt dizeleri (bayt listesi), 64 bit tam sayılar ve 32 bit kayan sayılar. Her zaman liste olarak depolanırlar. Tek bir veri öğesi, 1 boyutunda bir liste olur. Verileri TFRecords'a depolamak için aşağıdaki yardımcı işlevleri kullanabilirsiniz.

bayt dizeleri yazma

# warning, the input is a list of byte strings, which are themselves lists of bytes
def _bytestring_feature(list_of_bytestrings):
  return tf.train.Feature(bytes_list=tf.train.BytesList(value=list_of_bytestrings))

tam sayılar yazma

def _int_feature(list_of_ints): # int64
  return tf.train.Feature(int64_list=tf.train.Int64List(value=list_of_ints))

yazılar yüzüyor

def _float_feature(list_of_floats): # float32
  return tf.train.Feature(float_list=tf.train.FloatList(value=list_of_floats))

yukarıdaki yardımcıları kullanarak bir TFRecord yazarak

# input data in my_img_bytes, my_class, my_height, my_width, my_floats
with tf.python_io.TFRecordWriter(filename) as out_file:
  feature = {
    "image": _bytestring_feature([my_img_bytes]), # one image in the list
    "class": _int_feature([my_class]),            # one class in the list
    "size": _int_feature([my_height, my_width]),  # fixed length (2) list of ints
    "float_data": _float_feature(my_floats)       # variable length  list of floats
  }
  tf_record = tf.train.Example(features=tf.train.Features(feature=feature))
  out_file.write(tf_record.SerializeToString())

TFRecords'taki verileri okumak için önce depoladığınız kayıtların düzenini belirtmeniz gerekir. Bildirimde, adlandırılmış herhangi bir alana sabit uzunlukta liste veya değişken uzunlukta liste olarak erişebilirsiniz:

TFRecords'tan okuma

def read_tfrecord(data):
  features = {
    # tf.string = byte string (not text string)
    "image": tf.io.FixedLenFeature([], tf.string), # shape [] means scalar, here, a single byte string
    "class": tf.io.FixedLenFeature([], tf.int64),  # shape [] means scalar, i.e. a single item
    "size": tf.io.FixedLenFeature([2], tf.int64),  # two integers
    "float_data": tf.io.VarLenFeature(tf.float32)  # a variable number of floats
  }

  # decode the TFRecord
  tf_record = tf.io.parse_single_example(data, features)

  # FixedLenFeature fields are now ready to use
  sz = tf_record['size']

  # Typical code for decoding compressed images
  image = tf.io.decode_jpeg(tf_record['image'], channels=3)

  # VarLenFeature fields require additional sparse.to_dense decoding
  float_data = tf.sparse.to_dense(tf_record['float_data'])

  return image, sz, float_data

# decoding a tf.data.TFRecordDataset
dataset = dataset.map(read_tfrecord)
# now a dataset of triplets (image, sz, float_data)

Faydalı kod snippet'leri:

tek veri öğelerini okuma

tf.io.FixedLenFeature([], tf.string)   # for one byte string
tf.io.FixedLenFeature([], tf.int64)    # for one int
tf.io.FixedLenFeature([], tf.float32)  # for one float

sabit boyutlu öğe listelerini okuma

tf.io.FixedLenFeature([N], tf.string)   # list of N byte strings
tf.io.FixedLenFeature([N], tf.int64)    # list of N ints
tf.io.FixedLenFeature([N], tf.float32)  # list of N floats

değişken sayıda veri öğesini okuma

tf.io.VarLenFeature(tf.string)   # list of byte strings
tf.io.VarLenFeature(tf.int64)    # list of ints
tf.io.VarLenFeature(tf.float32)  # list of floats

VarLenFeature, seyrek bir vektör döndürür ve TFRecord'un kodunu çözdükten sonra ek bir adım gerekir:

dense_data = tf.sparse.to_dense(tf_record['my_var_len_feature'])

TFRecords'ta isteğe bağlı alanlar da bulunabilir. Bir alanı okurken varsayılan bir değer belirtirseniz alan eksikse hata yerine varsayılan değer döndürülür.

tf.io.FixedLenFeature([], tf.int64, default_value=0) # this field is optional

İşlediklerimiz

  • 🤔 GCS'den hızlı erişim için veri dosyalarını parçalama
  • 🔗 TFRecord'lar nasıl yazılır? (Söz dizimini unuttunuz mu? Sorun değil, bu sayfayı şifre defteri olarak yer işareti olarak ekleyin.)
  • 🤔 TFRecordDataset kullanarak TFRecords'den veri kümesi yükleme

Lütfen bir dakikanızı ayırarak bu yapılacaklar listesini zihninizde inceleyin.

6. Tebrikler!

Artık TPU'ya veri besleyebilirsiniz. Lütfen sonraki laboratuvara geçin

Uygulamada TPU'lar

TPU'lar ve GPU'lar Cloud AI Platform'da mevcuttur:

Son olarak, geri bildirimlere değer veriyoruz. Bu laboratuvarda yanlış bir şey görürseniz veya iyileştirilmesini düşünürseniz lütfen bize bildirin. Geri bildirimlerinizi, GitHub sorunları [feedback link] sayfasında bulabilirsiniz.

HR.png

Martin Görner kimliği small.jpg
Yazar: Martin Görner
Twitter: @martin_gorner