Model dan lapisan

Dalam pembelajaran mesin, model merupakan fungsi dengan dipelajari parameter yang memetakan input ke output. Parameter optimal diperoleh dengan melatih model pada data. Model yang terlatih dengan baik akan memberikan pemetaan yang akurat dari input hingga output yang diinginkan.

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

  1. menggunakan Layers API di mana Anda membangun model menggunakan lapisan.
  2. menggunakan API inti dengan ops 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 membangun model yang sama menggunakan Core API.

Membuat model dengan Layers API

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

Model sekuensial

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

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

Atau melalui add() metode:

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 membutuhkan inputShape . Pastikan Anda mengecualikan ukuran bets saat memberikan inputShape . Misalnya, jika Anda berencana untuk memberi makan tensor model bentuk [B, 784] , di mana B dapat berbagai ukuran batch, tentukan inputShape sebagai [784] saat membuat model.

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

Model fungsional

Cara lain untuk membuat LayersModel adalah melalui tf.model() fungsi. Perbedaan utama antara tf.model() dan tf.sequential() adalah bahwa tf.model() memungkinkan Anda untuk membuat grafik sewenang-wenang lapisan, selama mereka tidak memiliki siklus.

Berikut ini adalah potongan 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 menyebutnya apply() pada setiap lapisan untuk menghubungkannya ke output dari lapisan lain. Hasil apply() dalam hal ini adalah SymbolicTensor , yang bertindak seperti Tensor tetapi tanpa nilai-nilai yang konkret.

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

apply() juga dapat memberikan beton Tensor , jika Anda lulus beton Tensor untuk itu:

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

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

Validasi

Kedua model sekuensial dan model fungsional adalah contoh dari LayersModel kelas. Salah satu manfaat utama dari bekerja dengan LayersModel adalah validasi: memaksa Anda untuk menentukan bentuk input dan akan menggunakannya kemudian untuk memvalidasi masukan Anda. The LayersModel juga melakukan bentuk inferensi otomatis sebagai data mengalir melalui lapisan. Mengetahui bentuk terlebih dahulu memungkinkan model untuk secara otomatis membuat parameternya, dan dapat memberi tahu Anda jika dua lapisan berurutan tidak kompatibel satu sama lain.

Ringkasan model

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

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

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

Lapisan (tipe) Bentuk keluaran Param #
padat_padat1 (padat) [null,32] 25120
padat_padat2 (padat) [null,10] 330
Jumlah parameter: 25450
Parameter yang dapat dilatih: 25450
Params yang tidak dapat dilatih: 0

Perhatikan null nilai-nilai dalam bentuk output dari lapisan: pengingat bahwa model mengharapkan masukan untuk memiliki ukuran batch dimensi terluar, yang dalam hal ini dapat menjadi fleksibel karena null nilai.

Serialisasi

Salah satu manfaat utama menggunakan LayersModel atas tingkat rendah API adalah kemampuan untuk menyimpan dan memuat model. Sebuah LayersModel tahu tentang:

  • arsitektur model, memungkinkan Anda untuk membuat ulang model.
  • berat model
  • konfigurasi pelatihan (kerugian, pengoptimal, metrik).
  • status pengoptimal, memungkinkan Anda untuk melanjutkan pelatihan.

Untuk menyimpan atau memuat model hanya 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 save dan load panduan untuk bagaimana untuk menyimpan ke media yang berbeda (misalnya penyimpanan file, IndexedDB , memicu browser download, dll)

Lapisan khusus

Lapisan adalah blok bangunan model. Jika model Anda melakukan perhitungan khusus, Anda dapat menentukan lapisan khusus, yang berinteraksi dengan baik dengan lapisan lainnya. Di bawah ini kami mendefinisikan lapisan khusus yang menghitung jumlah kuadrat:

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 dapat memanggil apply() metode dengan tensor beton:

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 umum praktis adalah untuk selalu berusaha menggunakan Layers API pertama, karena dimodelkan setelah API Keras baik diadopsi 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 membutuhkan fleksibilitas atau kontrol maksimum.
  • Anda tidak memerlukan serialisasi, atau dapat mengimplementasikan logika serialisasi Anda sendiri.

Model dalam API inti hanya fungsi yang mengambil satu atau lebih Tensors dan kembali Tensor . Model yang sama seperti yang ditulis di atas 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 kami bertanggung jawab untuk membuat dan menginisialisasi bobot model. Setiap berat badan didukung oleh Variable yang memberi sinyal ke TensorFlow.js bahwa tensor ini dipelajari. Anda dapat membuat Variable menggunakan tf.variable () dan lewat di yang ada Tensor .

Dalam panduan ini Anda telah membiasakan diri dengan berbagai cara untuk membuat model menggunakan Layers dan Core API. Berikutnya, melihat model pelatihan panduan untuk bagaimana untuk melatih model.