ConvNets yang Keras dan modern, di TPU

1. Ringkasan

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

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

Yang akan Anda pelajari

• Menggunakan Keras dan Tensor Processing Unit (TPU) untuk membangun model kustom Anda lebih cepat.
• Untuk menggunakan tf.data.Dataset API dan format TFRecord untuk memuat data pelatihan secara efisien.
• Untuk menipu 🎬, gunakan pemelajaran transfer, bukan membangun model Anda sendiri.
• Untuk menggunakan gaya model Keras berurutan dan fungsional.
• Untuk membangun pengklasifikasi Keras Anda sendiri dengan lapisan softmax dan loss entropi silang.
• Untuk men-tuning model dengan pilihan lapisan konvolusional yang baik.
• Untuk mengeksplorasi ide arsitektur konvnet modern seperti modul, penggabungan rata-rata global, dll.
• Untuk membuat konvnet modern yang sederhana menggunakan arsitektur Squeezenet.

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. Anda dapat menjalankannya dari Chromebook. Buka file di bawah, lalu jalankan sel untuk memahami notebook Colab.

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 "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

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 yang lebih besar yang disebut "pod TPU" hingga 2048 core. Hardware tambahan dapat digunakan untuk mempercepat pelatihan dengan meningkatkan ukuran batch pelatihan.

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.

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

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 besar 128x128, 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 lain. 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 panggil TPUClusterResolver dengan parameter eksplisit: TPUClusterResolver(tp_uname, zone, project)
• TPUStrategy adalah 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.fit mengharapkan 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.Dataset API 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_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), 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 kecanggihan 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

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 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. [INFO] Pengklasifikasi jaringan neural 101

Ringkasan singkat

Jika semua istilah yang dicetak tebal di paragraf berikutnya sudah diketahui, Anda dapat melanjutkan ke latihan berikutnya. Jika Anda baru mulai mempelajari deep learning, selamat datang, dan silakan terus membaca.

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

Untuk model yang dibangun sebagai urutan lapisan Keras menawarkan Sequential API. Misalnya, pengklasifikasi gambar yang menggunakan tiga lapisan padat dapat ditulis dalam 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. Terdiri dari "neuron" diatur berlapis-lapis. Lapisan pertama memproses data input dan memberikan outputnya ke lapisan lain. Hal ini disebut "padat" karena setiap neuron terhubung ke semua neuron di lapisan sebelumnya.

Anda bisa memasukkan gambar ke dalam jaringan seperti itu dengan meratakan nilai RGB dari semua pikselnya menjadi vektor yang panjang dan menggunakannya sebagai input. Ini bukanlah teknik terbaik untuk pengenalan citra, tetapi kami akan meningkatkannya nanti.

Neuron, aktivasi, RELU

"neuron" menghitung jumlah tertimbang dari semua {i>input<i}-nya, menambahkan nilai yang disebut "bias" dan memberikan hasil melalui "fungsi aktivasi". Bobot dan bias pada awalnya tidak diketahui. Parameter tersebut akan diinisialisasi secara acak dan "learned" (dipelajari) dengan melatih jaringan neural pada banyak data yang diketahui.

Fungsi aktivasi yang paling populer disebut RELU untuk Unit Linear Terarah. 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 kami mengklasifikasikan bunga menjadi 5 kategori (mawar, tulip, dandelion, daisy, bunga matahari). Neuron di lapisan perantara diaktifkan menggunakan fungsi aktivasi RELU klasik. Pada lapisan terakhir, kita ingin menghitung angka antara 0 dan 1 yang mewakili probabilitas bunga ini adalah mawar, tulip, dan seterusnya. Untuk itu, kita akan menggunakan fungsi aktivasi yang disebut "softmax".

Penerapan softmax pada vektor dilakukan dengan mengambil eksponensial dari setiap elemen dan kemudian menormalisasi vektor tersebut, biasanya menggunakan norma L1 (jumlah nilai absolut) sehingga nilainya bertambah hingga 1 dan dapat diinterpretasikan sebagai probabilitas.

