Pipeline data berkecepatan TPU: tf.data.Dataset dan TFRecords

1. Ringkasan

TPU sangat cepat. Aliran data pelatihan harus dapat mengimbangi kecepatan pelatihan mereka. Di lab ini, Anda akan mempelajari cara memuat data dari GCS dengan tf.data.Dataset API untuk melakukan feed pada TPU Anda.

Lab ini adalah Bagian 1 dari seri "Keras di TPU". Anda dapat melakukannya dalam urutan berikut atau secara terpisah.

• [LAB INI] Pipeline data berkecepatan TPU: tf.data.Dataset dan TFRecords
• Model Keras pertama Anda, dengan pemelajaran transfer
• Jaringan neural konvolusional, dengan Keras dan TPU
• ConvNets, SqueezeNet, Xception modern, dengan Keras dan TPU

Yang akan Anda pelajari

• Untuk menggunakan tf.data.Dataset API guna memuat data pelatihan
• Untuk menggunakan format TFRecord guna memuat data pelatihan secara efisien dari GCS

Masukan

Jika Anda melihat sesuatu yang salah dalam codelab ini, beri tahu kami. Masukan dapat diberikan melalui masalah GitHub [ link masukan].

2. Memulai cepat Google Colaboratory

Lab ini menggunakan Google Colaboratory dan tidak memerlukan penyiapan di pihak Anda. Colaboratory adalah platform notebook online untuk tujuan pendidikan. Program ini menawarkan pelatihan CPU, GPU, dan TPU gratis.

Anda dapat membuka notebook contoh ini dan menjalankan beberapa sel untuk membiasakan diri dengan Colaboratory.

Welcome to Colab.ipynb

Memilih backend TPU

Di menu Colab, pilih Runtime > Ubah jenis runtime, lalu pilih TPU. Di codelab ini, Anda akan menggunakan TPU (Tensor Processing Unit) canggih yang didukung untuk pelatihan akselerasi hardware. Koneksi ke runtime akan terjadi secara otomatis pada eksekusi pertama, atau Anda dapat menggunakan tombol "Connect" di pojok kanan atas.

Eksekusi notebook

Jalankan sel satu per satu dengan mengklik sel dan menggunakan Shift-ENTER. Anda juga dapat menjalankan seluruh notebook dengan Runtime > Run all

Daftar isi

Semua notebook memiliki daftar isi. Anda dapat membukanya menggunakan panah hitam di sebelah kiri.

Sel tersembunyi

Beberapa sel hanya akan menampilkan judulnya. Ini adalah fitur notebook khusus Colab. Anda dapat mengklik dua kali untuk melihat kode di dalamnya, tetapi biasanya tidak terlalu menarik. Biasanya mendukung atau fungsi visualisasi. Anda masih perlu menjalankan sel ini agar fungsi di dalamnya dapat ditentukan.

Autentikasi

Colab dapat mengakses bucket Google Cloud Storage pribadi Anda, asalkan Anda melakukan autentikasi dengan akun yang diotorisasi. Cuplikan kode di atas akan memicu proses autentikasi.

3. [INFO] Apa itu Tensor Processing Unit (TPU)?

Singkatnya

TPU adalah akselerator hardware yang dikhususkan untuk tugas deep learning. Di codelab ini, Anda akan melihat cara menggunakannya dengan Keras dan Tensorflow 2. Cloud TPU tersedia dalam konfigurasi dasar dengan 8 core dan juga dalam konfigurasi lebih besar yang disebut "pod TPU" dengan hingga 2048 core. Hardware tambahan dapat digunakan untuk mempercepat pelatihan dengan meningkatkan ukuran batch pelatihan.

Kode untuk melatih model di TPU di Keras (dan kembali ke GPU atau CPU jika TPU tidak tersedia):

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

Hari ini kita akan menggunakan TPU untuk membuat dan mengoptimalkan pengklasifikasi bunga dengan kecepatan interaktif (menit per pelatihan yang dijalankan).

Mengapa TPU?

GPU modern diatur berdasarkan "core" yang dapat diprogram, yaitu arsitektur yang sangat fleksibel yang memungkinkannya menangani berbagai tugas seperti rendering 3D, deep learning, simulasi fisik, dll. Di sisi lain, TPU memasangkan prosesor vektor klasik dengan unit perkalian matriks khusus dan unggul dalam tugas apa pun yang didominasi perkalian matriks besar, seperti jaringan saraf.

