ConvNets yang Keras dan modern, di TPU

1. Ringkasan

Di lab ini, Anda akan mempelajari cara membangun, melatih, dan menyesuaikan jaringan neural konvolusional Anda sendiri dari nol dengan Keras dan Tensorflow 2. Proses ini kini dapat dilakukan dalam hitungan menit menggunakan kemampuan TPU. Anda juga akan mempelajari berbagai pendekatan mulai dari transfer learning yang sangat sederhana hingga arsitektur konvolusional modern seperti Squeezenet. Lab ini mencakup penjelasan teoretis tentang jaringan neural dan merupakan titik awal yang baik bagi developer yang mempelajari deep learning.

Membaca makalah deep learning bisa sulit dan membingungkan. Mari kita lihat langsung arsitektur jaringan neural konvolusional modern.

Yang akan Anda pelajari

• Untuk menggunakan Keras dan Tensor Processing Unit (TPU) guna membangun model kustom Anda dengan lebih cepat.
• Untuk menggunakan tf.data.Dataset API dan format TFRecord untuk memuat data pelatihan secara efisien.
• Untuk menipu 😈, gunakan transfer learning, bukan membuat model Anda sendiri.
• Untuk menggunakan gaya model fungsional dan berurutan Keras.
• Untuk membangun pengklasifikasi Keras Anda sendiri dengan lapisan softmax dan kerugian entropi silang.
• Untuk menyesuaikan model Anda dengan pilihan lapisan konvolusional yang baik.
• Untuk mempelajari ide arsitektur convnet modern seperti modul, global average pooling, dll.
• Untuk membangun convnet modern sederhana menggunakan arsitektur Squeezenet.

Masukan

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

2. Mulai cepat Google Colaboratory

Lab ini menggunakan Google Collaboratory dan tidak memerlukan penyiapan di pihak Anda. Anda dapat menjalankannya dari Chromebook. Buka file di bawah, dan jalankan sel untuk mempelajari notebook Colab.

Welcome to Colab.ipynb

Pilih backend TPU

Di menu Colab, pilih Runtime > Ubah jenis runtime, lalu pilih TPU. Dalam codelab ini, Anda akan menggunakan TPU (Tensor Processing Unit) yang andal yang didukung untuk pelatihan yang dipercepat hardware. Koneksi ke runtime akan terjadi secara otomatis pada eksekusi pertama, atau Anda dapat menggunakan tombol "Hubungkan" di sudut 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 fungsi atau visualisasi. Anda tetap 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 sah. 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. Dalam 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 yang lebih besar yang disebut "pod TPU" hingga 2048 core. Hardware tambahan dapat digunakan untuk mempercepat pelatihan dengan meningkatkan ukuran tumpukan 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 proses pelatihan).

Mengapa TPU?

GPU modern disusun di sekitar "core" yang dapat diprogram, sebuah arsitektur yang sangat fleksibel yang memungkinkan GPU 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 oleh perkalian matriks besar, seperti jaringan neural.

Ilustrasi: lapisan jaringan neural padat sebagai perkalian matriks, dengan batch delapan gambar yang diproses melalui jaringan neural sekaligus. Lakukan perkalian satu baris x kolom untuk memverifikasi bahwa operasi ini memang melakukan jumlah berbobot dari semua nilai piksel gambar. Lapisan konvolusional juga dapat direpresentasikan sebagai perkalian matriks meskipun sedikit lebih rumit ( penjelasan di sini, di bagian 1).

Hardware

MXU dan VPU

Core TPU v2 terdiri dari Matrix Multiply Unit (MXU) yang menjalankan perkalian matriks dan Vector Processing Unit (VPU) untuk semua tugas lainnya 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 perantara dilakukan dengan presisi float32.

Pelatihan jaringan neural biasanya tahan terhadap derau yang diperkenalkan oleh presisi floating point yang berkurang. Ada kasus ketika derau bahkan membantu pengoptimalan konvergen. Presisi floating point 16-bit secara tradisional digunakan untuk mempercepat komputasi, tetapi format float16 dan float32 memiliki rentang yang sangat berbeda. Mengurangi presisi dari float32 ke float16 biasanya menyebabkan overflow dan underflow. Solusi memang ada, tetapi biasanya diperlukan pekerjaan tambahan agar float16 dapat berfungsi.

Itulah sebabnya Google memperkenalkan format bfloat16 di TPU. bfloat16 adalah float32 yang dipangkas dengan bit eksponen dan rentang yang sama persis dengan float32. Selain itu, TPU menghitung perkalian matriks dalam presisi campuran dengan input bfloat16, tetapi output float32. Artinya, biasanya tidak ada perubahan kode yang diperlukan untuk mendapatkan manfaat dari peningkatan performa presisi yang lebih rendah.

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

Array sistolik

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

Elemen dasar perkalian matriks adalah produk titik antara baris dari satu matriks dan kolom dari matriks lainnya (lihat ilustrasi di bagian atas bagian ini). Untuk perkalian matriks Y=X*W, salah 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 titik ini ke dalam "core" GPU, lalu mengeksekusinya di sebanyak mungkin "core" secara paralel untuk mencoba menghitung setiap nilai matriks yang dihasilkan sekaligus. Jika matriks yang dihasilkan berukuran 128x128, maka diperlukan 128x128=16 ribu "core" yang tersedia, yang biasanya tidak mungkin. GPU terbesar memiliki sekitar 4.000 core. Sebaliknya, TPU menggunakan hardware minimum untuk unit komputasi di MXU: hanya bfloat16 x bfloat16 => float32 multiply-accumulator, tidak ada yang lain. Unit ini sangat kecil sehingga TPU dapat menerapkan 16 ribu unit di MXU 128x128 dan memproses perkalian matriks ini sekaligus.

Ilustrasi: array sistolik MXU. Elemen komputasi adalah multiply-accumulator. Nilai satu matriks dimuat ke dalam array (titik merah). Nilai matriks lainnya mengalir melalui array (titik abu-abu). Garis vertikal menyebarkan nilai ke atas. Garis horizontal menyebarkan jumlah parsial. Pengguna harus memverifikasi bahwa saat data mengalir melalui array, Anda akan mendapatkan hasil perkalian matriks yang keluar dari sisi kanan.

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

Cloud TPU

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

Ilustrasi: VM Anda dengan akselerator "Cloud TPU" yang terhubung ke jaringan. "Cloud TPU" itu sendiri terdiri dari VM dengan board TPU yang terhubung ke 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 core TPU v3.

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

Selama pelatihan, gradien dipertukarkan antar-core TPU menggunakan algoritma pengurangan penuh ( penjelasan yang baik tentang pengurangan penuh di sini). Model yang dilatih dapat memanfaatkan hardware dengan melatih ukuran batch yang besar.

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

Software

Pelatihan ukuran batch besar

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

Dalam lab kode 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 batch yang sangat besar, penanganan khusus mungkin diperlukan di beberapa model. Lihat LARSOptimizer untuk mengetahui detail selengkapnya.

Di balik layar: XLA

