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 verisi akışı, eğitim hızı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 Keres"in 1. bölümüdür. seri. Bunları aşağıdaki sırayla veya bağımsız olarak yapabilirsiniz.

• [THIS LAB] TPU hızında veri ardışık düzenleri: tf.data.Dataset ve TFRecords
• Aktarımla öğrenme özellikli ilk Keras modeliniz
• Keras ve TPU'larla kıvrımlı nöral ağlar
• Modern dönş., squeezenet, Xception, Keras ve TPU'lar

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 yanlışlık görürseniz lütfen bize bildirin. Geri bildirimlerinizi, GitHub sorunları [feedback link] sayfasında bulabilirsiniz.

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

Bu laboratuvarda Google Collaboratory kullanılı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.

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

Welcome to Colab.ipynb

TPU arka ucu seçin

Colab menüsünde Çalışma zamanı > Çalışma zamanı türünü değiştirin ve 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ı bağlantısı ilk çalıştırma sırasında otomatik olarak kurulur. Alternatif olarak, düğmesini tıklayın.

Not defteri yürütme

Bir hücreyi tıklayıp Üst Karakter-ENTER tuşlarını kullanarak hücreleri tek tek yürütün. Not defterinin tamamını da Çalışma zamanı > Tümünü çalıştır

İçindekiler

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

Gizli hücreler

Bazı hücrelerde yalnızca başlık gösterilir. Bu, Colab'e özel 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 işlevleri destekler veya görselleştirme yapar. İçerideki işlevlerin tanımlanması için bu hücreleri yine de çalıştırmanız gerekir.

Kimlik Doğrulama

Yetkili bir hesapla kimlik doğrulaması yapmanız koşuluyla Colab, gizli Google Cloud Storage paketlerinize erişebilir. Yukarıdaki kod snippet'i bir kimlik doğrulama işlemini tetikler.

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

Özet

TPU'lar, derin öğrenme görevlerinde uzmanlaşmış donanım hızlandırıcılardır. Bu kod laboratuvarında, bunları Keras ve Tensorflow 2 ile nasıl kullanacağınızı öğreneceksiniz. Cloud TPU'lar, 8 çekirdekli bir temel yapılandırmada ve "TPU kapsülleri" adı verilen daha büyük yapılandırmalarda sunulur. Maksimum 2.048 çekirdek. Ek donanım, eğitim grubu boyutunu artırarak eğitimi hızlandırmak için kullanılabilir.

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=...)

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

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, bir klasik vektör işlemciyi özel bir matris çarpım birimiyle eşleştirir ve nöral ağlar gibi büyük matris çarpımlarının baskın olduğu tüm görevlerde üstün başarı elde eder.

Çizim: Bir matris çarpımı olarak yoğun bir nöral ağ katmanı ve aynı anda nöral ağ üzerinden işlenen sekiz görüntüden oluşan bir katman. 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. Kıvrımlı katmanlar, biraz daha karmaşık olsa da matris çarpımları olarak da ifade edilebilir ( açıklama, 1. bölümdeki).

Donanım

MXU ve VPU

TPU v2 çekirdeği, matris çarpımları çalıştıran bir Matris Çarpma Biriminden (MXU) ve etkinleştirmeler, softmax vb. diğer tüm görevler için bir Vektör İşleme Birimi (VPU)ndan oluşur. VPU, float32 ve int32 hesaplamalarını yürütür. Diğer yandan MXU, karma hassasiyetli 16-32 bit kayan nokta biçiminde çalışır.

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.

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 geleneksel olarak hesaplamaları hızlandırmak için kullanılır, ancak float16 ve float32 biçimleri çok farklı aralıklara sahiptir. Hassasiyeti float32'den float16'ya düşürmek, 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.

Bu nedenle Google, TPU'larda bfloat16 biçimini kullanıma sunmuştur. 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.

bfloat16/float32 karma hassasiyet kullanımı, TPU'larda varsayılan olarak kullanılır. Etkinleştirmek için Tensorflow kodunuzda herhangi bir kod değişikliği yapmanız gerekmez. Kodunuzun tamamında float32 ile çalışmaya devam edersiniz. Matris çarpım işlemi yapılırken TPU, girişlerini otomatik olarak keserek bfloat16'ya getirir. Elde edilen matris, kayan noktalı32'dir.

