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ızına ayak uydurmalıdır. Bu laboratuvarda, TPU'nuzu beslemek için tf.data.Dataset API ile GCS'den nasıl veri yükleneceğini öğ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.

[BU LABORATUVAR] TPU hızında veri ardışık düzenleri: tf.data.Dataset ve TFRecords
Transfer öğrenme ile ilk Keras modeliniz
Keras ve TPU'lar ile evrişimli nöral ağlar
Keras ve TPU'larla modern evrişimli ağlar, SqueezeNet, Xception

Neler öğreneceksiniz?

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

Geri bildirim

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

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

Bu laboratuvarda Google Collaboratory kullanılır ve sizin tarafınızda herhangi bir kurulum yapılması gerekmez. Colaboratory, eğitim amaçlı kullanılan online bir not defteri platformudur. Ücretsiz CPU, GPU ve TPU eğitimi sunar.

Colaboratory'ye alışmak için bu örnek not defterini açıp birkaç hücreyi çalıştırabilirsiniz.

Welcome to Colab.ipynb

TPU arka ucu seçme

Colab menüsünde Çalışma zamanı > Çalışma zamanı türünü değiştir'i 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 (Tensor İşleme Birimi) kullanacaksınız. Çalışma zamanına bağlantı ilk yürütmede otomatik olarak gerçekleşir veya sağ üst köşedeki "Bağlan" düğmesini kullanabilirsiniz.

Not defteri yürütme

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

İçindekiler

Tüm not defterlerinde içindekiler tablosu bulunur. Sol taraftaki siyah oku kullanarak açabilirsiniz.

Gizli hücreler

Bazı hücrelerde yalnızca başlık gösterilir. Bu, Colab'e özgü bir not defteri özelliğidir. İçindeki kodu görmek için bunları çift tıklayabilirsiniz ancak genellikle çok ilginç değildir. Genellikle destek veya görselleştirme işlevleri. İçerideki işlevlerin tanımlanması için bu hücreleri yine de çalıştırmanız gerekir.

Kimlik doğrulama

Colab, yetkili bir hesapla kimliğinizi doğruladığınız sürece özel Google Cloud Storage paketlerinize erişebilir. Yukarıdaki kod snippet'i bir kimlik doğrulama sürecini tetikleyecektir.

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

Özet

Keras'ta TPU üzerinde model eğitme (TPU yoksa GPU veya CPU'ya geri dönme) 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 dakikalar) bir çiçek sınıflandırıcı oluşturmak ve optimize etmek için TPU'ları kullanacağız.

Neden TPU'lar?

Modern GPU'lar, programlanabilir "çekirdekler" etrafında düzenlenir. Bu çekirdekler, 3D oluşturma, derin öğrenme ve fiziksel simülasyon gibi çeşitli görevleri yerine getirmelerini sağlayan çok esnek bir mimaridir. TPU'lar ise klasik bir vektör işlemcisini özel bir matris çarpma birimiyle eşleştirir ve büyük matris çarpımlarının baskın olduğu tüm görevlerde (ör. sinir ağları) üstün performans gösterir.

Resim: Bir matris çarpımı olarak yoğun bir nöral ağ katmanı. Nöral ağda aynı anda işlenen sekiz görüntülük bir toplu işlem. Bir resmin tüm piksel değerlerinin ağırlıklı toplamını gerçekten yaptığını doğrulamak için lütfen bir satır x sütun çarpımı yapın. Evrişimli katmanlar, biraz daha karmaşık olsa da matris çarpımları olarak da gösterilebilir ( 1. bölümdeki açıklama).

Donanım

MXU ve VPU

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

Karma kesinlikli kayan nokta ve bfloat16

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

Nöral ağ eğitimi genellikle azaltılmış kayan nokta duyarlılığının neden olduğu gürültüye karşı dirençlidir. Gürültünün, optimize edicinin yakınlaşmasına yardımcı olduğu durumlar da vardır. Hesaplamaları hızlandırmak için geleneksel olarak 16 bit kayan nokta duyarlılığı kullanılmıştır ancak float16 ve float32 biçimlerinin aralıkları çok farklıdır. Hassasiyeti float32'den float16'ya düşürmek genellikle taşma ve eksik akışa neden olur. Çözümler mevcuttur ancak genellikle float16'nın çalışması için ek çalışma gerekir.