Program Tensorflow menentukan grafik komputasi. TPU tidak menjalankan kode Python secara langsung, tetapi menjalankan grafik komputasi yang ditentukan oleh program Tensorflow Anda. Di balik layar, compiler yang disebut XLA (compiler aljabar linier yang dipercepat) mengubah grafik node komputasi Tensorflow 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, graf komputasi yang ditentukan oleh program Tensorflow Anda pertama-tama diterjemahkan ke dalam representasi XLA (compiler aljabar linier yang dipercepat), lalu dikompilasi oleh XLA ke dalam 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 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() menemukan TPU di jaringan. Fungsi ini dapat digunakan tanpa parameter di sebagian besar sistem Google Cloud (job AI Platform, Colaboratory, Kubeflow, VM Deep Learning yang dibuat melalui utilitas 'ctpu up'). Sistem ini mengetahui lokasi TPU berkat variabel lingkungan TPU_NAME. Jika Anda membuat TPU secara manual, tetapkan variabel lingkungan TPU_NAME di VM yang Anda gunakan, atau panggil TPUClusterResolver dengan parameter eksplisit: TPUClusterResolver(tp_uname, zone, project)
• TPUStrategy adalah bagian yang menerapkan algoritma sinkronisasi gradien "all-reduce" dan distribusi.
• Strategi diterapkan melalui cakupan. Model harus ditentukan dalam strategy scope().
• Fungsi tpu_model.fit mengharapkan objek tf.data.Dataset sebagai input untuk pelatihan TPU.

Tugas umum porting TPU

• Meskipun ada banyak cara untuk memuat data dalam model Tensorflow, untuk TPU, penggunaan API tf.data.Dataset diperlukan.
• TPU sangat cepat dan penyerapan data sering kali menjadi hambatan saat berjalan di TPU. Ada alat yang dapat Anda gunakan untuk mendeteksi hambatan data dan tips performa lainnya di Panduan Performa TPU.
• Angka int8 atau int16 diperlakukan sebagai int32. TPU tidak memiliki hardware bilangan bulat yang beroperasi pada 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 dan penerusan 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 set data gambar bunga. Tujuannya adalah mempelajari cara mengategorikannya ke dalam 5 jenis bunga. Pemuatan data dilakukan menggunakan tf.data.Dataset API. Pertama, mari kita kenali API-nya.

Praktik langsung

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

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

Informasi tambahan

Tentang set data "flowers"

Dataset diatur dalam 5 folder. Setiap folder berisi bunga dari satu jenis. Foldernya diberi nama bunga matahari, daisy, dandelion, tulip, dan mawar. Data dihosting di bucket publik di Google Cloud Storage. Kutipan:

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 dalam Set Data, API ini 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 dalam artikel ini. Dokumentasi referensi ada di sini.

Dasar-dasar tf.data.Dataset

Data biasanya berupa beberapa file, seperti gambar di sini. 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 ke dalam 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 supervised learning, set data pelatihan biasanya terdiri dari pasangan data pelatihan dan jawaban yang benar. Untuk mengizinkan hal ini, fungsi decoding dapat menampilkan tuple. Kemudian, Anda akan memiliki set data tuple dan tuple akan ditampilkan saat Anda melakukan iterasi di dalamnya. 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 itu 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 kami mencapainya.

Solusi

Berikut adalah notebook solusi. 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 Set Data

Luangkan waktu sejenak untuk meninjau checklist ini dalam pikiran Anda.

5. Memuat data dengan cepat

Akselerator hardware Tensor Processing Unit (TPU) yang akan kita gunakan di lab ini sangat cepat. Tantangannya sering kali adalah memberi mereka data yang cukup cepat agar mereka tetap sibuk. Google Cloud Storage (GCS) mampu mempertahankan throughput yang sangat tinggi, tetapi seperti semua sistem penyimpanan cloud, memulai koneksi memerlukan beberapa kali bolak-balik jaringan. 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.

Bacaan lengkap

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 yang diformat TFRecord dengan benar akan disediakan untuk codelab selanjutnya.

Flower pictures to TFRecords.ipynb

Tata letak data yang ideal untuk throughput GCS yang optimal

Aturan umumnya adalah membagi data Anda ke dalam beberapa file berukuran besar (puluhan hingga ratusan) (puluhan hingga ratusan MB). Jika Anda memiliki terlalu banyak file, misalnya ribuan file, waktu untuk mengakses setiap file mungkin mulai mengganggu. Jika Anda memiliki terlalu sedikit file, seperti satu atau dua, Anda tidak akan mendapatkan manfaat dari 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 N file secara paralel dan mengabaikan urutan data demi kecepatan membaca.

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 TFRecord: string byte (daftar byte), bilangan bulat 64 bit, dan float 32 bit. Data ini selalu disimpan sebagai daftar, satu elemen data akan menjadi daftar berukuran 1. Anda dapat menggunakan fungsi helper berikut untuk menyimpan data ke TFRecord.

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 TFRecord, Anda harus mendeklarasikan tata letak rekaman yang telah Anda simpan terlebih dahulu. Dalam deklarasi, Anda dapat mengakses kolom bernama sebagai daftar panjang tetap atau daftar panjang variabel:

membaca dari TFRecord

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 ukuran 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 jarang dan langkah tambahan diperlukan setelah mendekode TFRecord:

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

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

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

Yang telah kita bahas

• 🤔 membagi file data untuk akses cepat dari GCS
• 😓 cara menulis TFRecord. (Anda sudah lupa sintaksisnya? Tidak masalah, beri bookmark pada halaman ini sebagai panduan)
• 🤔 memuat Dataset dari TFRecords menggunakan TFRecordDataset

Luangkan waktu sejenak untuk meninjau checklist ini dalam pikiran Anda.

6. [INFO] Pengklasifikasi jaringan neural 101

Singkatnya

Jika semua istilah yang dicetak tebal di paragraf berikutnya sudah Anda ketahui, Anda dapat melanjutkan ke latihan berikutnya. Jika Anda baru memulai deep learning, selamat datang, dan silakan baca terus.

Pengklasifikasi jaringan neural terdiri dari beberapa lapisan neuron. Untuk klasifikasi gambar, lapisan ini dapat berupa lapisan padat atau, lebih sering, lapisan konvolusional. Biasanya diaktifkan dengan fungsi aktivasi relu. Lapisan terakhir menggunakan neuron sebanyak jumlah kelas dan diaktifkan dengan softmax. Untuk klasifikasi, entropi silang adalah fungsi kerugian yang paling umum digunakan, yang membandingkan label yang dienkode one-hot (yaitu jawaban yang benar) dengan probabilitas yang diprediksi oleh jaringan neural. Untuk meminimalkan kehilangan, sebaiknya pilih pengoptimal dengan momentum, misalnya AdamOptimizer dan latih pada batch gambar dan label pelatihan.

Untuk model yang dibuat sebagai urutan lapisan, Keras menawarkan Sequential API. Misalnya, pengklasifikasi gambar yang menggunakan tiga lapisan padat dapat ditulis di Keras sebagai:

model = tf.keras.Sequential([
    tf.keras.layers.Flatten(input_shape=[192, 192, 3]),
    tf.keras.layers.Dense(500, activation="relu"),
    tf.keras.layers.Dense(50, activation="relu"),
    tf.keras.layers.Dense(5, activation='softmax') # classifying into 5 classes
])