Sistolik dizi

MXU, "sistolik dizi" adı verilen bir donanım kullanarak donanımda matris çarpımlarını uygular veri öğelerinin bir dizi donanım hesaplama biriminden geçtiği mimari. (Tıpta "sistolik" terimi, kalp kasılmalarını ve buradan veri akışını ifade eder.)

Matris çarpımlarının temel öğesi, bir matristeki çizgi ile diğer matristeki bir 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 ürünü bir GPU "çekirdek" olarak programlanır ve ardından tüm "çekirdek" modellerinde Böylece, sonuç matrisin her değerini bir kerede hesaplamayı deneyebilirsiniz. Sonuç matris 128x128 büyükse 128x128=16K "çekirdek" gerektirir kullanılabilir ve genellikle bu 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. Bunlar o kadar küçüktür ki TPU, bunların 16K'sını 128x128 MXU'ya uygulayabilir ve bu matris çarpımını tek seferde işleyebilir.

Çizim: MXU sistolik dizisi. Compute elemanları çarpma toplayıcılarıdır. Bir matrisin değerleri diziye (kırmızı noktalar) yüklenir. Diğer matrisin değerleri, diziden (gri noktalar) geçer. Dikey çizgiler, değerleri yukarı doğru yayar. Yatay çizgiler kısmi toplamları yayar. Veriler, diziden geçerken sağ taraftan çıkan matris çarpımının sonucunu elde ettiğinizi doğrulamak için kullanıcıya bir alıştırma olarak bırakılır.

Buna ek olarak nokta çarpımları, MXU cinsinden hesaplanırken ara toplamlar, bitişik hesap birimleri arasında geçiş yapar. 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

Bir " Cloud TPU v2 inç Google Cloud Platform'da, PCI'ye bağlı TPU kartı olan bir sanal makine alırsınız. TPU kartında dört adet çift çekirdekli TPU çipi bulunur. Her TPU çekirdeğinde bir VPU (Vektör İşleme Birimi) ve 128x128 MXU (MatriX çarpma Birimi) bulunur. Bu "Cloud TPU" daha sonra genellikle ağ üzerinden bunu isteyen sanal makineye bağlanır. Tam tablo şu şekilde görünür:

Çizim: Ağa bağlı "Cloud TPU" ile sanal makineniz hızlandırıcı. "Cloud TPU" kendisi üzerinde dört adet çift çekirdekli TPU çipi bulunan PCI'ye bağlı TPU kartı bulunan bir sanal makineden oluşuyor.

TPU kapsülleri

Google'ın veri merkezlerinde TPU'lar, yüksek performanslı bir 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.

Çizim: TPU v3 kapsülü. HPC ara bağlantısı üzerinden bağlanan 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.

Ç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 iş boyutu, TPU çekirdeği başına 128 veri öğesidir ancak donanım zaten TPU çekirdeği başına 8 veri öğesinden iyi bir kullanım gösterebilmektedir. Cloud TPU'da 8 çekirdek olduğunu unutmayın.

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

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.

Gelişmiş seçenekler: XLA

Tensorflow programları hesaplama grafiklerini tanımlar. TPU, Python kodunu doğrudan çalıştırmaz, Tensorflow programınız tarafından tanımlanan hesaplama grafiğini çalıştırır. Tüm bunların altında XLA (hızlandırılmış doğrusal cebir derleyici) adlı bir derleyici, hesaplama 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.

Çizim: TPU'da çalışmak 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'lar ve TPU kapsülleri üzerinde çalışır. Aşağıda TPU, GPU ve CPU'da çalışan bir örnek 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ğda 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. Elle bir TPU oluşturursanız TPU_NAME env. var. sanal makinede arayın veya açık parametrelerle TPUClusterResolver işlevini çağırın: TPUClusterResolver(tp_uname, zone, project)
• TPUStrategy, dağıtım ve "all-reduce"un uygulandığı kısımdır. gradyan senkronizasyon algoritmasından yararlanabilirsiniz.
• 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 girişi için bir tf.data.Dataset nesnesi bekler.