Mengapa "softmax" yang disebut {i>softmax<i}? Eksponensial adalah fungsi yang meningkat tajam. 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 class pemenang, "maks", tetapi mempertahankan urutan relatif asli dari nilai-nilainya, sehingga disebut "soft".

Kerugian entropi silang

Sekarang setelah jaringan neural kita menghasilkan prediksi dari gambar input, kita perlu mengukur seberapa bagus prediksinya, yaitu jarak antara apa yang ditunjukkan jaringan kepada kita dan jawaban yang benar, yang sering disebut "label". Ingatlah bahwa kita memiliki label yang benar untuk semua gambar dalam {i>dataset<i}.

Semua jarak dapat digunakan, tetapi untuk masalah klasifikasi, apa yang disebut "jarak entropi silang" adalah yang paling efektif. Kita akan menyebutnya {i>error<i} atau "{i>loss<i}" {i>function<i}:

"One-hot" pengkodean berarti Anda merepresentasikan label "3) dandelion" menggunakan vektor dari 5 nilai, semua angka nol kecuali untuk nilai ke-3 yaitu 1. Vektor ini merepresentasikan 100% kemungkinan untuk menjadi dandelion. Jaringan neural kita juga menghasilkan prediksinya sebagai vektor dari 5 nilai probabilitas. Mudah untuk dibandingkan.

Penurunan gradien

"Pelatihan" jaringan neural sebenarnya berarti menggunakan gambar dan label pelatihan untuk menyesuaikan bobot dan bias guna meminimalkan fungsi kerugian entropi silang. Begini cara kerjanya.

Entropi silang adalah fungsi bobot, bias, piksel dari gambar pelatihan dan kelasnya yang diketahui.

Jika kita menghitung turunan parsial dari entropi silang secara relatif terhadap semua bobot dan semua bias, kita memperoleh "gradien", yang dihitung untuk gambar, label, dan nilai sekarang dari bobot dan bias. Ingatlah bahwa kita dapat memiliki jutaan bobot dan bias sehingga menghitung gradien terdengar seperti pekerjaan yang berat. Untungnya, Tensorflow saja yang melakukannya untuk kita. Properti matematika dari gradien adalah bahwa gradien tersebut menunjuk "ke atas". Karena kita ingin menuju tempat yang nilai entropi silangnya rendah, kita melakukan ke arah yang berlawanan. Kita memperbarui bobot dan bias dengan menggunakan sebagian kecil dari gradien. Kemudian kita melakukan hal yang sama berulang kali menggunakan batch gambar dan label pelatihan berikutnya, dalam satu loop pelatihan. Mudah-mudahan, ini konvergensi ke tempat 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 pada setiap iterasi. Ini seperti mencoba mencapai dasar lembah sambil memakai sepatu bot tujuh liga. Anda akan melompat dari satu sisi lembah ke sisi lainnya. Untuk sampai ke bagian bawah, Anda perlu melakukan langkah-langkah yang lebih kecil, yaitu hanya gunakan sebagian kecil dari gradien, biasanya dalam rentang 1/1000. Bagian ini disebut "kecepatan pembelajaran".

Pengelompokan mini dan momentum

Anda dapat menghitung gradien hanya pada satu gambar contoh dan segera memperbarui bobot dan bias, tetapi melakukan hal ini pada sekumpulan, misalnya, 128 gambar memberikan gradien yang lebih mewakili batasan yang diberlakukan oleh gambar contoh yang berbeda dan karenanya cenderung menyatu menuju solusi lebih cepat. Ukuran tumpukan mini adalah parameter yang dapat disesuaikan.

Teknik ini, kadang-kadang disebut "penurunan gradien stokastik" memiliki manfaat lain yang lebih pragmatis: bekerja dengan batch juga berarti bekerja dengan matriks yang lebih besar dan ini biasanya lebih mudah dioptimalkan pada GPU dan TPU.