# this configures the training of the model. Keras calls it "compiling" the model.
model.compile(
  optimizer='adam',
  loss= 'categorical_crossentropy',
  metrics=['accuracy']) # % of correct answers

# train the model
model.fit(dataset, ... )

Jaringan neural padat

Ini adalah jaringan neural paling sederhana untuk mengklasifikasikan gambar. Jaringan ini terdiri dari "neuron" yang disusun dalam lapisan. Lapisan pertama memproses data input dan memasukkan outputnya ke lapisan lain. Lapisan ini disebut "padat" karena setiap neuron terhubung ke semua neuron di lapisan sebelumnya.

Anda dapat memasukkan gambar ke dalam jaringan seperti itu dengan meratakan nilai RGB semua pikselnya menjadi vektor panjang dan menggunakannya sebagai input. Teknik ini bukan yang terbaik untuk pengenalan gambar, tetapi kami akan meningkatkannya nanti.

Neuron, aktivasi, RELU

"Neuron" menghitung jumlah bobot semua inputnya, menambahkan nilai yang disebut "bias", dan meneruskan hasilnya melalui "fungsi aktivasi". Bobot dan bias tidak diketahui pada awalnya. Bobot ini akan diinisialisasi secara acak dan "dipelajari" dengan melatih jaringan neural pada banyak data yang diketahui.

Fungsi aktivasi yang paling populer disebut RELU untuk Rectified Linear Unit. Ini adalah fungsi yang sangat sederhana seperti yang dapat Anda lihat pada grafik di atas.

Aktivasi softmax

Jaringan di atas diakhiri dengan lapisan 5 neuron karena kita mengklasifikasikan bunga ke dalam 5 kategori (mawar, tulip, dandelion, daisy, bunga matahari). Neuron di lapisan perantara diaktifkan menggunakan fungsi aktivasi RELU klasik. Namun, di lapisan terakhir, kita ingin menghitung angka antara 0 dan 1 yang merepresentasikan probabilitas bunga ini sebagai mawar, tulip, dan sebagainya. Untuk itu, kita akan menggunakan fungsi aktivasi yang disebut "softmax".

Penerapan softmax pada vektor dilakukan dengan mengambil eksponensial setiap elemen, lalu menormalisasi vektor, biasanya menggunakan norma L1 (jumlah nilai absolut) sehingga nilai-nilai tersebut berjumlah 1 dan dapat ditafsirkan sebagai probabilitas.

Mengapa "softmax" disebut softmax? Eksponensial adalah fungsi yang meningkat tajam. Hal ini akan meningkatkan perbedaan antara output neuron. Kemudian, saat Anda menormalisasi vektor, elemen terbesar, yang mendominasi norma, akan dinormalisasi ke nilai yang mendekati 1, sementara semua elemen lainnya akan dibagi dengan nilai yang besar dan dinormalisasi ke nilai yang mendekati 0. Vektor yang dihasilkan dengan jelas menunjukkan kelas pemenang, yaitu "maks", tetapi mempertahankan urutan relatif asli dari nilainya, sehingga disebut "soft".

Kerugian entropi silang

Setelah jaringan neural kita menghasilkan prediksi dari gambar input, kita perlu mengukur seberapa baik prediksi tersebut, yaitu jarak antara yang disampaikan jaringan dan jawaban yang benar, yang sering disebut "label". Ingatlah bahwa kita memiliki label yang benar untuk semua gambar dalam set data.

Jarak apa pun akan berfungsi, tetapi untuk masalah klasifikasi, yang disebut "jarak entropi silang" adalah yang paling efektif. Kita akan menyebutnya sebagai fungsi error atau "loss":

Encoding "One-hot" berarti Anda merepresentasikan label "3) dandelion" dengan menggunakan vektor 5 nilai, semuanya nol kecuali nilai ke-3 yang bernilai 1. Vektor ini merepresentasikan probabilitas 100% sebagai dandelion. Jaringan neural kami juga menghasilkan prediksi sebagai vektor 5 nilai probabilitas. Mudah dibandingkan.

Penurunan gradien

"Melatih" jaringan neural sebenarnya berarti menggunakan gambar dan label pelatihan untuk menyesuaikan bobot dan bias sehingga dapat meminimalkan fungsi loss cross-entropy. Berikut cara kerjanya.

Cross-entropy adalah fungsi bobot, bias, piksel gambar pelatihan, dan kelasnya yang diketahui.

Jika kita menghitung turunan parsial cross-entropy relatif terhadap semua bobot dan semua bias, kita akan mendapatkan "gradien", yang dihitung untuk gambar, label, dan nilai bobot dan bias saat ini. Ingatlah bahwa kita dapat memiliki jutaan bobot dan bias, sehingga menghitung gradien akan membutuhkan banyak pekerjaan. Untungnya, Tensorflow melakukannya untuk kita. Properti matematika gradien adalah bahwa gradien mengarah "ke atas". Karena kita ingin menuju tempat dengan entropi silang yang rendah, kita bergerak ke arah yang berlawanan. Kita memperbarui bobot dan bias dengan sebagian kecil gradien. Kemudian, kita melakukan hal yang sama berulang kali menggunakan batch berikutnya dari gambar dan label pelatihan, dalam loop pelatihan. Semoga, proses ini akan mencapai titik di mana entropi silang minimal, meskipun tidak ada jaminan bahwa minimum ini unik.

"Kecepatan pembelajaran": Anda tidak dapat memperbarui bobot dan bias dengan seluruh panjang gradien di setiap iterasi. Ini seperti mencoba mencapai dasar lembah sambil mengenakan sepatu tujuh liga. Anda akan melompat dari satu sisi lembah ke sisi lainnya. Untuk mencapai bagian bawah, Anda perlu melakukan langkah-langkah yang lebih kecil, yaitu hanya menggunakan sebagian kecil gradien, biasanya dalam rentang 1/1000. Pecahan ini disebut "rasio pembelajaran".

Mini-batching dan momentum

Anda dapat menghitung gradien hanya pada satu contoh gambar dan langsung memperbarui bobot dan bias, tetapi melakukannya pada batch, misalnya, 128 gambar akan memberikan gradien yang lebih baik dalam merepresentasikan batasan yang diberlakukan oleh contoh gambar yang berbeda dan oleh karena itu cenderung lebih cepat mencapai solusi. Ukuran tumpukan mini adalah parameter yang dapat disesuaikan.

Teknik ini, yang terkadang disebut "stochastic gradient descent", memiliki manfaat lain yang lebih pragmatis: bekerja dengan batch juga berarti bekerja dengan matriks yang lebih besar dan biasanya lebih mudah dioptimalkan di GPU dan TPU.

Konvergensi masih bisa sedikit kacau dan bahkan dapat berhenti jika vektor gradien semuanya nol. Apakah itu berarti kita telah menemukan nilai minimum? Tidak selalu. Komponen gradien dapat bernilai nol pada minimum atau maksimum. Dengan vektor gradien yang memiliki jutaan elemen, jika semuanya adalah nol, probabilitas bahwa setiap nol sesuai dengan titik minimum dan tidak ada yang sesuai dengan titik maksimum cukup kecil. Dalam ruang dengan banyak dimensi, titik pelana cukup umum dan kita tidak ingin berhenti di titik tersebut.

