Tentang codelab ini
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 "Keras on TPU" Workspace kami. Anda dapat melakukannya dalam urutan berikut atau secara terpisah.
- [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
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 ada yang tidak beres dalam codelab ini, beri tahu kami. Masukan dapat diberikan melalui masalah GitHub [link masukan].
2. Memulai cepat Google Colaboratory
Lab ini menggunakan Kolaborasi Google dan tidak memerlukan penyiapan dari 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 memahami Colaboratory.
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 "Hubungkan" 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 > Jalankan semua
Daftar isi
Semua notebook memiliki daftar isi. Anda dapat membukanya menggunakan panah hitam di sebelah kiri.
Sel tersembunyi
Beberapa sel hanya akan menampilkan judulnya. Fitur ini adalah fitur notebook khusus Colab. Anda dapat mengkliknya dua kali untuk melihat kode di dalamnya, tetapi biasanya ini tidak terlalu menarik. Biasanya mendukung atau fungsi visualisasi. Anda masih harus menjalankan sel-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)?
Ringkasan singkat
Kode untuk melatih model pada 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=...)
Kita akan menggunakan TPU saat ini untuk membangun dan mengoptimalkan pengklasifikasi bunga dengan kecepatan interaktif (menit per sesi pelatihan).
Mengapa TPU?
GPU modern diatur berdasarkan "inti" 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 pemroses vektor klasik dengan unit pengali matriks khusus dan unggul dalam tugas apa pun yang mendominasi perkalian matriks besar, seperti jaringan neural.
Ilustrasi: lapisan jaringan neural padat sebagai perkalian matriks, dengan batch berisi delapan gambar yang diproses melalui jaringan neural sekaligus. Jalankan perkalian kolom x satu baris x untuk memverifikasi bahwa perintah tersebut benar-benar menjumlahkan semua nilai piksel sebuah gambar. Lapisan konvolusional 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 16-32 bit presisi campuran.
Floating point presisi campuran dan bfloat16
MXU menghitung perkalian matriks menggunakan input bfloat16 dan output float32. Akumulasi menengah dilakukan dengan presisi float32.
Pelatihan jaringan neural biasanya tahan terhadap noise yang dihasilkan oleh presisi floating point yang lebih rendah. Ada kasus di mana derau bahkan membantu pengoptimal bertemu. 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 menyebabkan kelebihan dan kekurangan aliran. Ada solusi, tetapi pekerjaan tambahan biasanya diperlukan agar float16 berfungsi.
Itulah mengapa Google memperkenalkan format bfloat16 di TPU. bfloat16 adalah float32 terpotong dengan bit eksponen yang sama persis dan rentang dengan float32. Hal ini, ditambah dengan fakta bahwa TPU menghitung perkalian matriks dalam presisi campuran dengan input bfloat16 tetapi output float32, yang berarti bahwa, biasanya, tidak ada perubahan kode yang diperlukan untuk mendapatkan manfaat dari peningkatan performa dari presisi yang lebih rendah.
Array sistolik
MXU mengimplementasikan perkalian matriks di hardware menggunakan apa yang disebut "array sistolik" arsitektur di mana elemen data mengalir melalui susunan unit komputasi perangkat keras. (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 produk dot ini menjadi "inti" GPU lalu mengeksekusinya pada sebanyak mungkin "inti" yang tersedia secara paralel untuk mencoba dan menghitung setiap nilai matriks yang dihasilkan sekaligus. Jika matriks yang dihasilkan adalah 128x128 besar, itu akan membutuhkan 128x128=16K "inti" tersedia yang biasanya tidak memungkinkan. 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 lainnya. Ini sangat kecil sehingga TPU dapat mengimplementasikan 16K di antaranya dalam MXU 128x128 dan memproses perkalian matriks ini dalam sekali jalan.
Ilustrasi: array sistolik MXU. Elemen komputasinya adalah {i>multi-accumulator<i}. 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. Ini menjadi latihan bagi pengguna untuk memverifikasi bahwa saat data mengalir melalui array, Anda akan mendapatkan hasil perkalian matriks yang keluar dari sisi kanan.
Selain itu, saat produk titik sedang dihitung dalam MXU, jumlah perantara hanya mengalir antara unit komputasi yang berdekatan. Mereka tidak perlu disimpan dan diambil ke/dari memori atau bahkan file register. Hasil akhirnya adalah arsitektur susunan 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 Anda memintanya " Cloud TPU v2" di Google Cloud Platform, Anda akan mendapatkan virtual machine (VM) yang memiliki board TPU yang terpasang di PCI. Papan TPU memiliki empat chip TPU dual-core. Setiap inti TPU memiliki VPU (Vector Processing Unit) dan MXU (MatriX dikalikan Unit) 128x128. "Cloud TPU" ini kemudian terhubung melalui jaringan ke VM yang memintanya. Jadi gambaran lengkapnya terlihat seperti ini:
Ilustrasi: VM Anda dengan "Cloud TPU" yang terpasang pada jaringan akselerator. "Cloud TPU" sendiri terbuat dari VM dengan board TPU yang terpasang pada PCI dan dilengkapi 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. Board 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 mendapatkan 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 ini tidak menjalankan kode Python secara langsung, 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 akan diterjemahkan terlebih dahulu ke representasi XLA (compiler Algebra Linear yang dipercepat), kemudian dikompilasi oleh XLA menjadi kode mesin TPU.
Menggunakan TPU di Keras
TPU didukung melalui Keras API mulai Tensorflow 2.1. Dukungan Keras berfungsi pada TPU dan pod TPU. Berikut ini contoh yang berfungsi pada 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. Cloud Endpoints berfungsi tanpa parameter di sebagian besar sistem Google Cloud (tugas AI Platform, Colaboratory, Kubeflow, Deep Learning VM yang dibuat melalui utilitas 'ctpu up'). Sistem ini mengetahui lokasi TPU mereka berkat variabel lingkungan TPU_NAME. Jika Anda membuat TPU secara manual, setel env TPU_NAME. variabel di VM yang Anda gunakan, atau panggilTPUClusterResolverdengan parameter eksplisit:TPUClusterResolver(tp_uname, zone, project)TPUStrategyadalah bagian yang mengimplementasikan distribusi dan "all-reduce" algoritma sinkronisasi gradien.- Strategi ini diterapkan melalui ruang lingkup. Model harus ditentukan dalam strategi scope().
- Fungsi
tpu_model.fitmengharapkan objek tf.data.Dataset untuk input untuk pelatihan TPU.
Tugas transfer TPU umum
- Meskipun ada banyak cara untuk memuat data dalam model TensorFlow, penggunaan
tf.data.DatasetAPI diperlukan untuk TPU. - TPU sangat cepat dan menyerap data sering menjadi bottleneck saat menjalankannya. 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_functidak 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), lalu ikuti petunjuk di mana pun Anda melihat "DIPERLUKAN KERJA" label.
Fun with tf.data.Dataset (playground).ipynb
Informasi tambahan
Tentang "bunga" set data
{i>Dataset<i} disusun dalam 5 folder. Setiap folder berisi satu jenis bunga. Folder tersebut diberi nama bunga matahari, daisy, dandelion, tulip, dan mawar. Data di-host dalam 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 Dataset 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 referensi tersedia di sini.
Dasar-dasar tf.data.Dataset
Data biasanya berbentuk beberapa file, seperti 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.
Anda kemudian "{i>map<i}" fungsi untuk setiap nama file yang biasanya akan memuat dan mendekode file ke data aktual 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 supervised learning, set data pelatihan biasanya terdiri dari pasangan data pelatihan dan jawaban yang benar. Untuk mengizinkannya, fungsi decoding dapat menampilkan tuple. Anda kemudian akan memiliki {i>dataset <i}yang terdiri dari tuple dan tuple akan dikembalikan 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 Anda melakukan iterasi pada {i>dataset<i} ini, Anda akan melihat bahwa Anda dapat memuat sesuatu seperti 1-2 gambar per detik. Terlalu lambat! Akselerator hardware yang akan kita gunakan untuk pelatihan dapat bertahan berkali-kali lipat kecepatan ini. Buka bagian berikutnya untuk melihat cara kami mencapainya.
Solusi
Berikut notebook solusinya. Anda dapat menggunakannya jika mengalami kesulitan.
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 kita sebagai ribuan file individual tidaklah ideal. Kita akan mengelompokkannya dalam jumlah file yang lebih kecil dan menggunakan kemampuan tf.data.Dataset untuk membaca dari beberapa file secara paralel.
Baca-tayang
Kode yang memuat file gambar, mengubah ukurannya ke ukuran umum, lalu menyimpannya di 16 file TFRecord ada di notebook berikut. Harap baca dengan cepat. Anda tidak perlu menjalankannya karena data berformat TFRecord dengan benar akan disediakan untuk codelab lainnya.
Flower pictures to TFRecords.ipynb
Tata letak data yang ideal untuk throughput GCS yang optimal
Format file TFRecord
Format file pilihan Tensorflow untuk menyimpan data adalah format TFRecord berbasis protobuf. Format serialisasi lainnya juga dapat 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. Mereka selalu disimpan sebagai daftar, elemen data tunggal akan berupa daftar ukuran 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 sintaksnya? 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!
Sekarang Anda dapat melakukan feed pada TPU dengan 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
Penggunaan TPU
TPU dan GPU tersedia di Cloud AI Platform:
- Di Deep Learning VM
- Di AI Platform Notebooks
- Dalam tugas AI Platform Training
Terakhir, kami senang menerima masukan. Beri tahu kami jika Anda melihat ada yang tidak beres di lab ini atau menurut Anda harus diperbaiki. Masukan dapat diberikan melalui masalah GitHub [link masukan].
|
|