Bu nedenle Google, TPU'larda bfloat16 biçimini kullanıma sundu. bfloat16, float32 ile tam olarak aynı üs bitlerine ve aralığa sahip, kısaltılmış bir float32'dir. Bu durum, TPU'ların bfloat16 girişleri ve float32 çıkışlarıyla karma duyarlılıkta matris çarpımlarını hesaplamasıyla birleştiğinde, genellikle duyarlılığın azaltılmasının performans kazançlarından yararlanmak için kodda değişiklik yapılması gerekmediği anlamına gelir.

Sistolik dizi

MXU, veri öğelerinin bir donanım hesaplama birimleri dizisinden aktığı "sistolik dizi" adı verilen bir mimari kullanarak donanımda matris çarpımlarını uygular. (Tıpta "sistolik", kalp kasılmaları ve kan akışı anlamına gelir. Burada ise veri akışı anlamında kullanılmıştır.)

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 resmi inceleyin). 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]

Bir GPU'da bu nokta çarpımı bir GPU "çekirdeğine" programlanır ve ardından sonuç matrisinin her değerini aynı anda hesaplamak için paralel olarak mümkün olduğunca çok "çekirdekte" yürütülür. Ortaya çıkan matris 128x128 boyutunda olursa 128x128=16 bin "çekirdek" gerekir. Bu da genellikle mümkün değildir. En büyük GPU'larda yaklaşık 4.000 çekirdek bulunur. Öte yandan bir TPU, MXU'daki işlem birimleri için en az donanımı kullanır: yalnızca bfloat16 x bfloat16 => float32 çarpma-toplama birimi. Bu birimler o kadar küçüktür ki bir TPU, 128x128 MXU'da 16.000 birim uygulayabilir ve bu matris çarpımını tek seferde işleyebilir.

Resim: MXU sistolik dizisi. İşlem öğeleri, çoklu biriktiricilerdir. Bir matrisin değerleri diziye yüklenir (kırmızı noktalar). Diğer matrisin değerleri diziden akar (gri noktalar). Dikey çizgiler, değerleri yukarı doğru yayar. Yatay çizgiler, kısmi toplamları yayar. Veriler diziden geçerken sağ tarafta matris çarpımı sonucunu aldığınızı doğrulama işlemi kullanıcıya bırakılmıştır.

Buna ek olarak, skaler çarpımlar bir MXU'da hesaplanırken ara toplamlar bitişik işlem birimleri arasında akar. Bu değerlerin bellekte veya bir kayıt dosyasında saklanması ve alınması gerekmez. Sonuç olarak, TPU sistolik dizi mimarisi, matris çarpımları hesaplanırken GPU'ya kıyasla önemli bir yoğunluk ve güç avantajının yanı sıra göz ardı edilemeyecek bir hız avantajına sahiptir.

Cloud TPU

Google Cloud Platform'da bir "Cloud TPU v2" istediğinizde, PCI'ye bağlı bir TPU kartı olan bir sanal makine (VM) 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 (MatriX Çarpma Birimi) bulunur. Bu "Cloud TPU" daha sonra genellikle ağ üzerinden bunu isteyen sanal makineye bağlanır. Dolayısıyla, resmin tamamı şu şekilde görünür:

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

TPU pod'ları

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

Resim: TPU v3 kapsülü. HPC ara bağlantısı üzerinden bağlanmış TPU kartları ve rafları.

Eğitim sırasında, tümünü azaltma algoritması kullanılarak TPU çekirdekleri arasında gradyanlar değiştirilir ( Tümünü azaltma algoritmasıyla ilgili iyi bir açıklama için burayı tıklayın). Eğitilen model, büyük toplu iş boyutlarında eğitim yaparak donanımdan yararlanabilir.

Resim: Google TPU'nun 2 boyutlu toroidal örgü HPC ağında all-reduce algoritması kullanılarak eğitim sırasında gradyanların senkronizasyonu.

Yazılım

Büyük grup boyutu eğitimi

TPU'lar için ideal grup boyutu, TPU çekirdeği başına 128 veri öğesidir ancak donanım, TPU çekirdeği başına 8 veri öğesiyle de iyi bir kullanım gösterebilir. Bir Cloud TPU'nun 8 çekirdeği 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ünür ve TPU'nun 8 çekirdeğinde çalıştırılır.

Ek performans ipuçları için TPU Performans Kılavuzu'na bakın. Çok büyük toplu boyutlar için bazı modellerde özel dikkat gerekebilir. Daha fazla bilgi için LARSOptimizer'a bakın.