Ilustrasi: titik pelana. Gradiennya adalah 0, tetapi bukan minimum di semua arah. (Atribusi gambar Wikimedia: By Nicoguaro - Own work, CC BY 3.0)

Solusinya adalah menambahkan beberapa momentum ke algoritma pengoptimalan sehingga dapat melewati titik pelana tanpa berhenti.

Library Tensorflow menyediakan berbagai pengoptimal, dimulai dengan tf.train.GradientDescentOptimizer. Pengoptimal populer yang lebih canggih dan memiliki momentum bawaan adalah tf.train.RMSPropOptimizer atau tf.train.AdamOptimizer.

Glosarium

batch atau tumpukan mini: pelatihan selalu dilakukan pada batch data dan label pelatihan. Dengan demikian, algoritma dapat melakukan konvergensi. Dimensi "batch" biasanya merupakan dimensi pertama tensor data. Misalnya, tensor dengan bentuk [100, 192, 192, 3] berisi 100 gambar berukuran 192x192 piksel dengan tiga nilai per piksel (RGB).

Kerugian entropi silang: fungsi kerugian khusus yang sering digunakan dalam pengklasifikasi.

lapisan padat: lapisan neuron di mana setiap neuron terhubung ke semua neuron di lapisan sebelumnya.

fitur: input jaringan saraf terkadang disebut "fitur". Seni mencari tahu bagian mana dari set data (atau kombinasi bagian) yang akan dimasukkan ke jaringan neural untuk mendapatkan prediksi yang baik disebut "rekayasa fitur".

label: nama lain untuk "kelas" atau jawaban yang benar dalam masalah klasifikasi terawasi

kecepatan pembelajaran: fraksi gradien yang digunakan untuk memperbarui bobot dan bias pada setiap iterasi loop pelatihan.

logits: output lapisan neuron sebelum fungsi aktivasi diterapkan disebut "logits". Istilah ini berasal dari "fungsi logistik" alias "fungsi sigmoid" yang dulunya merupakan fungsi aktivasi paling populer. "Neuron outputs before logistic function" disingkat menjadi "logits".

loss: fungsi error yang membandingkan output jaringan neural dengan jawaban yang benar

neuron: menghitung jumlah input yang diberi bobot, menambahkan bias, dan meneruskan hasilnya melalui fungsi aktivasi.

enkode one-hot: kelas 3 dari 5 dienkode sebagai vektor 5 elemen, semua nol kecuali yang ke-3 yaitu 1.

relu: unit linear yang diperbaiki. Fungsi aktivasi yang populer untuk neuron.

sigmoid: fungsi aktivasi lain yang dulu populer dan masih berguna dalam kasus khusus.

softmax: fungsi aktivasi khusus yang bekerja pada vektor, meningkatkan perbedaan antara komponen terbesar dan semua komponen lainnya, serta menormalisasi vektor agar memiliki jumlah 1 sehingga dapat ditafsirkan sebagai vektor probabilitas. Digunakan sebagai langkah terakhir dalam pengklasifikasi.

tensor: "Tensor" seperti matriks, tetapi dengan jumlah dimensi yang berubah-ubah. Tensor 1 dimensi adalah vektor. Tensor 2 dimensi adalah matriks. Kemudian, Anda dapat memiliki tensor dengan 3, 4, 5, atau lebih dimensi.

7. Transfer Learning

Untuk masalah klasifikasi gambar, lapisan padat mungkin tidak cukup. Kita harus mempelajari lapisan konvolusional dan berbagai cara untuk menyusunnya.

Namun, kita juga bisa menggunakan pintasan. Ada jaringan neural konvolusional yang terlatih sepenuhnya dan tersedia untuk didownload. Anda dapat memotong lapisan terakhirnya, yaitu head klasifikasi softmax, dan menggantinya dengan head Anda sendiri. Semua bobot dan bias yang dilatih tetap seperti semula, Anda hanya melatih ulang lapisan softmax yang ditambahkan. Teknik ini disebut transfer learning dan secara mengejutkan, teknik ini berfungsi selama set data yang digunakan untuk melatih awal jaringan neural "cukup dekat" dengan set data Anda.

Interaktif

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

Keras Flowers transfer learning (playground).ipynb

Informasi tambahan

Dengan transfer learning, Anda mendapatkan manfaat dari arsitektur jaringan neural konvolusional canggih yang dikembangkan oleh peneliti terkemuka dan dari pra-pelatihan pada set data gambar yang sangat besar. Dalam kasus ini, kita akan menggunakan transfer learning dari jaringan yang dilatih menggunakan ImageNet, yaitu database gambar yang berisi banyak tanaman dan pemandangan luar ruangan, yang cukup mirip dengan bunga.

Ilustrasi: menggunakan jaringan neural konvolusional yang kompleks, yang sudah dilatih, sebagai kotak hitam, melatih ulang hanya head klasifikasi. Inilah yang disebut pemelajaran transfer. Kita akan melihat cara kerja pengaturan rumit lapisan konvolusional ini nanti. Untuk saat ini, itu adalah masalah orang lain.

Pemelajaran transfer di Keras

Di Keras, Anda dapat membuat instance model terlatih dari koleksi tf.keras.applications.*. Misalnya, MobileNet V2 adalah arsitektur konvolusional yang sangat baik dan tetap berukuran wajar. Dengan memilih include_top=False, Anda akan mendapatkan model terlatih tanpa lapisan softmax akhir sehingga Anda dapat menambahkan lapisan Anda sendiri:

pretrained_model = tf.keras.applications.MobileNetV2(input_shape=[*IMAGE_SIZE, 3], include_top=False)
pretrained_model.trainable = False

model = tf.keras.Sequential([
    pretrained_model,
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(5, activation='softmax')
])

Perhatikan juga setelan pretrained_model.trainable = False. Hal ini membekukan bobot dan bias model terlatih sebelumnya sehingga Anda hanya melatih lapisan softmax. Proses ini biasanya melibatkan bobot yang relatif sedikit dan dapat dilakukan dengan cepat serta tidak memerlukan set data yang sangat besar. Namun, jika Anda memiliki banyak data, transfer learning dapat bekerja lebih baik dengan pretrained_model.trainable = True. Bobot yang telah dilatih sebelumnya kemudian memberikan nilai awal yang sangat baik dan masih dapat disesuaikan oleh pelatihan agar lebih sesuai dengan masalah Anda.

Terakhir, perhatikan lapisan Flatten() yang disisipkan sebelum lapisan softmax padat Anda. Lapisan padat bekerja pada vektor data datar, tetapi kita tidak tahu apakah itu yang ditampilkan oleh model terlatih. Itulah sebabnya kita perlu meratakan. Pada bab berikutnya, saat mempelajari arsitektur konvolusional, kita akan menjelaskan format data yang ditampilkan oleh lapisan konvolusional.

Anda akan mendapatkan akurasi mendekati 75% dengan pendekatan ini.

Solusi

Berikut adalah notebook solusi. Anda dapat menggunakannya jika mengalami masalah.

Keras Flowers transfer learning (solution).ipynb

Yang telah kita bahas