Konvergensi masih bisa sedikit kacau dan bahkan bisa berhenti jika vektor gradien semua nol. Apakah itu berarti kita telah menemukan minimum? Tidak selalu. Komponen gradien dapat bernilai nol pada nilai minimum atau maksimum. Dengan vektor gradien dengan jutaan elemen, jika semuanya bernilai nol, maka probabilitas bahwa setiap nol sesuai dengan nilai minimum dan tidak satu pun dari mereka hingga titik maksimum cukup kecil. Dalam ruang dari berbagai dimensi, saddle point cukup umum dan kita tidak ingin berhenti di sini.

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

Solusinya adalah menambahkan beberapa momentum pada algoritme pengoptimalan sehingga algoritme tersebut dapat berlayar melewati titik pelana tanpa berhenti.

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

Glosarium

batch atau mini-batch: pelatihan selalu dilakukan pada batch data dan label pelatihan. Tindakan ini akan membantu algoritma konvergensi. "Batch" dimensi biasanya adalah dimensi pertama dari tensor data. Misalnya, tensor 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 yang setiap neuronnya terhubung ke semua neuron di lapisan sebelumnya.

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

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

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

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

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

neuron: menghitung jumlah input tertimbang, menambahkan bias, dan memberikan hasilnya melalui fungsi aktivasi.

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

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

sigmoid: fungsi aktivasi lain yang sebelumnya populer dan masih berguna dalam kasus tertentu.

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

tensor: "tensor" seperti matriks tetapi dengan jumlah dimensi yang arbitrer. Tensor 1-dimensi adalah vektor. Tensor 2 dimensi adalah sebuah matriks. Dan kemudian Anda dapat memiliki tensor dengan 3, 4, 5 atau lebih dimensi.

7. Pemelajaran Transfer

Untuk masalah klasifikasi gambar, lapisan padat mungkin tidak cukup. Kita harus belajar tentang lapisan konvolusional dan berbagai cara untuk mengaturnya.

Tapi kita juga bisa mengambil jalan pintas! Ada jaringan neural konvolusional terlatih yang bisa didownload. Anda dapat memotong lapisan terakhirnya, kepala klasifikasi softmax, dan menggantinya dengan milik Anda. Semua bobot dan bias yang dilatih tetap seperti itu, Anda hanya melatih ulang lapisan softmax yang Anda tambahkan. Teknik ini disebut pemelajaran transfer dan sangat bagus, teknik ini berhasil asalkan set data tempat jaringan neural yang dilatih sebelumnya "cukup dekat" dengan milik Anda.

Langsung

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

Keras Flowers transfer learning (playground).ipynb

Informasi tambahan

Dengan pemelajaran transfer, Anda mendapatkan manfaat dari arsitektur jaringan neural konvolusional canggih yang dikembangkan oleh peneliti top dan dari pelatihan awal pada set data gambar yang besar. Dalam kasus ini, kita akan mentransfer pemelajaran dari jaringan yang dilatih di ImageNet, yaitu database gambar yang berisi banyak tanaman dan pemandangan luar ruangan, yang cukup dekat dengan bunga.

Ilustrasi: menggunakan jaringan neural konvolusional kompleks, yang sudah dilatih, sebagai kotak hitam, melatih ulang kepala klasifikasi saja. Inilah pemelajaran transfer. Kita akan melihat bagaimana pengaturan lapisan konvolusional yang rumit ini bekerja nanti. Untuk saat ini, masalahnya ada di tangan orang lain.

Transfer pembelajaran di Keras

Di Keras, Anda dapat membuat instance model terlatih dari koleksi tf.keras.applications.*. MobileNet V2 misalnya adalah arsitektur konvolusional yang sangat baik dengan ukuran yang tetap wajar. Dengan memilih include_top=False, Anda mendapatkan model terlatih tanpa lapisan softmax akhirnya sehingga Anda dapat menambahkan model 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. Fungsi ini membekukan bobot dan bias model terlatih sehingga Anda hanya melatih lapisan softmax. Proses ini biasanya melibatkan bobot yang relatif sedikit dan dapat dilakukan dengan cepat dan tanpa memerlukan {i>dataset<i} yang sangat besar. Namun, jika Anda memiliki banyak data, pemelajaran transfer dapat berfungsi 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. Itu sebabnya kita perlu meratakan. Di bab berikutnya, saat kita mempelajari arsitektur konvolusional, kita akan menjelaskan format data yang dikembalikan oleh lapisan konvolusional.