Ilustrasi: lapisan jaringan saraf yang padat sebagai perkalian matriks, dengan batch delapan gambar yang diproses melalui jaringan saraf sekaligus. Jalankan perkalian kolom x satu baris x untuk memverifikasi bahwa perintah tersebut benar-benar menjumlahkan semua nilai piksel sebuah gambar. Lapisan konvolusi juga dapat direpresentasikan sebagai perkalian matriks meskipun sedikit lebih rumit ( penjelasan di sini, di bagian 1).

Hardware

MXU dan VPU

Inti TPU v2 terbuat dari Matrix Multiply Unit (MXU) yang menjalankan perkalian matriks dan Vector Processing Unit (VPU) untuk semua tugas lain seperti aktivasi, softmax, dll. VPU menangani komputasi float32 dan int32. Di sisi lain, MXU beroperasi dalam format floating point presisi campuran 16-32 bit.

Floating point presisi campuran dan bfloat16

MXU menghitung perkalian matriks menggunakan input bfloat16 dan output float32. Akumulasi perantara dilakukan dalam presisi float32.

Pelatihan jaringan neural biasanya tahan terhadap noise yang dihasilkan oleh presisi floating point yang lebih rendah. Ada kalanya derau bahkan membantu pengoptimal melakukan konvergensi. Presisi floating point 16-bit secara tradisional telah digunakan untuk mempercepat komputasi tetapi format float16 dan float32 memiliki rentang yang sangat berbeda. Mengurangi presisi dari float32 ke float16 biasanya menghasilkan aliran berlebih dan kurang. Solusi ada, tetapi biasanya diperlukan pekerjaan tambahan agar float16 berfungsi.

Itulah mengapa Google memperkenalkan format bfloat16 di TPU. bfloat16 adalah float32 yang terpotong dengan bit dan rentang eksponen yang sama persis dengan float32. Hal ini, ditambah dengan fakta bahwa TPU menghitung perkalian matriks dalam presisi campuran dengan input bfloat16, tetapi output float32, berarti bahwa biasanya tidak diperlukan perubahan kode untuk mendapatkan manfaat dari peningkatan performa presisi yang dikurangi.

Penggunaan presisi campuran bfloat16/float32 adalah default di TPU. Tidak diperlukan perubahan kode di kode Tensorflow Anda untuk mengaktifkannya. Anda masih bekerja dengan float32 di seluruh kode Anda. Saat menjalankan perkalian matriks, TPU akan otomatis memotong inputnya menjadi bfloat16. Matriks yang dihasilkan adalah float32.

Array sistolik

MXU mengimplementasikan perkalian matriks dalam hardware menggunakan apa yang disebut arsitektur "array sistolik" di mana elemen data mengalir melalui array unit komputasi hardware. (Dalam kedokteran, "sistolik" mengacu pada kontraksi jantung dan aliran darah, di sini adalah aliran data.)

Elemen dasar perkalian matriks adalah perkalian titik antara garis dari satu matriks dan kolom dari matriks lain (lihat ilustrasi di bagian atas bagian ini). Untuk perkalian matriks Y=X*W, satu elemen hasilnya adalah:

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]

Di GPU, seseorang akan memprogram perkalian titik ini ke dalam "core" GPU, lalu menjalankannya di sebanyak mungkin "core" yang tersedia secara paralel untuk mencoba dan menghitung setiap nilai matriks yang dihasilkan sekaligus. Jika matriks yang dihasilkan berukuran 128x128, diperlukan 128x128=16K "core" yang biasanya tidak tersedia. GPU terbesar memiliki sekitar 4.000 core. Di sisi lain, TPU menggunakan hardware minimum untuk unit komputasi di MXU: hanya multi-akumulator bfloat16 x bfloat16 => float32, tidak ada yang lain. Ini sangat kecil sehingga TPU dapat mengimplementasikan 16K di antaranya dalam MXU 128x128 dan memproses perkalian matriks ini dalam satu langkah.

Ilustrasi: array sistolik MXU. Elemen komputasi adalah pengganda akumulator. Nilai satu matriks dimuat ke dalam array (titik merah). Nilai matriks lain mengalir melalui array (titik abu-abu). Garis vertikal menyebarkan nilai ke atas. Garis horizontal menyebarkan jumlah parsial. Anda dapat mempraktikkan sendiri untuk memverifikasi bahwa saat data mengalir melalui array, Anda akan mendapatkan hasil perkalian matriks yang keluar dari sisi kanan.

Selain itu, saat perkalian titik dihitung di MXU, jumlah perantara hanya mengalir di antara unit komputasi yang berdekatan. Mereka tidak perlu disimpan dan diambil ke/dari memori atau bahkan file register. Hasil akhirnya adalah arsitektur array sistolik TPU memiliki kepadatan dan keunggulan daya yang signifikan, serta keunggulan kecepatan yang tidak dapat diabaikan dibandingkan GPU, saat menghitung perkalian matriks.