• 🤔 Cara menulis pengklasifikasi di Keras
• 🤓 dikonfigurasi dengan lapisan terakhir softmax, dan kerugian entropi silang
• 😈 Pemelajaran transfer
• 🤔 Melatih model pertama Anda
• 🧐 Mengikuti kerugian dan akurasinya selama pelatihan

Luangkan waktu sejenak untuk meninjau checklist ini dalam pikiran Anda.

8. [INFO] Jaringan neural konvolusional

Singkatnya

Jika semua istilah yang dicetak tebal di paragraf berikutnya sudah Anda ketahui, Anda dapat melanjutkan ke latihan berikutnya. Jika Anda baru memulai jaringan neural konvolusional, silakan baca terus.

Ilustrasi: memfilter gambar dengan dua filter berurutan yang masing-masing terdiri dari 48 bobot yang dapat dipelajari (4x4x3=48).

Jaringan neural konvolusional menerapkan serangkaian filter yang dapat dipelajari ke gambar input. Lapisan konvolusional ditentukan oleh ukuran filter (atau kernel), jumlah filter yang diterapkan, dan langkah. Input dan output lapisan konvolusional memiliki tiga dimensi (lebar, tinggi, jumlah saluran), dimulai dengan gambar input (lebar, tinggi, saluran RGB). Saat menumpuk lapisan konvolusional, lebar dan tinggi output dapat disesuaikan dengan menggunakan langkah >1 atau dengan operasi max-pooling. Kedalaman output (jumlah saluran) disesuaikan dengan menggunakan lebih banyak atau lebih sedikit filter.

Berikut tampilan jaringan neural konvolusional sederhana di Keras:

model = tf.keras.Sequential([
  # input: images of size 192x192x3 pixels (the three stands for RGB channels)
  tf.keras.layers.Conv2D(kernel_size=3, filters=24, padding='same', activation='relu', input_shape=[192, 192, 3]),
  tf.keras.layers.Conv2D(kernel_size=3, filters=24, padding='same', activation='relu'),
  tf.keras.layers.MaxPooling2D(pool_size=2),
  tf.keras.layers.Conv2D(kernel_size=3, filters=12, padding='same', activation='relu'),
  tf.keras.layers.MaxPooling2D(pool_size=2),
  tf.keras.layers.Conv2D(kernel_size=3, filters=6, padding='same', activation='relu'),
  tf.keras.layers.Flatten(),
  # classifying into 5 categories
  tf.keras.layers.Dense(5, activation='softmax')
])

model.compile(
  optimizer='adam',
  loss= 'categorical_crossentropy',
  metrics=['accuracy'])

Dasar-dasar jaringan neural konvolusional

Dalam lapisan jaringan konvolusional, satu "neuron" melakukan jumlah berbobot piksel tepat di atasnya, hanya di seluruh area kecil gambar. Lapisan ini menambahkan bias dan memasukkan jumlah melalui fungsi aktivasi, seperti halnya neuron di lapisan padat biasa. Operasi ini kemudian diulangi di seluruh gambar menggunakan bobot yang sama. Ingatlah bahwa di lapisan padat, setiap neuron memiliki bobotnya sendiri. Di sini, satu "patch" bobot meluncur di seluruh gambar ke kedua arah (sebuah "konvolusi"). Output memiliki nilai sebanyak jumlah piksel dalam gambar (meskipun beberapa padding diperlukan di tepi). Operasi ini adalah operasi pemfilteran, menggunakan filter dengan 4x4x3=48 bobot.

Namun, 48 bobot tidak akan cukup. Untuk menambahkan lebih banyak derajat kebebasan, kita mengulangi operasi yang sama dengan kumpulan bobot baru. Tindakan ini akan menghasilkan serangkaian output filter baru. Mari kita sebut sebagai "saluran" output berdasarkan analogi dengan saluran R,G,B dalam gambar input.

Dua (atau lebih) set bobot dapat dijumlahkan sebagai satu tensor dengan menambahkan dimensi baru. Hal ini memberi kita bentuk umum tensor bobot untuk lapisan konvolusional. Karena jumlah saluran input dan output adalah parameter, kita dapat mulai menumpuk dan merangkai lapisan konvolusional.

Ilustrasi: jaringan neural konvolusional mengubah "kubus" data menjadi "kubus" data lainnya.

Konvolusi berirama, penggabungan maks

Dengan melakukan konvolusi dengan langkah 2 atau 3, kita juga dapat mengecilkan kubus data yang dihasilkan dalam dimensi horizontalnya. Ada dua cara umum untuk melakukannya:

• Konvolusi berirama: filter geser seperti di atas, tetapi dengan irama >1
• Penggabungan maks: jendela geser yang menerapkan operasi MAX (biasanya pada patch 2x2, diulang setiap 2 piksel)

Ilustrasi: menggeser jendela komputasi sebesar 3 piksel akan menghasilkan lebih sedikit nilai output. Konvolusi berirama atau penggabungan maks (maks pada jendela 2x2 yang bergeser dengan irama 2) adalah cara untuk mengecilkan kubus data dalam dimensi horizontal.

"Max-pooling" dapat membantu kita memahami secara intuitif cara kerja jaringan konvolusional: jika Anda mengasumsikan bahwa selama pelatihan, patch bobot berkembang menjadi filter yang mengenali bentuk dasar (garis horizontal dan vertikal, kurva, ...), maka salah satu cara untuk menyaring informasi yang berguna adalah dengan mempertahankan output di seluruh lapisan tempat bentuk dikenali dengan intensitas maksimum. Dalam praktiknya, di lapisan max-pool, output neuron diproses dalam grup 2x2 dan hanya nilai maksimum yang dipertahankan.

Convolutional classifier (Pengklasifikasi konvolusional)

Terakhir, kita melampirkan head klasifikasi dengan meratakan kubus data terakhir dan memasukkannya melalui lapisan padat yang diaktifkan softmax. Pengklasifikasi konvolusional standar dapat terlihat seperti ini:

Ilustrasi: pengklasifikasi gambar menggunakan lapisan konvolusional dan softmax. Menggunakan filter 3x3 dan 1x1. Lapisan maxpool mengambil nilai maksimum dari grup titik data 2x2. Kepala klasifikasi diimplementasikan dengan lapisan padat dengan aktivasi softmax.

Di Keras

Stack konvolusional yang diilustrasikan di atas dapat ditulis di Keras seperti ini:

model = tf.keras.Sequential([
  # input: images of size 192x192x3 pixels (the three stands for RGB channels)    
  tf.keras.layers.Conv2D(kernel_size=3, filters=32, padding='same', activation='relu', input_shape=[192, 192, 3]),
  tf.keras.layers.Conv2D(kernel_size=1, filters=32, padding='same', activation='relu'),
  tf.keras.layers.MaxPooling2D(pool_size=2),
  tf.keras.layers.Conv2D(kernel_size=3, filters=32, padding='same', activation='relu'),
  tf.keras.layers.Conv2D(kernel_size=1, filters=32, padding='same', activation='relu'),
  tf.keras.layers.MaxPooling2D(pool_size=2),
  tf.keras.layers.Conv2D(kernel_size=3, filters=32, padding='same', activation='relu'),
  tf.keras.layers.Conv2D(kernel_size=1, filters=32, padding='same', activation='relu'),
  tf.keras.layers.MaxPooling2D(pool_size=2),
  tf.keras.layers.Conv2D(kernel_size=3, filters=32, padding='same', activation='relu'),
  tf.keras.layers.Conv2D(kernel_size=1, filters=32, padding='same', activation='relu'),
  tf.keras.layers.MaxPooling2D(pool_size=2),
  tf.keras.layers.Conv2D(kernel_size=3, filters=16, padding='same', activation='relu'),
  tf.keras.layers.Conv2D(kernel_size=1, filters=8, padding='same', activation='relu'),
  tf.keras.layers.Flatten(),
  # classifying into 5 categories
  tf.keras.layers.Dense(5, activation='softmax')
])