Akurasi Anda akan mendekati 75% dengan pendekatan ini.

Solusi

Berikut notebook solusinya. Anda dapat menggunakannya jika mengalami kesulitan.

Keras Flowers transfer learning (solution).ipynb

Yang telah kita bahas

• 🤔 Cara menulis pengklasifikasi di Keras
• 🤓 dikonfigurasikan dengan lapisan terakhir softmax, dan kerugian entropi silang
• 🎬 Pemelajaran transfer
• 🤔 Melatih model pertama Anda
• 🧐 Setelah kehilangan dan akurasinya selama pelatihan

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

8. [INFO] Jaringan neural konvolusional

Ringkasan singkat

Jika semua istilah yang dicetak tebal di paragraf berikutnya sudah diketahui, Anda dapat melanjutkan ke latihan berikutnya. Jika Anda baru mulai mempelajari jaringan neural konvolusional, harap baca terus.

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

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 menggunakan stride >1 atau dengan operasi max-pooling. Kedalaman output (nb saluran) disesuaikan dengan menggunakan lebih banyak atau lebih sedikit filter.

Berikut adalah 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'])

Jaringan neural konvolusional

Dalam lapisan jaringan konvolusional, satu "neuron" melakukan penjumlahan piksel di atasnya yang diberi bobot, hanya di seluruh wilayah kecil gambar. Fungsi ini menambahkan bias dan memasukkan jumlah tersebut melalui fungsi aktivasi, sama seperti yang dilakukan neuron dalam lapisan padat biasa. Operasi ini kemudian diulang di seluruh gambar menggunakan bobot yang sama. Ingatlah bahwa di lapisan padat, setiap neuron memiliki bobotnya sendiri. Di sini, satu "patch" bobot bergeser melalui gambar secara dua arah ("konvolusi"). Output memiliki nilai sebanyak piksel dalam gambar (tetapi beberapa padding diperlukan di bagian tepinya). Ini adalah operasi penyaringan, dengan menggunakan filter dengan bobot 4 x 4 x 3=48.

Namun, 48 bobot tidak akan cukup. Untuk menambahkan lebih banyak derajat kebebasan, kita mengulangi operasi yang sama dengan set berat baru. Tindakan ini akan menghasilkan serangkaian output filter baru. Sebut saja "channel" output secara analogi dengan saluran R,G,B pada gambar input.

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

Ilustrasi: jaringan neural konvolusional mengubah "kubus" data ke dalam "kubus" lain. yang besar.

Konvolusi berjalan, penggabungan maksimum

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

• Langkah konvolusi: filter geser seperti di atas tetapi dengan langkah >1
• Pengumpulan maksimum: jendela geser yang menerapkan operasi MAX (biasanya pada patch 2x2, diulang setiap 2 piksel)

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

"Pengumpulan maksimum" bisa membantu kita memahami secara intuitif cara jaringan konvolusional beroperasi: jika Anda berasumsi bahwa selama pelatihan, tambalan bobot berkembang menjadi filter yang mengenali bentuk dasar (garis horizontal dan vertikal, kurva, ...) maka salah satu cara untuk meringkas informasi yang berguna adalah dengan mempertahankan lapisan, output tempat sebuah bentuk dikenali dengan intensitas maksimum. Dalam praktiknya, dalam lapisan neuron max-pool diproses dalam kelompok 2x2 dan hanya nilai maksimal yang dipertahankan.

Pengklasifikasi lokal

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

Ilustrasi: pengklasifikasi gambar yang menggunakan lapisan konvolusional dan softmax. Sistem ini menggunakan filter 3x3 dan 1x1. Lapisan maxpool mengambil jumlah maksimal grup titik data 2x2. Head klasifikasi diimplementasikan dengan lapisan padat dengan aktivasi softmax.

Di Keras

Stack konvolusional yang diilustrasikan di atas dapat ditulis dalam 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": padding dengan angka nol untuk menghasilkan output dengan lebar/tinggi yang sama dengan input
• "valid": tidak ada padding, hanya gunakan piksel sungguhan