Cloud TPU

Saat meminta satu "Cloud TPU v2" di Google Cloud Platform, Anda akan mendapatkan virtual machine (VM) yang memiliki board TPU yang terpasang pada PCI. Papan TPU memiliki empat chip TPU dual-core. Setiap core TPU memiliki VPU (Vector Processing Unit) dan MXU 128x128 (MatriX multiply Unit). "Cloud TPU" ini biasanya terhubung melalui jaringan ke VM yang memintanya. Jadi gambaran lengkapnya terlihat seperti ini:

Ilustrasi: VM Anda dengan akselerator "Cloud TPU" yang terhubung ke jaringan. "Cloud TPU" itu sendiri terbuat dari VM dengan papan TPU yang terpasang PCI dengan empat chip TPU dual-core di dalamnya.

Pod TPU

Di pusat data Google, TPU terhubung ke interkoneksi komputasi berperforma tinggi (HPC) yang dapat membuatnya muncul sebagai satu akselerator yang sangat besar. Google menyebutnya pod dan dapat mencakup hingga 512 core TPU v2 atau 2048 TPU v3 core.

Ilustrasi: pod TPU v3. Papan dan rak TPU yang terhubung melalui interkoneksi HPC.

Selama pelatihan, gradien dipertukarkan antara inti TPU menggunakan algoritma semua pengurangan ( penjelasan yang baik tentang semua pengurangan di sini). Model yang dilatih bisa memanfaatkan hardware dengan dilatih pada ukuran tumpukan yang besar.

Ilustrasi: sinkronisasi gradien selama pelatihan menggunakan algoritma all-reduce di jaringan HPC mesh toroidal 2-D Google TPU.

Software

Pelatihan ukuran batch besar

Ukuran batch yang ideal untuk TPU adalah 128 item data per inti TPU, tetapi hardware sudah dapat menunjukkan pemanfaatan yang baik dari 8 item data per inti TPU. Perlu diingat bahwa satu Cloud TPU memiliki 8 core.

Dalam codelab ini, kita akan menggunakan Keras API. Di Keras, batch yang Anda tentukan adalah ukuran batch global untuk seluruh TPU. Batch Anda akan otomatis dibagi menjadi 8 dan dijalankan di 8 core TPU.

Untuk tips performa tambahan, lihat Panduan Performa TPU. Untuk ukuran tumpukan yang sangat besar, perlakuan khusus pada beberapa model mungkin diperlukan. Lihat LARSOptimizer untuk mengetahui detail selengkapnya.

Di balik layar: XLA

Program TensorFlow menentukan grafik komputasi. TPU tidak langsung menjalankan kode Python, tetapi menjalankan grafik komputasi yang ditentukan oleh program Tensorflow Anda. Di balik layar, compiler bernama XLA (Accelerated Linear Algebra compiler) mengubah grafik Tensorflow dari node komputasi menjadi kode mesin TPU. Compiler ini juga melakukan banyak pengoptimalan lanjutan pada kode dan tata letak memori Anda. Kompilasi terjadi secara otomatis saat tugas dikirim ke TPU. Anda tidak harus menyertakan XLA dalam rantai build secara eksplisit.

Ilustrasi: untuk dijalankan di TPU, grafik komputasi yang ditentukan oleh program Tensorflow Anda pertama-tama diterjemahkan ke representasi XLA (compiler Linear Algebra yang dipercepat), lalu dikompilasi oleh XLA menjadi kode mesin TPU.

Menggunakan TPU di Keras

TPU didukung melalui Keras API mulai Tensorflow 2.1. Dukungan Keras berfungsi di TPU dan pod TPU. Berikut adalah contoh yang berfungsi di TPU, GPU, dan CPU:

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

Dalam cuplikan kode ini:

• TPUClusterResolver().connect() akan menemukan TPU di jaringan. Alat ini berfungsi tanpa parameter di sebagian besar sistem Google Cloud (tugas AI Platform, Colaboratory, Kubeflow, VM Deep Learning yang dibuat melalui utilitas 'ctpu up'). Sistem ini dapat mengetahui lokasi TPU mereka berkat variabel lingkungan TPU_NAME. Jika Anda membuat TPU secara manual, tetapkan variabel lingkungan TPU_NAME di VM tempat Anda menggunakannya, atau panggil TPUClusterResolver dengan parameter eksplisit: TPUClusterResolver(tp_uname, zone, project)
• TPUStrategy adalah bagian yang mengimplementasikan distribusi dan algoritma sinkronisasi gradien "all-reduce".
• Strategi diterapkan melalui cakupan. Model harus ditentukan dalam strategi scope().
• Fungsi tpu_model.fit mengharapkan objek tf.data.Dataset untuk input untuk pelatihan TPU.