model.compile(
  optimizer='adam',
  loss= 'categorical_crossentropy',
  metrics=['accuracy'])

Parameter padding di lapisan konvolusional dapat memiliki dua nilai:

• "same": isi dengan nol sehingga menghasilkan output dengan lebar/tinggi yang sama seperti input
• "valid": tidak ada padding, hanya menggunakan piksel sebenarnya

9. Convnet kustom Anda

Interaktif

Mari kita bangun dan latih jaringan neural konvolusional dari awal. Dengan menggunakan TPU, kita dapat melakukan iterasi dengan sangat cepat. Buka notebook berikut, jalankan sel (Shift-ENTER), dan ikuti petunjuk di mana pun Anda melihat label "TINDAKAN DIPERLUKAN".

Keras_Flowers_TPU (playground).ipynb

Tujuannya adalah untuk mengalahkan akurasi 75% dari model transfer learning. Model tersebut memiliki keunggulan karena telah dilatih sebelumnya pada set data yang berisi jutaan gambar, sedangkan kita hanya memiliki 3.670 gambar di sini. Setidaknya, bisakah Anda mencocokkannya?

Informasi tambahan

Berapa banyak lapisan, seberapa besar?

Memilih ukuran lapisan lebih merupakan seni daripada sains. Anda harus menemukan keseimbangan yang tepat antara memiliki terlalu sedikit dan terlalu banyak parameter (bobot dan bias). Dengan bobot yang terlalu sedikit, jaringan neural tidak dapat merepresentasikan kompleksitas bentuk bunga. Jika terlalu banyak, model dapat rentan terhadap "overfitting", yaitu mengkhususkan diri pada gambar pelatihan dan tidak dapat melakukan generalisasi. Dengan banyak parameter, model juga akan lambat dilatih. Di Keras, fungsi model.summary() menampilkan struktur dan jumlah parameter model Anda:

Layer (type)                 Output Shape              Param #   
=================================================================
conv2d (Conv2D)              (None, 192, 192, 16)      448       
_________________________________________________________________
conv2d_1 (Conv2D)            (None, 192, 192, 30)      4350      
_________________________________________________________________
max_pooling2d (MaxPooling2D) (None, 96, 96, 30)        0         
_________________________________________________________________
conv2d_2 (Conv2D)            (None, 96, 96, 60)        16260     
_________________________________________________________________
 ... 