9. Konvnet kustom Anda

Langsung

Mari kita buat dan latih jaringan neural konvolusional dari awal. Menggunakan TPU akan memungkinkan kami melakukan iterasi dengan sangat cepat. Buka notebook berikut, jalankan sel (Shift-ENTER), lalu ikuti petunjuk di mana pun Anda melihat "DIPERLUKAN KERJA" label.

Keras_Flowers_TPU (playground).ipynb

Tujuannya adalah mengalahkan akurasi model pemelajaran transfer sebesar 75%. Model tersebut diuntungkan karena telah dilatih sebelumnya dengan set data yang berisi jutaan gambar, sedangkan di sini kita hanya memiliki 3670 gambar. Bisakah Anda setidaknya 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. Dengan terlalu banyak, pemodelan bisa menjadi rentan terhadap "overfitting", yaitu mengkhususkan diri dalam 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 "deep" neural buatan. Untuk masalah pengenalan bunga sederhana ini, 5 hingga 10 lapisan adalah hal yang masuk akal.
• Gunakan filter kecil. Biasanya filter 3x3 bagus di mana saja.
• Filter 1x1 juga dapat digunakan dan murah. Mereka tidak benar-benar "memfilter" apa pun kecuali komputasi kombinasi linier dari saluran. Ganti dengan filter asli. (Selengkapnya tentang "konvolusi 1x1" di bagian berikutnya.)
• Untuk masalah klasifikasi seperti ini, lakukan pengurangan sampel secara rutin dengan lapisan penggabungan maksimum (atau konvolusi dengan langkah >1). Anda tidak peduli di mana bunganya berada, hanya saja bunga itu adalah mawar atau dandelion sehingga kehilangan informasi x dan y tidak penting dan memfilter area yang lebih kecil menjadi lebih murah.
• Jumlah filter biasanya menjadi mirip dengan jumlah class di akhir jaringan (mengapa? lihat trik "penggabungan rata-rata global" di bawah). Jika Anda mengklasifikasikan ke dalam ratusan class, tingkatkan jumlah filter secara bertahap pada lapisan yang berurutan. Untuk set data bunga dengan 5 class, pemfilteran hanya dengan 5 filter tidak akan cukup. Anda dapat menggunakan jumlah filter yang sama di sebagian besar lapisan, misalnya 32, lalu menguranginya menjelang akhir.
• Lapisan padat akhir mahal. Lapisan ini dapat memiliki lebih banyak bobot daripada gabungan semua lapisan konvolusional. Misalnya, bahkan dengan output yang sangat wajar dari kubus data terakhir 24x24x10 titik data, lapisan padat 100 neuron akan berharga 24x24x10x100=576.000 bobot !!! Pertimbangkan dengan baik, atau coba penggabungan rata-rata global (lihat di bawah).

Penggabungan rata-rata global

Alih-alih menggunakan lapisan padat yang mahal di akhir jaringan neural konvolusional, Anda dapat membagi data yang masuk dengan nama "kubus" ke dalam sebanyak mungkin bagian dari class Anda, menghitung nilai rata-ratanya, dan memasukkan nilai tersebut melalui fungsi aktivasi softmax. Cara pembuatan head klasifikasi ini memerlukan bobot 0. Di Keras, sintaksisnya adalah tf.keras.layers.GlobalAveragePooling2D().

Jaringan neural konvolusional mendeteksi lokasi sesuatu. Ketika filter sangat merespons beberapa fitur, filter akan melakukannya di lokasi x,y tertentu. Bergantung pada apa yang ingin Anda lakukan, jaringan neural dapat dilatih untuk menggunakan atau membuang data lokasi ini. Menggunakan penggabungan rata-rata global akan secara eksplisit menghapus semua data lokasi. Tindakan tersebut mungkin tidak masalah untuk pengklasifikasi bunga, tetapi mungkin tidak untuk tugas lain seperti misalnya menghitung bunga dalam gambar. Gunakan dengan hati-hati.

Solusi

Berikut notebook solusinya. Anda dapat menggunakannya jika mengalami kesulitan.