Tugas porting TPU umum

• Meskipun ada banyak cara untuk memuat data dalam model Tensorflow, untuk TPU, penggunaan tf.data.Dataset API diperlukan.
• TPU sangat cepat dan menyerap data sering kali menjadi bottleneck saat berjalan di TPU. Terdapat alat yang dapat Anda gunakan untuk mendeteksi bottleneck data dan tips performa lainnya di Panduan Performa TPU.
• Angka int8 atau int16 diperlakukan sebagai int32. TPU tidak memiliki hardware bilangan bulat yang beroperasi kurang dari 32 bit.
• Beberapa operasi Tensorflow tidak didukung. Daftarnya ada di sini. Kabar baiknya adalah batasan ini hanya berlaku untuk kode pelatihan, yaitu penerusan maju dan mundur melalui model Anda. Anda tetap dapat menggunakan semua operasi Tensorflow di pipeline input data karena akan dieksekusi di CPU.
• tf.py_func tidak didukung di TPU.

4. Memuat Data

Kita akan bekerja dengan {i>dataset<i} gambar bunga. Tujuannya adalah belajar mengkategorikannya ke dalam 5 jenis bunga. Pemuatan data dilakukan menggunakan tf.data.Dataset API. Pertama-tama, beri tahu kami API-nya.

Langsung

Buka notebook berikut, jalankan sel (Shift-ENTER), dan ikuti petunjuk di mana pun Anda melihat label "KERJA DIPERLUKAN".

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

Informasi tambahan

Tentang set data "flowers"

{i>Dataset<i} disusun dalam 5 folder. Setiap folder berisi bunga dari satu jenis. Folder tersebut diberi nama bunga matahari, daisy, dandelion, tulip, dan mawar. Data dihosting di bucket publik di Google Cloud Storage. Cuplikan:

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

Mengapa tf.data.Dataset?

Keras dan Tensorflow menerima Set Data di semua fungsi pelatihan dan evaluasinya. Setelah Anda memuat data di Set Data, API tersebut menawarkan semua fungsi umum yang berguna untuk data pelatihan jaringan neural:

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

Anda dapat menemukan tips performa dan praktik terbaik Set Data di artikel ini. Dokumentasi referensinya ada di sini.

Dasar-dasar tf.data.Dataset

Data biasanya terdiri dari beberapa file, di sini gambar. Anda dapat membuat set data nama file dengan memanggil:

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

Kemudian, Anda "memetakan" fungsi ke setiap nama file yang biasanya akan memuat dan mendekode file menjadi data sebenarnya dalam memori:

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)

Untuk melakukan iterasi pada Set data:

for data in my_dataset:
  print(data)

Set data tuple

Dalam pembelajaran dengan pengawasan, set data pelatihan biasanya terdiri dari pasangan data pelatihan dan jawaban yang benar. Untuk mengizinkannya, fungsi decoding dapat menampilkan tuple. Selanjutnya, Anda akan memiliki set data tuple dan tuple akan ditampilkan saat Anda melakukan iterasi. Nilai yang ditampilkan adalah tensor TensorFlow yang siap digunakan oleh model Anda. Anda dapat memanggil .numpy() untuk melihat nilai mentah:

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

Kesimpulan:memuat gambar satu per satu sangatlah lambat.

Saat melakukan iterasi pada set data ini, Anda akan melihat bahwa Anda dapat memuat sekitar 1-2 gambar per detik. Terlalu lambat. Akselerator hardware yang akan kita gunakan untuk pelatihan dapat mempertahankan kecepatan ini berkali-kali lipat. Buka bagian berikutnya untuk melihat cara melakukannya.

Solusi

Berikut notebook solusinya. Anda dapat menggunakannya jika mengalami masalah.

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

Yang telah kita bahas

• 🤔 tf.data.Dataset.list_files
• 🤔 tf.data.Dataset.map
• 🤔 Set data tuple
• 😀 melakukan iterasi melalui {i>Dataset<i}

Luangkan waktu sejenak untuk membaca {i>checklist<i} ini di kepala Anda.

5. Memuat data dengan cepat

