Model dan lapisan

Dalam pembelajaran mesin, model adalah fungsi dengan parameter yang dapat dipelajari yang memetakan masukan ke keluaran. Parameter optimal diperoleh dengan melatih model pada data. Model yang terlatih akan memberikan pemetaan yang akurat dari masukan hingga keluaran yang diinginkan.

Di TensorFlow.js ada dua cara untuk membuat model pembelajaran mesin:

  1. menggunakan Layers API tempat Anda membuat model menggunakan lapisan .
  2. menggunakan Core API dengan operasi tingkat rendah seperti tf.matMul() , tf.add() , dll.

Pertama, kita akan melihat Layers API, yang merupakan API tingkat tinggi untuk membangun model. Kemudian, kami akan menunjukkan cara membuat model yang sama menggunakan Core API.

Membuat model dengan Layers API

Ada dua cara untuk membuat model menggunakan Layers API: Model sekuensial , dan model fungsional . Dua bagian berikutnya membahas setiap jenis lebih dekat.

Model sekuensial

Jenis model yang paling umum adalah model Sequential , yang merupakan tumpukan lapisan linier. Anda dapat membuat model Sequential dengan meneruskan daftar lapisan ke fungsi sequential() :

const model = tf.sequential({
 layers: [
   tf.layers.dense({inputShape: [784], units: 32, activation: 'relu'}),
   tf.layers.dense({units: 10, activation: 'softmax'}),
 ]
});

Atau melalui metode add() :

const model = tf.sequential();
model.add(tf.layers.dense({inputShape: [784], units: 32, activation: 'relu'}));
model.add(tf.layers.dense({units: 10, activation: 'softmax'}));

PENTING: Lapisan pertama dalam model memerlukan inputShape . Pastikan Anda mengecualikan ukuran batch saat memberikan inputShape . Misalnya, jika Anda berencana memasukkan tensor model dengan bentuk [B, 784] , dengan B dapat berupa ukuran batch apa pun, tentukan inputShape sebagai [784] saat membuat model.

Anda dapat mengakses lapisan model melalui model.layers , dan lebih khusus lagi model.inputLayers dan model.outputLayers .

Model fungsional

Cara lain untuk membuat LayersModel adalah melalui fungsi tf.model() . Perbedaan utama antara tf.model() dan tf.sequential() adalah tf.model() memungkinkan Anda membuat grafik lapisan yang berubah-ubah, selama lapisan tersebut tidak memiliki siklus.

Berikut cuplikan kode yang mendefinisikan model yang sama seperti di atas menggunakan tf.model() API:

// Create an arbitrary graph of layers, by connecting them
// via the apply() method.
const input = tf.input({shape: [784]});
const dense1 = tf.layers.dense({units: 32, activation: 'relu'}).apply(input);
const dense2 = tf.layers.dense({units: 10, activation: 'softmax'}).apply(dense1);
const model = tf.model({inputs: input, outputs: dense2});

Kami memanggil apply() pada setiap lapisan untuk menghubungkannya ke keluaran lapisan lain. Hasil dari apply() dalam hal ini adalah SymbolicTensor , yang bertindak seperti Tensor tetapi tanpa nilai konkret apa pun.

Perhatikan bahwa tidak seperti model sekuensial, kami membuat SymbolicTensor melalui tf.input() alih-alih memberikan inputShape ke lapisan pertama.

apply() juga dapat memberi Anda Tensor yang konkret, jika Anda meneruskan Tensor yang konkret ke sana:

const t = tf.tensor([-2, 1, 0, 5]);
const o = tf.layers.activation({activation: 'relu'}).apply(t);
o.print(); // [0, 1, 0, 5]

Ini dapat berguna saat menguji lapisan secara terpisah dan melihat keluarannya.

Sama seperti model sekuensial, Anda dapat mengakses lapisan model melalui model.layers , dan lebih khusus lagi model.inputLayers dan model.outputLayers .

Validasi

Baik model sekuensial maupun model fungsional merupakan turunan dari kelas LayersModel . Salah satu manfaat utama bekerja dengan LayersModel adalah validasi: ini memaksa Anda untuk menentukan bentuk masukan dan akan menggunakannya nanti untuk memvalidasi masukan Anda. LayersModel juga melakukan inferensi bentuk otomatis saat data mengalir melalui lapisan. Mengetahui bentuknya terlebih dahulu memungkinkan model membuat parameternya secara otomatis, dan dapat memberi tahu Anda jika dua lapisan yang berurutan tidak kompatibel satu sama lain.

Ringkasan model

Panggil model.summary() untuk mencetak ringkasan model yang berguna, yang meliputi:

  • Nama dan tipe semua lapisan dalam model.
  • Bentuk keluaran untuk setiap lapisan.
  • Jumlah parameter bobot setiap lapisan.
  • Jika model memiliki topologi umum (dibahas di bawah), masukan yang diterima setiap lapisan
  • Jumlah total parameter model yang dapat dilatih dan tidak dapat dilatih.