Keras_Flowers_TPU (solution).ipynb

Yang telah kita bahas

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

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

10. [INFO] Arsitektur konvolusional modern

Ringkasan singkat

Jaringan konvolusi modern, dimulai dengan " Insepsi" dan " Inception v2", sering kali menggunakan "modul" di mana lapisan konvolusional yang berbeda dicoba sekaligus pada input yang sama, {i>output-<i}nya digabungkan dan jaringan memutuskan, melalui pelatihan, lapisan mana yang paling berguna.

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

Di Keras, untuk membuat model tempat aliran data dapat bercabang ke dalam dan ke luar, Anda harus menggunakan fungsi "fungsional" gaya model dasar. 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 murah lainnya

Filter 3x3 kecil

Dalam ilustrasi ini, Anda melihat hasil dari dua filter 3x3 berturut-turut. Cobalah untuk melacak kembali titik data mana yang berkontribusi pada hasil: dua filter 3x3 berturut-turut ini menghitung beberapa kombinasi wilayah 5x5. Ini bukan kombinasi yang sama persis dengan yang akan dihitung oleh filter 5x5 tetapi perlu dicoba karena dua filter 3x3 berturut-turut lebih murah daripada satu filter 5x5.

Konvolusi 1x1?

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

11. Squeezenet

Cara sederhana untuk menyatukan ide-ide ini telah ditampilkan di "Squeezenet" kertas. Penulis menyarankan desain modul konvolusional yang sangat sederhana, hanya menggunakan lapisan konvolusional 1x1 dan 3x3.

Ilustrasi: arsitektur squeezenet berdasarkan "modul kebakaran". Mereka bergantian lapisan 1x1 yang "memeras" data yang masuk dalam dimensi vertikal diikuti oleh dua lapisan konvolusional 1x1 dan 3x3 paralel yang "meluas" kedalaman datanya.

Langsung

Lanjutkan di notebook sebelumnya dan bangun jaringan neural konvolusional yang terinspirasi squeezenet. Anda harus mengubah kode model menjadi "functional style" Keras.

Keras_Flowers_TPU (playground).ipynb

Info tambahan

Untuk pelatihan ini, naikkan jumlah EPOCH menjadi 35.

Akan sangat berguna untuk latihan ini untuk menentukan fungsi bantuan di 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)

Target kali ini adalah mencapai akurasi 80%.

Yang perlu 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 penggabungan maksimum dalam jaringan dan juga dengan 1, 2 atau 3 modul api berturut-turut di antara lapisan penggabungan maksimum.

Dalam modul api, "{i>squeeze<i}" biasanya harus lebih kecil daripada parameter "expand" . Parameter ini sebenarnya adalah jumlah filter. Biasanya, rentangnya dapat berkisar dari 8 hingga 196. Anda dapat bereksperimen dengan arsitektur yang jumlah filternya meningkat secara bertahap melalui jaringan, atau arsitektur sederhana yang semua modul kebakarannya 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 melihat bahwa eksperimen tidak berjalan dengan baik dan tujuan akurasi 80% tampak masih jauh. Saatnya mencoba beberapa trik murah lainnya.

Normalisasi Batch

Norma batch akan membantu mengatasi masalah konvergensi yang Anda alami. Akan ada penjelasan terperinci tentang teknik ini pada workshop berikutnya, untuk saat ini, silakan gunakan itu sebagai "ajaib" kotak hitam helper 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 diturunkan dari nilai default 0,99 menjadi 0,9 karena dataset kita kecil. Untuk sekarang, abaikan detail ini.

Pengayaan data

