Jaringan neural konvolusional, dengan Keras dan TPU

1. Ringkasan

Dalam lab ini, Anda akan mempelajari cara menyusun lapisan konvolusi menjadi model jaringan saraf yang dapat mengenali bunga. Kali ini, Anda akan membangun model sendiri dari awal dan menggunakan kecanggihan TPU untuk melatihnya dalam hitungan detik dan mengulangi desainnya.

Lab ini mencakup penjelasan teoretis yang diperlukan tentang jaringan neural konvolusional serta merupakan titik awal yang bagus bagi developer yang mempelajari deep learning.

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

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

Yang akan Anda pelajari

• Untuk membangun pengklasifikasi gambar konvolusional menggunakan model Keras Sequential.
• Untuk melatih model Keras Anda di TPU
• Untuk menyesuaikan model Anda dengan pilihan lapisan konvolusi yang baik.

Masukan

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

2. Memulai cepat Google Colaboratory

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

Anda dapat membuka notebook contoh ini dan menjalankan beberapa sel untuk memahami Colaboratory.

Welcome to Colab.ipynb

Memilih backend TPU

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

Eksekusi notebook

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

Daftar isi

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

Sel tersembunyi

Beberapa sel hanya akan menampilkan judulnya. Ini adalah fitur notebook khusus Colab. Anda dapat mengkliknya dua kali untuk melihat kode di dalamnya, tetapi biasanya ini tidak terlalu menarik. Biasanya mendukung atau fungsi visualisasi. Anda tetap 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

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

Kode untuk melatih model 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=...)

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

Mengapa TPU?

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

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

Hardware

MXU dan VPU

Core TPU v2 terbuat 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 dalam 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 menjadi float16 biasanya menghasilkan overflow dan underflow. Solusi ada, tetapi biasanya diperlukan pekerjaan tambahan agar float16 berfungsi.

Itulah mengapa Google memperkenalkan format bfloat16 di TPU. bfloat16 adalah float32 yang terpotong dengan bit dan rentang eksponen yang sama persis dengan float32. Hal ini, ditambah dengan fakta bahwa TPU menghitung perkalian matriks dalam presisi campuran dengan input bfloat16 tetapi output float32, 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 default di TPU. Tidak diperlukan perubahan kode dalam kode TensorFlow Anda untuk mengaktifkannya. Anda masih bekerja dengan float32 di seluruh kode Anda. Saat menjalankan perkalian matriks, TPU akan otomatis memotong inputnya menjadi bfloat16. Matriks yang dihasilkan adalah float32.

Array sistolik