Untuk model yang kami definisikan di atas, kami mendapatkan keluaran berikut di konsol:

Lapisan (tipe) Bentuk keluaran Parameter #
padat_Padat1 (Padat) [batal,32] 25120
padat_Padat2 (Padat) [batal,10] 330
Jumlah parameter: 25450
Param yang dapat dilatih: 25450
Param yang tidak dapat dilatih: 0

Perhatikan nilai null dalam bentuk keluaran lapisan: pengingat bahwa model mengharapkan masukan memiliki ukuran batch sebagai dimensi terluar, yang dalam hal ini bisa fleksibel karena nilai null .

Serialisasi

Salah satu manfaat utama menggunakan LayersModel dibandingkan API tingkat rendah adalah kemampuan untuk menyimpan dan memuat model. LayersModel mengetahui tentang:

  • arsitektur model, memungkinkan Anda membuat ulang model.
  • bobot model
  • konfigurasi pelatihan (kerugian, pengoptimal, metrik).
  • keadaan pengoptimal, memungkinkan Anda melanjutkan pelatihan.

Untuk menyimpan atau memuat model hanya dengan 1 baris kode:

const saveResult = await model.save('localstorage://my-model-1');
const model = await tf.loadLayersModel('localstorage://my-model-1');

Contoh di atas menyimpan model ke penyimpanan lokal di browser. Lihat model.save() documentation dan panduan simpan dan muat untuk mengetahui cara menyimpan ke media yang berbeda (misalnya penyimpanan file, IndexedDB , memicu pengunduhan browser, dll.)

Lapisan khusus

Lapisan adalah blok penyusun suatu model. Jika model Anda melakukan komputasi khusus, Anda dapat menentukan lapisan khusus, yang berinteraksi dengan baik dengan lapisan lainnya. Di bawah ini kami mendefinisikan lapisan khusus yang menghitung jumlah kotak:

class SquaredSumLayer extends tf.layers.Layer {
 constructor() {
   super({});
 }
 // In this case, the output is a scalar.
 computeOutputShape(inputShape) { return []; }

 // call() is where we do the computation.
 call(input, kwargs) { return input.square().sum();}

 // Every layer needs a unique name.
 getClassName() { return 'SquaredSum'; }
}

Untuk mengujinya, kita bisa memanggil metode apply() dengan tensor konkret:

const t = tf.tensor([-2, 1, 0, 5]);
const o = new SquaredSumLayer().apply(t);
o.print(); // prints 30

PENTING: Jika Anda menambahkan lapisan khusus, Anda kehilangan kemampuan untuk membuat serial model.

Membuat model dengan Core API

Di awal panduan ini, kami menyebutkan bahwa ada dua cara untuk membuat model pembelajaran mesin di TensorFlow.js.

Aturan umumnya adalah selalu mencoba menggunakan Layers API terlebih dahulu, karena ini dimodelkan setelah Keras API yang diadopsi dengan baik yang mengikuti praktik terbaik dan mengurangi beban kognitif . Layers API juga menawarkan berbagai solusi siap pakai seperti inisialisasi bobot, serialisasi model, pelatihan pemantauan, portabilitas, dan pemeriksaan keamanan.

Anda mungkin ingin menggunakan Core API kapan pun:

  • Anda memerlukan fleksibilitas atau kontrol maksimum.
  • Anda tidak memerlukan serialisasi, atau dapat mengimplementasikan logika serialisasi Anda sendiri.

Model di Core API hanyalah fungsi yang mengambil satu atau lebih Tensors dan mengembalikan Tensor . Model yang sama seperti di atas yang ditulis menggunakan Core API terlihat seperti ini:

// The weights and biases for the two dense layers.
const w1 = tf.variable(tf.randomNormal([784, 32]));
const b1 = tf.variable(tf.randomNormal([32]));
const w2 = tf.variable(tf.randomNormal([32, 10]));
const b2 = tf.variable(tf.randomNormal([10]));

function model(x) {
  return x.matMul(w1).add(b1).relu().matMul(w2).add(b2).softmax();
}

Perhatikan bahwa di Core API kita bertanggung jawab untuk membuat dan menginisialisasi bobot model. Setiap bobot didukung oleh Variable yang memberi sinyal kepada TensorFlow.js bahwa tensor ini dapat dipelajari. Anda dapat membuat Variable menggunakan tf.variable() dan meneruskan Tensor yang sudah ada.

Dalam panduan ini Anda telah membiasakan diri dengan berbagai cara membuat model menggunakan Lapisan dan API Inti. Selanjutnya, lihat panduan model pelatihan tentang cara melatih model.