Anda akan mendapatkan beberapa poin persentase lagi dengan meningkatkan data dengan transformasi yang mudah seperti membalik 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 ("set data pelatihan dan validasi", 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 ditingkatkan. Tidak masuk akal untuk menambah set data validasi.

Akurasi 80% dalam 35 epoch kini akan dapat dicapai.

Solusi

Berikut notebook solusinya. Anda dapat menggunakannya jika mengalami kesulitan.

Keras_Flowers_TPU_squeezenet.ipynb

Yang telah kita bahas

• 🤔 Keras "functional style" model
• 🤓 Arsitektur Squeezenet
• 🤓 Pengayaan data dengan tf.data.datset

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

12. Xception disesuaikan

Konvolusi yang dapat dipisahkan

Cara lain untuk menerapkan lapisan konvolusional telah populer baru-baru ini: konvolusi yang dapat dipisahkan kedalamannya. Saya tahu, tidak masuk akal, tetapi konsepnya cukup sederhana. Class ini diimplementasikan di Tensorflow dan Keras sebagai tf.keras.layers.SeparableConv2D.

Convolution yang dapat dipisahkan juga menjalankan filter pada gambar, tetapi menggunakan set bobot yang berbeda untuk setiap saluran gambar input. Hal ini diikuti dengan "konvolusi 1x1", serangkaian produk titik yang menghasilkan jumlah berbobot saluran yang difilter. Dengan bobot baru setiap saat, sebanyak mungkin rekombinasi berbobot saluran dihitung sesuai kebutuhan.

Ilustrasi: konvolusi yang dapat dipisahkan. Fase 1: konvolusi dengan filter terpisah untuk setiap saluran Fase 2: rekombinasi linear saluran. Diulangi dengan satu set bobot baru hingga jumlah saluran output yang diinginkan tercapai. Fase 1 juga dapat diulang, dengan bobot baru setiap waktu, tetapi dalam praktiknya jarang sekali.

konvolusi terpisah digunakan dalam arsitektur jaringan konvolusional terbaru: MobileNetV2, Xception, EfficientNet. Ngomong-ngomong, MobileNetV2 adalah alat yang Anda gunakan untuk pemelajaran transfer sebelumnya.

Mereka lebih murah daripada konvolusi reguler dan telah 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

Latihan ini diberikan sebagai latihan bagi pembaca untuk menghitung lebih dari jumlah perkalian yang diperlukan untuk menerapkan setiap gaya skala lapisan konvolusional dengan cara yang sama. konvolusi terpisah lebih kecil dan jauh lebih efektif secara komputasi.

Langsung

Memulai ulang dari "pembelajaran transfer" playground, tetapi kali ini pilih Xception sebagai model terlatih. Xception hanya menggunakan konvolusi yang dapat dipisahkan. Biarkan semua bobot dapat dilatih. Kita akan menyesuaikan bobot terlatih pada data kita, bukan menggunakan lapisan terlatih seperti itu.

Keras Flowers transfer learning (playground).ipynb

Sasaran: akurasi > 95% (Tidak, serius, itu mungkin!)

Ujian ini adalah latihan terakhir, dan latihan ini membutuhkan lebih banyak kode dan pekerjaan sains data.

Info tambahan tentang fine-tuning

Xception tersedia dalam model standar terlatih di tf.keras.application.* Jangan lupa untuk membiarkan 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 melakukan fine-tuning 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 akan mempertahankannya secara bertahap hingga model yang telah menempel pada data Anda dapat mengubahnya dengan cara yang logis. Setelah ramp, Anda dapat melanjutkan dengan kecepatan pemelajaran yang konstan atau menurun secara eksponensial.

Di Keras, kecepatan pemelajaran ditentukan melalui callback yang memungkinkan Anda menghitung kecepatan pemelajaran yang sesuai untuk setiap epoch. Keras akan meneruskan kecepatan pemelajaran 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 notebook solusinya. Anda dapat menggunakannya jika mengalami kesulitan.

07_Keras_Flowers_TPU_xception_fine_tuned_best.ipynb

Yang telah kita bahas

• 🤔 Konvolusi yang dapat dipisahkan kedalaman
• 🤓 Jadwal kecepatan pembelajaran
• 📈 Meningkatkan kualitas model terlatih.

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

13. Selamat!

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

Penggunaan TPU

TPU dan GPU tersedia di Vertex AI Google Cloud:

• Di Deep Learning VM
• Di Notebooks Vertex AI
• Di tugas Tugas Pelatihan Vertex AI

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].

Penulis: Martin Görner Twitter: @martin_gorner