Akselerator hardware Tensor Processing Unit (TPU) yang akan kita gunakan di lab ini sangat cepat. Tantangannya adalah memberi mereka data dengan cukup cepat agar mereka tetap sibuk. Google Cloud Storage (GCS) mampu mempertahankan throughput yang sangat tinggi. Namun, seperti halnya semua sistem penyimpanan cloud, memulai koneksi akan menimbulkan biaya beberapa jaringan bolak-balik. Oleh karena itu, menyimpan data sebagai ribuan file terpisah bukanlah hal yang ideal. Kita akan mengelompokkannya dalam jumlah file yang lebih kecil dan menggunakan kecanggihan tf.data.Dataset untuk membaca dari beberapa file secara paralel.

Baca-tayang

Kode yang memuat file gambar, mengubah ukurannya menjadi ukuran umum, lalu menyimpannya di 16 file TFRecord ada di notebook berikut. Harap baca dengan cepat. Anda tidak perlu menjalankannya karena data berformat TFRecord yang benar akan disediakan untuk sisa codelab.

Flower pictures to TFRecords.ipynb

Tata letak data yang ideal untuk throughput GCS yang optimal

Aturan praktisnya adalah membagi data Anda menjadi beberapa (10-an hingga 100-an) file besar (10-an hingga 100-an MB). Jika Anda memiliki terlalu banyak file, misalnya ribuan file, waktu untuk mengakses setiap file mungkin mulai mengganggu. Jika memiliki terlalu sedikit file, seperti satu atau dua, Anda tidak akan mendapatkan manfaat melakukan streaming dari beberapa file secara paralel.

Format file TFRecord

Format file pilihan Tensorflow untuk menyimpan data adalah format TFRecord berbasis protobuf. Format serialisasi lainnya juga akan berfungsi, tetapi Anda dapat memuat set data dari file TFRecord secara langsung dengan menulis:

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

Untuk performa yang optimal, sebaiknya gunakan kode yang lebih kompleks berikut untuk membaca dari beberapa file TFRecord sekaligus. Kode ini akan membaca dari file N secara paralel dan mengabaikan urutan data demi kecepatan pembacaan.

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

Tips praktis TFRecord

Tiga jenis data dapat disimpan dalam TFRecords: string byte (daftar byte), integer 64 bit, dan float 32 bit. Elemen data selalu disimpan sebagai daftar, satu elemen data akan menjadi daftar berukuran 1. Anda dapat menggunakan fungsi bantuan berikut untuk menyimpan data ke dalam TFRecords.

menulis string byte

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

menulis bilangan bulat

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

menulis float

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

menulis TFRecord, menggunakan helper di atas

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

Untuk membaca data dari TFRecords, Anda harus terlebih dahulu mendeklarasikan tata letak data yang telah disimpan. Dalam deklarasi, Anda dapat mengakses kolom bernama apa pun sebagai daftar panjang tetap atau daftar panjang variabel:

membaca dari TFRecords

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)

Cuplikan kode yang berguna:

membaca elemen data tunggal

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

membaca daftar elemen berukuran tetap

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

membaca sejumlah variabel item data

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 menampilkan vektor renggang dan langkah tambahan diperlukan setelah mendekode TFRecord:

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

Anda juga dapat memiliki kolom opsional di TFRecords. Jika Anda menentukan nilai default saat membaca kolom, nilai default yang akan ditampilkan, bukan error, jika kolom tidak ada.

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

Yang telah kita bahas

• 🤔 sharding file data untuk akses cepat dari GCS
• Mengautentikasi cara menulis TFRecords. (Anda lupa sintaksisnya? Tidak masalah, tandai halaman ini sebagai tips praktis)
• 🤔 memuat Set Data dari TFRecords menggunakan TFRecordDataset

Luangkan waktu sejenak untuk membaca {i>checklist<i} ini di kepala Anda.

6. Selamat!

Anda kini dapat memberi TPU data. Silakan lanjutkan ke lab berikutnya

• [THIS LAB] Pipeline data berkecepatan TPU: tf.data.Dataset dan TFRecords
• Model Keras pertama Anda, dengan pemelajaran transfer
• Jaringan neural konvolusional, dengan Keras dan TPU
• ConvNets, SqueezeNet, Xception modern, dengan Keras dan TPU

TPU dalam praktik

TPU dan GPU tersedia di Cloud AI Platform:

• Di Deep Learning VM
• Di AI Platform Notebooks
• Dalam tugas Pelatihan AI Platform

Terakhir, kami senang menerima masukan. Beri tahu kami jika Anda melihat sesuatu yang salah di lab ini atau jika menurut Anda lab ini harus ditingkatkan. Masukan dapat diberikan melalui masalah GitHub [ link masukan].

Penulis: Martin Görner Twitter: @martin_gorner