Genel TPU bağlantı noktası görevleri

• Tensorflow modelinde 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'nun, 32 bitten düşük değerler üzerinde ç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üldüğünden, veri girişi ardışık düzeninizdeki tüm Tensorflow işlemlerini kullanmaya devam edebilirsiniz.
• tf.py_func, TPU'da desteklenmez.

4. Veriler Yükleniyor

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

Uygulamalı

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

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

Ek bilgiler

"Çiçekler" hakkında veri kümesi

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ını 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 dosya halinde gelir (burada resimler). Aşağıdakileri çağırarak dosya adlarından 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.

Ardından "haritalar" her bir dosya adına, genellikle dosyayı yükleyip kodu çözerek bellekteki gerçek verilere dönüştürecek bir işleve 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 verisi çiftlerinden 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 tensörleridir. İşlenmemiş değerleri görmek için bu öğelerde .numpy() yöntemini ç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 tekrarlarken saniyede 1-2 görüntü gibi bir şey yükleyebileceğinizi göreceksiniz. 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. Takılırsanız kullanabilirsiniz.

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ümeleriyle yineleme

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. İşin zor kısmı, genellikle onları meşgul edecek kadar hızlı şekilde verileri 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 getiren ve 16 TFRecord dosyası genelinde depolayan kod aşağıdaki not defterinde bulunur. 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.

Flower pictures to TFRecords.ipynb

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

Genel kural, verilerinizi birkaç (10 ila 100 saniye) büyük boyutlu dosyalara (10 ila 100 MB) bölmektir. Çok fazla dosyanız, örneğin binlerce dosyanız varsa her bir dosyaya erişim süresi sıkıntıya girebilir. Bir veya iki gibi çok az dosyanız varsa aynı anda birden fazla dosyadan dosya akışı gerçekleştirmenin avantajlarından yararlanamazsınız.

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 şunları yazarak TFRecord dosyalarından doğrudan 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 aşağıdaki daha karmaşık kodu kullanarak birden çok TFRecord dosyasını aynı anda okumanız önerilir. Bu kod paralel olarak N dosyadan okur ve veri sırasını dikkate alarak okuma hızını dikkate alır.

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 hakkında yardımcı kısa bilgiler

TFRecord'larda üç tür veri depolanabilir: bayt dizeleri (bayt listesi), 64 bit tamsayılar ve 32 bit kayan değerler. Her zaman liste olarak depolanırlar. Tek bir veri öğesi, 1 boyutunda bir liste olur. Verileri TFRecord'larda 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))

kayan metinler yazma

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

TFRecord'lardaki verileri okumak için öncelikle depoladığınız kayıtların düzenini beyan etmeniz 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)

Yararlı 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 bir seyrek vektör döndürür ve TFRecord kodunun çözülmesinden 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ı yardımcı kısa bilgiler olarak yer işaretlerine ekleyin)
• 🤔 TFRecordDataset kullanarak TFRecords'tan veri kümesi yükleme

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

6. Tebrikler!

Artık veri içeren bir TPU besleyebilirsiniz. Lütfen sonraki laboratuvara geçin

• [THIS LAB] TPU hızında veri ardışık düzenleri: tf.data.Dataset ve TFRecords
• Aktarımla öğrenme özellikli ilk Keras modeliniz
• Keras ve TPU'larla kıvrımlı nöral ağlar
• Modern dönş., squeezenet, Xception, Keras ve TPU'lar

Uygulamada TPU'lar

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

• Derin Öğrenme Sanal Makinelerinde
• AI Platform Notebooks'ta
• AI Platform Training alanındaki iş ilanları

Son olarak, geri bildirimlere değer veriyoruz. Bu laboratuvarda bir eksiklik görürseniz veya bir şeylerin iyileştirilmesi gerektiğini düşünüyorsanız lütfen bize bildirin. Geri bildirimlerinizi, GitHub sorunları [feedback link] sayfasında bulabilirsiniz.

Yazar: Martin Görner Twitter: @martin_gorner