Perde arkası: 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. Arka planda, XLA (Hızlandırılmış Doğrusal Cebir derleyicisi) adlı bir derleyici, hesaplama düğümlerinin TensorFlow grafiğini TPU makine diline dönüştürür. Bu derleyici, kodunuzda ve bellek düzeninizde birçok gelişmiş optimizasyon da gerçekleştirir. Derleme, iş TPU'ya gönderilirken otomatik olarak gerçekleşir. XLA'yı derleme zincirinize açıkça dahil etmeniz gerekmez.

Resim: Tensorflow programınız tarafından tanımlanan hesaplama grafiğinin TPU'da çalıştırılması için önce XLA (hızlandırılmış doğrusal cebir derleyicisi) gösterimine çevrilir, ardından XLA tarafından TPU makine koduna derlenir.

Keras'ta TPU'ları kullanma

Tensorflow 2.1'den itibaren TPU'lar Keras API üzerinden desteklenir. Keras desteği, TPU'larda ve TPU kapsüllerinde çalışır. TPU, GPU ve CPU'da çalışan bir örneği aşağıda bulabilirsiniz:

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ı aracılığıyla oluşturulan Deep Learning VM'leri) 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 işlevini açık parametrelerle çağırın: TPUClusterResolver(tp_uname, zone, project)
TPUStrategy, dağıtımı ve "all-reduce" 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.

Sık kullanılan TPU taşıma görevleri

TensorFlow modeline veri yüklemenin birçok yolu olsa da TPU'larda tf.data.Dataset API'sinin kullanılması gerekir.
TPU'lar çok hızlıdır ve bunlar üzerinde çalışırken veri alımı genellikle darboğaz haline gelir. TPU Performans Kılavuzu'nda, veri darboğazlarını tespit etmek için kullanabileceğiniz araçlar ve diğer performans ipuçları yer almaktadır.
int8 veya int16 sayıları int32 olarak değerlendirilir. TPU, 32 bit'ten daha az bit üzerinde çalışan tam sayı donanımına sahip değildir.
Bazı TensorFlow işlemleri desteklenmez. Listeyi burada bulabilirsiniz. Bu sınırlamanın yalnızca eğitim kodu (yani modelinizdeki ileri ve geri geçiş) için geçerli olduğunu belirtmek isteriz. CPU'da yürütüleceği için veri girişi ardışık düzeninizde tüm TensorFlow işlemlerini kullanmaya devam edebilirsiniz.
tf.py_func, TPU'da desteklenmez.

4. Veriler yükleniyor

Çiçek resimlerinden oluşan bir veri kümesiyle çalışacağız. Amaç, bu çiçekleri 5 çiçek türüne göre sınıflandırmayı öğrenmektir. 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 çalıştırın (Shift-ENTER) ve "ÇALIŞMA GEREKLİ" etiketini gördüğünüz her yerde talimatları uygulayın.

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

Ek bilgiler

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

Veri kümesi 5 klasör halinde düzenlenir. Her klasörde tek bir türden çiçekler bulunur. Klasörler ayçiçeği, papatya, karahindiba, lale ve gül olarak adlandırılıyor. Veriler, Google Cloud Storage'daki 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, sinir ağı eğitim verileri için yararlı olan 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

Performans ipuçlarını ve veri kümesiyle ilgili en iyi uygulamaları bu makalede bulabilirsiniz. Referans belgelerini burada bulabilirsiniz.

tf.data.Dataset basics

Veriler genellikle birden fazla dosya halinde gelir. Burada resimler gösterilmektedir. Aşağıdaki işlevi ç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.

Ardından, her dosya adına bir işlev "eşlersiniz". Bu işlev genellikle dosyayı yükleyip 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)

Veri kümesi üzerinde yineleme yapmak için:

for data in my_dataset:
  print(data)

Demet veri kümeleri

Denetimli öğrenmede, eğitim veri kümesi genellikle eğitim verileri ve doğru yanıtlardan oluşan çiftlerden oluşur. Buna izin vermek için kod çözme işlevi demetler döndürebilir. Daha sonra, demetlerden oluşan bir veri kümeniz olur ve bu veri kümesi üzerinde yineleme yaptığınızda demetler döndürülür. Döndürülen değerler, modeliniz tarafından kullanılmaya hazır Tensorflow tensörleridir. Ham değerleri görmek için .numpy() işlevini kullanabilirsiniz:

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ç:Görüntüleri tek tek yüklemek yavaştır.

Bu veri kümesini yinelediğinizde saniyede 1-2 resim yükleyebildiğinizi görürsünüz. Bu çok yavaş! Eğitim için kullanacağımız donanım hızlandırıcılar bu oranın kat kat üstünde bir hıza dayanabilir. Bunu nasıl yapacağımızı görmek için sonraki bölüme geçin.