MXU mengimplementasikan perkalian matriks dalam hardware menggunakan apa yang disebut arsitektur "array sistolik" di mana elemen data mengalir melalui array unit komputasi hardware. (Dalam kedokteran, "sistolik" mengacu pada kontraksi jantung dan aliran darah, di sini mengacu pada 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, Anda harus memprogram produk titik ini menjadi "inti" GPU, lalu mengeksekusinya pada sebanyak mungkin "inti" yang tersedia secara paralel untuk mencoba dan menghitung setiap nilai matriks yang dihasilkan sekaligus. Jika matriks yang dihasilkan adalah 128x128 besar, itu akan membutuhkan 128x128=16K "inti" tersedia yang biasanya tidak memungkinkan. GPU terbesar memiliki sekitar 4.000 core. Di sisi lain, TPU menggunakan hardware minimum untuk unit komputasi di MXU: hanya bfloat16 x bfloat16 => float32 pengganda-akumulasi, tidak ada yang lain. Ini sangat kecil sehingga TPU dapat mengimplementasikan 16K di antaranya dalam MXU 128x128 dan memproses perkalian matriks ini dalam satu langkah.

Ilustrasi: array sistolik MXU. Elemen komputasinya adalah {i>multi-accumulator<i}. 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. 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 perkalian titik dihitung di MXU, jumlah perantara hanya mengalir di antara unit komputasi yang berdekatan. Data tersebut 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 meminta satu "Cloud TPU v2" di Google Cloud Platform, Anda akan mendapatkan virtual machine (VM) yang memiliki board TPU yang terpasang pada PCI. Papan TPU memiliki empat chip TPU dual-core. Setiap core TPU memiliki VPU (Vector Processing Unit) dan MXU 128x128 (MatriX multiply Unit). "Cloud TPU" ini biasanya terhubung melalui jaringan ke VM yang memintanya. Jadi, gambaran lengkapnya akan terlihat seperti ini:

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

Pod TPU

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

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

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

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

Software

Pelatihan ukuran batch besar

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

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

Untuk tips performa tambahan, lihat Panduan Performa TPU. Untuk ukuran 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 langsung menjalankan kode Python, tetapi menjalankan grafik komputasi yang ditentukan oleh program Tensorflow Anda. Di balik layar, compiler yang disebut XLA (compiler Linear Algebra 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, 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 adalah contoh yang berfungsi di TPU, GPU, dan CPU:

try: # detect TPUs
    tpu = tf.distribute.cluster_resolver.TPUClusterResolver.connect()
    strategy = tf.distribute.TPUStrategy(tpu)
except ValueError: # detect GPUs
    strategy = tf.distribute.MirroredStrategy() # for CPU/GPU or multi-GPU machines

# use TPUStrategy scope to define model
with strategy.scope():
  model = tf.keras.Sequential( ... )
  model.compile( ... )

# train model normally on a tf.data.Dataset
model.fit(training_dataset, epochs=EPOCHS, steps_per_epoch=...)

Dalam cuplikan kode ini:

• TPUClusterResolver().connect() akan menemukan TPU di jaringan. Alat ini berfungsi tanpa parameter di sebagian besar sistem Google Cloud (tugas AI Platform, Colaboratory, Kubeflow, VM Deep Learning yang dibuat melalui utilitas &#39;ctpu up&#39;). Sistem ini dapat mengetahui lokasi TPU mereka berkat variabel lingkungan TPU_NAME. Jika Anda membuat TPU secara manual, setel TPU_NAME env. var. di VM yang Anda gunakan, atau panggil TPUClusterResolver dengan parameter eksplisit: TPUClusterResolver(tp_uname, zone, project)
• TPUStrategy adalah bagian yang menerapkan distribusi dan algoritma sinkronisasi gradien "all-reduce".
• Strategi ini diterapkan melalui ruang lingkup. Model harus ditentukan dalam cakupan strategi().
• Fungsi tpu_model.fit mengharapkan objek tf.data.Dataset untuk input 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 dianggap 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 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. [INFO] Dasar-dasar pengklasifikasi jaringan saraf

Singkatnya

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 saraf terdiri dari beberapa lapisan neuron. Untuk klasifikasi gambar, ini dapat berupa lapisan padat atau, lebih sering, lapisan konvolusi. Pemicu ini biasanya diaktifkan dengan fungsi aktivasi relu. Lapisan terakhir menggunakan neuron sebanyak jumlah 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. Jaringan ini terbuat dari "neuron" yang disusun dalam lapisan. Lapisan pertama memproses data input dan memberikan 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 tersebut dengan meratakan nilai RGB dari semua pikselnya menjadi vektor panjang dan menggunakannya sebagai input. Ini bukan teknik terbaik untuk pengenalan gambar, tetapi kita akan meningkatkannya nanti.

Neuron, aktivasi, RELU

"Neuron" menghitung jumlah berbobot dari semua inputnya, menambahkan nilai yang disebut "bias", dan memasukkan hasilnya melalui "fungsi aktivasi". Bobot dan bias pada awalnya tidak diketahui. Parameter ini akan diinisialisasi secara acak dan "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.

Aktifasi 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. 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" 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 class pemenang, "maks", tetapi mempertahankan urutan relatif asli nilainya, sehingga disebut "soft".

Kerugian entropi silang

Setelah jaringan neural menghasilkan prediksi dari gambar input, kita perlu mengukur seberapa bagusnya prediksi tersebut, yaitu jarak antara apa yang diberitahukan 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, yang disebut "jarak entropi silang" adalah yang paling efektif. Kita akan menyebutnya fungsi error atau "loss":

Encoding "One-hot" berarti Anda merepresentasikan label "3) dandelion" dengan menggunakan vektor 5 nilai, semuanya 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

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

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

Jika kita menghitung turunan parsial entropi silang secara relatif terhadap semua bobot dan semua bias, kita akan mendapatkan "gradien", yang dihitung untuk gambar, label, dan nilai bobot dan bias tertentu. Ingat bahwa kita dapat memiliki jutaan bobot dan bias sehingga menghitung gradien terdengar seperti banyak pekerjaan. Untungnya, Tensorflow melakukannya untuk kita. Properti matematika dari gradien adalah bahwa gradien tersebut menunjuk "ke atas". Karena kita ingin menuju tempat entropi silang rendah, kita akan menuju ke arah yang berlawanan. Kita memperbarui bobot dan bias dengan sebagian gradien. Kemudian kita melakukan hal yang sama berulang kali menggunakan batch gambar dan label pelatihan berikutnya, dalam satu loop pelatihan. Semoga, hal ini akan konvergen ke tempat cross-entropy minimal meskipun tidak ada yang menjamin 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 mencapai 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 contoh gambar dan segera memperbarui bobot dan bias, tetapi melakukannya pada batch, misalnya, 128 gambar akan memberikan gradien yang lebih baik mewakili batasan yang diberlakukan oleh berbagai contoh gambar sehingga cenderung akan berkonvergensi ke solusi lebih cepat. 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 bisa berhenti jika vektor gradien semua nol. Apakah itu berarti kita telah menemukan nilai 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 dengan banyak dimensi, titik pelana cukup umum dan kita tidak ingin berhenti di sana.

Ilustrasi: titik pelana. Gradiennya adalah 0, tetapi bukan minimum di semua arah. (Atribusi gambar Wikimedia: Oleh Nicoguaro - Karya sendiri, 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. Dimensi "batch" biasanya adalah dimensi pertama 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 "class" atau jawaban yang benar dalam masalah klasifikasi berpengawasan

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" atau "fungsi sigmoid" yang dulunya merupakan fungsi aktivasi paling populer. "Output neuron sebelum fungsi logistik" disingkat menjadi "logits".

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

neuron: menghitung jumlah berbobot dari inputnya, menambahkan bias, dan memasukkan 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 populer untuk neuron.

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

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" mirip matriks, tetapi dengan jumlah dimensi arbitrer. Tensor 1 dimensi adalah vektor. Tensor 2 dimensi adalah matriks. Kemudian, Anda dapat memiliki tensor dengan 3, 4, 5, atau lebih dimensi.

5. [INFO BARU] Jaringan neural konvolusi

Ringkasan

Jika semua istilah yang dicetak tebal di paragraf berikutnya sudah Anda ketahui, Anda dapat melanjutkan ke latihan berikutnya. Jika Anda baru memulai jaringan neural konvolusi, lanjutkan membaca.

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 konvolusi, lebar dan tinggi output dapat disesuaikan menggunakan langkah >1 atau dengan operasi max-pooling. Kedalaman output (jumlah saluran) disesuaikan dengan menggunakan lebih banyak atau lebih sedikit filter.

Berikut adalah tampilan jaringan neural konvolusi 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

Di lapisan jaringan konvolusi, satu "neuron" melakukan jumlah berbobot piksel tepat di atasnya, hanya di area 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. Ingat bahwa dalam lapisan padat, setiap neuron memiliki bobotnya sendiri. Di sini, satu "patch" bobot bergeser di seluruh gambar dalam kedua 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 kumpulan bobot baru. Tindakan ini akan menghasilkan kumpulan output filter baru. Mari kita sebut sebagai "saluran" output berdasarkan analogi dengan saluran R, G, B dalam 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 saraf konvolusi mengubah "kubus" data menjadi "kubus" data lainnya.

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:

• Konvolusi dengan langkah: 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" dapat membantu kami memahami secara intuitif cara jaringan konvolusional beroperasi: jika Anda berasumsi bahwa selama pelatihan, patch 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 output tempat bentuk dikenali dengan intensitas maksimum. Dalam praktiknya, di lapisan max-pool, output neuron diproses dalam grup 2x2 dan hanya nilai maksimum yang dipertahankan.

Classifier konvolusi

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. Filter 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 convolutional 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 sebenarnya

6. Convnet kustom Anda

Praktis

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

Keras_Flowers_TPU (playground).ipynb

Sasarannya adalah mengalahkan akurasi 75% 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. 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 saraf 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 jaringan neural "dalam" 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 murah. Mereka tidak benar-benar "memfilter" apa pun kecuali menghitung kombinasi linier dari saluran. Ganti dengan filter yang sebenarnya. (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 serupa dengan jumlah class di akhir jaringan (mengapa? lihat trik "global average pooling" di bawah). Jika Anda mengklasifikasikan ke dalam ratusan class, tingkatkan jumlah filter secara bertahap pada lapisan yang berurutan. Untuk set data bunga dengan 5 kelas, pemfilteran hanya dengan 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. Lapisan ini dapat memiliki lebih banyak bobot daripada semua lapisan konvolusi yang digabungkan. Misalnya, meskipun dengan output yang sangat wajar dari kubus data terakhir yang terdiri dari 24x24x10 titik data, lapisan padat 100 neuron akan memerlukan 24x24x10x100=576.000 bobot !!! Cobalah untuk mempertimbangkan, 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 "kubus" menjadi sebanyak mungkin bagian yang Anda miliki class, 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. Jika filter merespons dengan kuat terhadap beberapa fitur, filter akan melakukannya di lokasi x,y tertentu. Bergantung pada hal 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 misalnya menghitung bunga dalam gambar. Gunakan dengan hati-hati.

Solusi

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

Keras_Flowers_TPU (solution).ipynb

Yang telah kita bahas

• 🤔 Bermain dengan lapisan konvolusi
• 🤓 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.

7. Selamat!

Anda telah membangun jaringan neural konvolusional modern pertama Anda dan melatihnya hingga 80% + akurasi, sehingga melakukan iterasi pada arsitekturnya hanya dalam hitungan menit berkat TPU. Lanjutkan ke lab berikutnya untuk mempelajari arsitektur konvolusi modern:

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

Penggunaan TPU

TPU dan GPU tersedia di Cloud AI Platform:

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

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

Penulis: Martin Görner Twitter: @martin_gorner

www.tensorflow.org