_________________________________________________________________
global_average_pooling2d (Gl (None, 130)               0         
_________________________________________________________________
dense (Dense)                (None, 90)                11790     
_________________________________________________________________
dense_1 (Dense)              (None, 5)                 455       
=================================================================
Total params: 300,033
Trainable params: 300,033
Non-trainable params: 0
_________________________________________________________________

Beberapa tips:

• Memiliki beberapa lapisan adalah hal yang membuat jaringan neural "dalam" menjadi efektif. Untuk masalah pengenalan bunga sederhana ini, 5 hingga 10 lapisan sudah cukup.
• Gunakan filter kecil. Biasanya, filter 3x3 bagus di mana saja.
• Filter 1x1 juga dapat digunakan dan harganya murah. Filter ini tidak benar-benar "memfilter" apa pun, tetapi menghitung kombinasi linear channel. Ganti dengan filter asli. (Selengkapnya tentang "konvolusi 1x1" di bagian berikutnya.)
• Untuk masalah klasifikasi seperti ini, lakukan downsampling secara sering dengan lapisan max-pooling (atau konvolusi dengan langkah >1). Anda tidak peduli di mana bunga itu berada, yang penting bunga itu adalah mawar atau dandelion, sehingga kehilangan informasi x dan y tidak penting dan memfilter area yang lebih kecil lebih murah.
• Jumlah filter biasanya menjadi mirip dengan jumlah kelas di akhir jaringan (mengapa? lihat trik "global average pooling" di bawah). Jika Anda mengklasifikasikan ke dalam ratusan kelas, tingkatkan jumlah filter secara bertahap di lapisan berurutan. Untuk set data bunga dengan 5 kelas, pemfilteran dengan hanya 5 filter tidak akan cukup. Anda dapat menggunakan jumlah filter yang sama di sebagian besar lapisan, misalnya 32, dan menguranginya di bagian akhir.
• Lapisan Dense akhir mahal. Bobot ini dapat memiliki lebih banyak bobot daripada semua lapisan konvolusional yang digabungkan. Misalnya, meskipun dengan output yang sangat wajar dari kubus data terakhir dengan 24x24x10 titik data, lapisan padat 100 neuron akan berharga 24x24x10x100=576.000 bobot. Coba pikirkan baik-baik, atau coba penggabungan rata-rata global (lihat di bawah).

Penggabungan rata-rata global

Daripada menggunakan lapisan padat yang mahal di akhir jaringan saraf tiruan konvolusional, Anda dapat membagi "kubus" data yang masuk menjadi sebanyak yang Anda miliki kelas, menghitung rata-rata nilainya, dan memasukkannya melalui fungsi aktivasi softmax. Cara membangun head klasifikasi ini tidak memerlukan bobot. Di Keras, sintaksisnya adalah tf.keras.layers.GlobalAveragePooling2D().

Jaringan neural konvolusional mendeteksi lokasi suatu objek. Jika filter merespons kuat beberapa fitur, filter akan melakukannya di lokasi x,y tertentu. Bergantung pada tindakan yang ingin Anda lakukan, jaringan neural dapat dilatih untuk menggunakan atau menghapus data lokasi ini. Menggunakan penggabungan rata-rata global secara eksplisit akan menghapus semua data lokasi. Hal ini mungkin tidak masalah untuk pengklasifikasi bunga, tetapi mungkin tidak untuk tugas lain seperti menghitung bunga dalam gambar. Gunakan dengan hati-hati.

Solusi

Berikut adalah notebook solusi. Anda dapat menggunakannya jika mengalami masalah.

Keras_Flowers_TPU (solution).ipynb

Yang telah kita bahas

• 🤔 Bereksperimen dengan lapisan konvolusional
• 🤓 Bereksperimen dengan penggabungan maks, langkah, penggabungan rata-rata global, ...
• 😀 melakukan iterasi pada model dunia nyata dengan cepat, di TPU

Luangkan waktu sejenak untuk meninjau checklist ini dalam pikiran Anda.

10. [INFO] Arsitektur konvolusional modern

Singkatnya

Jaringan konvolusi modern, dimulai dengan " Inception" dan " Inception v2", sering menggunakan "modul" tempat berbagai lapisan konvolusi dicoba sekaligus pada input yang sama, outputnya digabungkan dan jaringan memutuskan, melalui pelatihan, lapisan mana yang paling berguna.

Ilustrasi: "modul" konvolusional. Apa yang terbaik saat ini? Lapisan max-pool yang diikuti dengan lapisan konvolusional 1x1 atau kombinasi lapisan yang berbeda? Coba semuanya, gabungkan hasilnya, dan biarkan jaringan memutuskan. Di sebelah kanan: arsitektur konvolusional " inception" yang menggunakan modul tersebut.

Di Keras, untuk membuat model dengan alur data yang dapat bercabang masuk dan keluar, Anda harus menggunakan gaya model "fungsional". Berikut ini contohnya:

l = tf.keras.layers # syntax shortcut

y = l.Conv2D(filters=32, kernel_size=3, padding='same',
             activation='relu', input_shape=[192, 192, 3])(x) # x=input image

# module start: branch out
y1 = l.Conv2D(filters=32, kernel_size=1, padding='same', activation='relu')(y)
y3 = l.Conv2D(filters=32, kernel_size=3, padding='same', activation='relu')(y)
y = l.concatenate([y1, y3]) # output now has 64 channels
# module end: concatenation

# many more layers ...

# Create the model by specifying the input and output tensors.
# Keras layers track their connections automatically so that's all that's needed.
z = l.Dense(5, activation='softmax')(y)
model = tf.keras.Model(x, z)

Trik murahan lainnya

Filter 3x3 kecil

Dalam ilustrasi ini, Anda akan melihat hasil dari dua filter 3x3 berturut-turut. Coba telusuri kembali titik data mana yang berkontribusi pada hasil: kedua filter 3x3 berturut-turut ini menghitung beberapa kombinasi wilayah 5x5. Kombinasinya tidak persis sama dengan yang akan dihitung oleh filter 5x5, tetapi patut dicoba karena dua filter 3x3 berturut-turut lebih murah daripada satu filter 5x5.

Konvolusi 1x1?

Dalam istilah matematika, konvolusi "1x1" adalah perkalian dengan konstanta, bukan konsep yang terlalu berguna. Namun, dalam jaringan saraf tiruan konvolusional, ingatlah bahwa filter diterapkan ke kubus data, bukan hanya gambar 2D. Oleh karena itu, filter "1x1" menghitung jumlah berbobot dari kolom data 1x1 (lihat ilustrasi) dan saat Anda menggesernya di seluruh data, Anda akan mendapatkan kombinasi linear dari saluran input. Hal ini sebenarnya berguna. Jika Anda menganggap saluran sebagai hasil dari operasi pemfilteran individual, misalnya filter untuk "telinga runcing", filter lain untuk "kumis", dan filter ketiga untuk "mata sipit", maka lapisan konvolusional "1x1" akan menghitung beberapa kemungkinan kombinasi linear dari fitur ini, yang mungkin berguna saat mencari "kucing". Selain itu, lapisan 1x1 menggunakan lebih sedikit bobot.

11. Squeezenet

Cara sederhana untuk menggabungkan ide-ide ini telah ditunjukkan dalam makalah"Squeezenet". Penulis menyarankan desain modul konvolusional yang sangat sederhana, hanya menggunakan lapisan konvolusional 1x1 dan 3x3.

Ilustrasi: arsitektur squeezenet berdasarkan "modul api". Model ini bergantian menggunakan lapisan 1x1 yang "memadatkan" data yang masuk dalam dimensi vertikal, diikuti dengan dua lapisan konvolusional 1x1 dan 3x3 paralel yang "memperluas" kedalaman data lagi.

Interaktif

Lanjutkan di notebook sebelumnya dan bangun jaringan neural konvolusional yang terinspirasi dari squeezenet. Anda harus mengubah kode model ke "gaya fungsional" Keras.

Keras_Flowers_TPU (playground).ipynb

Info tambahan

Untuk pelatihan ini, tingkatkan jumlah EPOCH menjadi 35.

Akan berguna untuk latihan ini jika Anda menentukan fungsi bantuan untuk modul squeezenet:

def fire(x, squeeze, expand):
  y = l.Conv2D(filters=squeeze, kernel_size=1, padding='same', activation='relu')(x)
  y1 = l.Conv2D(filters=expand//2, kernel_size=1, padding='same', activation='relu')(y)
  y3 = l.Conv2D(filters=expand//2, kernel_size=3, padding='same', activation='relu')(y)
  return tf.keras.layers.concatenate([y1, y3])

# this is to make it behave similarly to other Keras layers
def fire_module(squeeze, expand):
  return lambda x: fire(x, squeeze, expand)

# usage:
x = l.Input(shape=[192, 192, 3])
y = fire_module(squeeze=24, expand=48)(x) # typically, squeeze is less than expand
y = fire_module(squeeze=32, expand=64)(y)
...
model = tf.keras.Model(x, y)

Tujuan kali ini adalah mencapai akurasi 80%.

Hal-hal yang dapat dicoba

Mulai dengan satu lapisan konvolusional, lalu ikuti dengan "fire_modules", bergantian dengan lapisan MaxPooling2D(pool_size=2). Anda dapat bereksperimen dengan 2 hingga 4 lapisan max pooling dalam jaringan dan juga dengan 1, 2, atau 3 modul fire berurutan di antara lapisan max pooling.

Dalam modul api, parameter "squeeze" biasanya harus lebih kecil daripada parameter "expand". Parameter ini sebenarnya adalah jumlah filter. Nilai ini biasanya berkisar antara 8 hingga 196. Anda dapat bereksperimen dengan arsitektur yang jumlah filternya meningkat secara bertahap melalui jaringan, atau arsitektur sederhana yang semua modul apinya memiliki jumlah filter yang sama.

Berikut ini contohnya:

x = tf.keras.layers.Input(shape=[*IMAGE_SIZE, 3]) # input is 192x192 pixels RGB

y = tf.keras.layers.Conv2D(kernel_size=3, filters=32, padding='same', activation='relu')(x)
y = fire_module(24, 48)(y)
y = tf.keras.layers.MaxPooling2D(pool_size=2)(y)
y = fire_module(24, 48)(y)
y = tf.keras.layers.MaxPooling2D(pool_size=2)(y)
y = fire_module(24, 48)(y)
y = tf.keras.layers.GlobalAveragePooling2D()(y)
y = tf.keras.layers.Dense(5, activation='softmax')(y)

model = tf.keras.Model(x, y)

Pada titik ini, Anda mungkin menyadari bahwa eksperimen Anda tidak berjalan dengan baik dan tujuan akurasi 80% tampaknya sulit dicapai. Saatnya melakukan beberapa trik murah lainnya.

Normalisasi Batch

Batch norm akan membantu mengatasi masalah konvergensi yang Anda alami. Akan ada penjelasan mendetail tentang teknik ini di workshop berikutnya. Untuk saat ini, gunakan sebagai bantuan "ajaib" black box dengan menambahkan baris ini setelah setiap lapisan konvolusional di jaringan Anda, termasuk lapisan di dalam fungsi fire_module:

y = tf.keras.layers.BatchNormalization(momentum=0.9)(y)
# please adapt the input and output "y"s to whatever is appropriate in your context

Parameter momentum harus dikurangi dari nilai defaultnya 0,99 menjadi 0,9 karena set data kita kecil. Lupakan detail ini untuk saat ini.

Augmentasi data

Anda akan mendapatkan beberapa poin persentase lagi dengan menambah data menggunakan transformasi sederhana seperti pembalikan kiri-kanan perubahan saturasi:

Hal ini sangat mudah dilakukan di TensorFlow dengan tf.data.Dataset API. Tentukan fungsi transformasi baru untuk data Anda:

def data_augment(image, label):
    image = tf.image.random_flip_left_right(image)
    image = tf.image.random_saturation(image, lower=0, upper=2)
    return image, label

Kemudian, gunakan dalam transformasi data akhir Anda (sel "training and validation datasets", fungsi "get_batched_dataset"):

dataset = dataset.repeat() # existing line
# insert this
if augment_data:
  dataset = dataset.map(data_augment, num_parallel_calls=AUTO)
dataset = dataset.shuffle(2048) # existing line

Jangan lupa untuk membuat augmentasi data menjadi opsional dan menambahkan kode yang diperlukan untuk memastikan hanya set data pelatihan yang di-augmentasi. Tidak ada gunanya memperbesar set data validasi.

Akurasi 80% dalam 35 epoch kini dapat dicapai.

Solusi

Berikut adalah notebook solusi. Anda dapat menggunakannya jika mengalami masalah.

Keras_Flowers_TPU_squeezenet.ipynb

Yang telah kita bahas

• 🤔 Model "gaya fungsional" Keras
• 🤓 Arsitektur Squeezenet
• 🤓 Augmentasi data dengan tf.data.dataset

Luangkan waktu sejenak untuk meninjau checklist ini dalam pikiran Anda.

12. Xception yang di-fine-tune

Konvolusi yang dapat dipisahkan

Cara lain untuk menerapkan lapisan konvolusi baru-baru ini menjadi populer: konvolusi yang dapat dipisahkan menurut kedalaman. Saya tahu, namanya cukup rumit, tetapi konsepnya cukup sederhana. Lapisan ini diimplementasikan di TensorFlow dan Keras sebagai tf.keras.layers.SeparableConv2D.

Konvolusi yang dapat dipisahkan juga menjalankan filter pada gambar, tetapi menggunakan serangkaian bobot yang berbeda untuk setiap saluran gambar input. Setelah itu, dilakukan "konvolusi 1x1", serangkaian perkalian titik yang menghasilkan jumlah berbobot dari saluran yang difilter. Dengan bobot baru setiap kali, sebanyak mungkin kombinasi berbobot dari saluran dihitung sesuai kebutuhan.

Ilustrasi: konvolusi yang dapat dipisahkan. Fase 1: konvolusi dengan filter terpisah untuk setiap saluran. Fase 2: penggabungan saluran secara linear. Diulang dengan kumpulan bobot baru hingga jumlah saluran output yang diinginkan tercapai. Fase 1 juga dapat diulang, dengan bobot baru setiap kali, tetapi dalam praktiknya jarang dilakukan.

Konvolusi yang dapat dipisahkan digunakan dalam arsitektur jaringan konvolusional terbaru: MobileNetV2, Xception, EfficientNet. Ngomong-ngomong, MobileNetV2 adalah model yang Anda gunakan untuk pemelajaran transfer sebelumnya.

Operasi ini lebih murah daripada konvolusi reguler dan terbukti sama efektifnya dalam praktiknya. Berikut adalah jumlah bobot untuk contoh yang diilustrasikan di atas:

Lapisan konvolusional: 4 x 4 x 3 x 5 = 240

Lapisan konvolusional yang dapat dipisahkan: 4 x 4 x 3 + 3 x 5 = 48 + 15 = 63

Pembaca dapat menghitung jumlah perkalian yang diperlukan untuk menerapkan setiap gaya lapisan konvolusional dengan cara yang serupa. Konvolusi yang dapat dipisahkan lebih kecil dan jauh lebih efektif secara komputasi.

Interaktif

Mulai ulang dari notebook playground "transfer learning", tetapi kali ini pilih Xception sebagai model terlatih. Xception hanya menggunakan konvolusi yang dapat dipisahkan. Biarkan semua bobot dapat dilatih. Kami akan menyempurnakan bobot yang telah dilatih sebelumnya pada data kami, bukan menggunakan lapisan yang telah dilatih sebelumnya.

Keras Flowers transfer learning (playground).ipynb

Tujuan: akurasi > 95% (Ya, sungguh, ini mungkin!)

Karena ini adalah latihan terakhir, Anda akan memerlukan lebih banyak kode dan pekerjaan data science.

Info tambahan tentang penyesuaian

Xception tersedia dalam model terlatih standar di tf.keras.application.* Jangan lupa untuk membuat semua bobot dapat dilatih kali ini.

pretrained_model = tf.keras.applications.Xception(input_shape=[*IMAGE_SIZE, 3],
                                                  include_top=False)
pretrained_model.trainable = True

Untuk mendapatkan hasil yang baik saat menyesuaikan model, Anda harus memperhatikan kecepatan pembelajaran dan menggunakan jadwal kecepatan pembelajaran dengan periode penyesuaian. Seperti ini:

Memulai dengan kecepatan pembelajaran standar akan mengganggu bobot model yang telah dilatih sebelumnya. Memulai secara progresif akan mempertahankan data tersebut hingga model telah terhubung ke data Anda dan dapat memodifikasinya dengan cara yang wajar. Setelah ramp, Anda dapat melanjutkan dengan laju pembelajaran yang konstan atau menurun secara eksponensial.

Di Keras, laju pembelajaran ditentukan melalui callback yang memungkinkan Anda menghitung laju pembelajaran yang sesuai untuk setiap epoch. Keras akan meneruskan laju pembelajaran yang benar ke pengoptimal untuk setiap epoch.

def lr_fn(epoch):
  lr = ...
  return lr

lr_callback = tf.keras.callbacks.LearningRateScheduler(lr_fn, verbose=True)

model.fit(..., callbacks=[lr_callback])

Solusi

Berikut adalah notebook solusi. Anda dapat menggunakannya jika mengalami masalah.

07_Keras_Flowers_TPU_xception_fine_tuned_best.ipynb

Yang telah kita bahas

• 🤔 Konvolusi yang dapat dipisahkan menurut kedalaman
• 🤓 Jadwal kecepatan pembelajaran
• 😈 Melakukan fine-tuning model terlatih.

Luangkan waktu sejenak untuk meninjau checklist ini dalam pikiran Anda.

13. Selamat!

Anda telah membangun jaringan neural konvolusional modern pertama dan melatihnya hingga akurasi 90% +, melakukan iterasi pada proses pelatihan berturut-turut hanya dalam beberapa menit berkat TPU.

TPU dalam praktik

TPU dan GPU tersedia di Vertex AI Google Cloud:

• Di Deep Learning VM
• Di Vertex AI Notebooks
• Di tugas Vertex AI Training Jobs

Terakhir, kami menyambut masukan dengan tangan terbuka. Beri tahu kami jika Anda melihat sesuatu yang tidak beres 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