Çözüm

Çözüm not defterini burada bulabilirsiniz. Takılırsanız bu özelliği kullanabilirsiniz.

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

İşlediğimiz konular

🤔 tf.data.Dataset.list_files
🤔 tf.data.Dataset.map
🤔 Demet veri kümeleri
😀 Veri kümelerinde yineleme

Lütfen bu kontrol listesini zihninizde gözden geçirin.

5. Verileri hızlı yükleme

Bu laboratuvarda kullanacağımız Tensor İşleme Birimi (TPU) donanım hızlandırıcıları çok hızlıdır. Genellikle bu modelleri meşgul edecek kadar hızlı veri sağlamak zorlu bir görevdir. Google Cloud Storage (GCS), çok yüksek gönderim hacmini destekleyebilir ancak tüm bulut depolama sistemlerinde olduğu gibi bağlantı başlatmak için ağda gidiş geliş gerekir. Bu nedenle, verilerimizin binlerce ayrı dosya olarak saklanması ideal değildir. Bu dosyaları daha az sayıda dosyada gruplandıracağız ve tf.data.Dataset'in gücünü kullanarak birden fazla dosyayı paralel olarak okuyacağız.

Read-through

Resim dosyalarını yükleyen, bunları ortak bir boyuta yeniden boyutlandıran ve ardından 16 TFRecord dosyasına depolayan kod aşağıdaki not defterinde yer almaktadır. Lütfen hızlıca okuyun. TFRecord biçiminde düzgün şekilde biçimlendirilmiş veriler, codelab'in geri kalanı için sağlanacağından bu işlemi yürütmek gerekli değildir.

Flower pictures to TFRecords.ipynb

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

TFRecord dosya biçimi

Tensorflow'un veri depolamak için tercih ettiği dosya biçimi, protobuf tabanlı TFRecord biçimidir. Diğer serileştirme biçimleri de kullanılabilir ancak aşağıdaki kodu yazarak doğrudan TFRecord dosyalarından bir 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 aynı anda birden fazla TFRecord dosyasından okumak üzere aşağıdaki daha karmaşık kodu kullanmanız önerilir. Bu kod, N dosyayı paralel olarak 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 yardımcı kısa bilgileri

TFRecord'larda üç tür veri depolanabilir: bayt dizeleri (bayt listesi), 64 bit tam sayılar ve 32 bit kayan nokta sayıları. Bunlar her zaman liste olarak depolanır. Tek bir veri öğesi, boyutu 1 olan bir liste olur. Verileri TFRecord'lara 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ı kaydırma

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 TFRecord yazma

# 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'lardan veri okumak için öncelikle depoladığınız kayıtların düzenini bildirmeniz gerekir. Bildirimde, adlandırılmış alanlara sabit uzunluklu liste veya değişken uzunluklu liste olarak erişebilirsiniz:

TFRecord'lardan 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

öğelerin sabit boyutlu 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 öğesi 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 kodu çözüldükten sonra ek bir adım gerekir:

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

TFRecord'larda isteğe bağlı alanlar da olabilir. Bir alanı okurken varsayılan 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

İşlediğimiz konular

🤔 GCS'den hızlı erişim için veri dosyalarını parçalama
😓 TFRecord'ları yazma (Söz dizimini unuttunuz mu? (Sorun değil, bu sayfayı kopya kağıdı olarak işaretleyin)
🤔 TFRecordDataset kullanarak TFRecord'lardan bir veri kümesi yükleme

Lütfen bu kontrol listesini zihninizde gözden geçirin.

6. Tebrikler!

Artık TPU'ya veri sağlayabilirsiniz. Lütfen bir sonraki laboratuvara geçin.

[BU LABORATUVAR] TPU hızında veri ardışık düzenleri: tf.data.Dataset ve TFRecords
Transfer öğrenme ile ilk Keras modeliniz
Keras ve TPU'lar ile evrişimli nöral ağlar
Keras ve TPU'larla modern evrişimli ağlar, SqueezeNet, Xception

TPU'ların uygulamadaki yeri

TPU'lar ve GPU'lar Cloud AI Platform'da kullanılabilir:

Son olarak, geri bildirimlerinizi öğrenmekten memnuniyet duyarız. Bu laboratuvarda yanlış bir şey görürseniz veya iyileştirilmesi gerektiğini düşünürseniz lütfen bize bildirin. Geri bildirimler GitHub sorunları [geri bildirim bağlantısı] üzerinden gönderilebilir.

Martin Görner ID small.jpg
Yazar: Martin Görner
Twitter: @martin_gorner