Platform dan lingkungan

TensorFlow.js berfungsi di browser dan Node.js, dan di kedua platform ada banyak konfigurasi berbeda yang tersedia. Setiap platform memiliki serangkaian pertimbangan unik yang akan memengaruhi cara aplikasi dikembangkan.

Di browser, TensorFlow.js mendukung perangkat seluler serta perangkat desktop. Setiap perangkat memiliki serangkaian batasan tertentu, seperti API WebGL yang tersedia, yang secara otomatis ditentukan dan dikonfigurasi untuk Anda.

Di Node.js, TensorFlow.js mendukung pengikatan langsung ke API TensorFlow atau berjalan dengan implementasi CPU vanilla yang lebih lambat.

Lingkungan

Saat program TensorFlow.js dijalankan, konfigurasi spesifiknya disebut lingkungan. Lingkungan terdiri dari satu backend global serta satu set flag yang mengontrol fitur-fitur mendetail dari TensorFlow.js.

Backend

TensorFlow.js mendukung beberapa backend berbeda yang mengimplementasikan penyimpanan tensor dan operasi matematika. Pada waktu tertentu, hanya satu backend yang aktif. Biasanya, TensorFlow.js akan secara otomatis memilih backend terbaik untuk Anda mengingat lingkungan saat ini. Namun, terkadang penting untuk mengetahui backend mana yang digunakan dan cara menggantinya.

Untuk menemukan backend mana yang Anda gunakan:

console.log(tf.getBackend());

Jika Anda ingin mengubah backend secara manual:

tf.setBackend('cpu');
console.log(tf.getBackend());

Backend WebGL

Backend WebGL, 'webgl', saat ini merupakan backend paling kuat untuk browser. Backend ini hingga 100x lebih cepat daripada backend CPU vanilla. Tensor disimpan sebagai tekstur WebGL dan operasi matematika diimplementasikan dalam shader WebGL. Berikut adalah beberapa hal berguna yang perlu diketahui saat menggunakan backend ini: \

Hindari memblokir utas UI

Ketika sebuah operasi dipanggil, seperti tf.matMul(a, b), hasil tf.Tensor dikembalikan secara sinkron, namun perhitungan perkalian matriks mungkin belum benar-benar siap. Ini berarti tf.Tensor yang dikembalikan hanyalah pegangan untuk perhitungan. Ketika Anda memanggil x.data() atau x.array() , nilai-nilai akan menyelesaikan ketika perhitungan telah benar-benar selesai. Hal ini membuat penting untuk menggunakan asynchronous x.data() dan x.array() metode atas rekan-rekan sinkron mereka x.dataSync() dan x.arraySync() untuk menghindari menghalangi thread UI saat selesai perhitungan.

Manajemen memori

Satu peringatan saat menggunakan backend WebGL adalah perlunya manajemen memori eksplisit. WebGLTextures, tempat penyimpanan data Tensor, tidak secara otomatis mengumpulkan sampah oleh browser.

Untuk menghancurkan memori dari tf.Tensor , Anda dapat menggunakan dispose() metode:

const a = tf.tensor([[1, 2], [3, 4]]);
a.dispose();

Sangat umum untuk menghubungkan beberapa operasi bersama-sama dalam suatu aplikasi. Memegang referensi ke semua variabel perantara untuk membuangnya dapat mengurangi keterbacaan kode. Untuk mengatasi masalah ini, TensorFlow.js menyediakan tf.tidy() metode yang membersihkan semua tf.Tensor s yang tidak dikembalikan oleh fungsi setelah melaksanakan itu, mirip dengan cara variabel lokal dibersihkan ketika fungsi dijalankan:

const a = tf.tensor([[1, 2], [3, 4]]);
const y = tf.tidy(() => {
  const result = a.square().log().neg();
  return result;
});

presisi

Pada perangkat seluler, WebGL mungkin hanya mendukung tekstur titik mengambang 16 bit. Namun, sebagian besar model pembelajaran mesin dilatih dengan bobot dan aktivasi floating point 32 bit. Hal ini dapat menyebabkan masalah presisi ketika port model untuk perangkat mobile seperti angka floating 16 bit hanya dapat mewakili angka di kisaran [0.000000059605, 65504] . Ini berarti Anda harus berhati-hati agar bobot dan aktivasi dalam model Anda tidak melebihi kisaran ini. Untuk memeriksa apakah perangkat mendukung 32 bit tekstur, periksa nilai tf.ENV.getBool('WEBGL_RENDER_FLOAT32_CAPABLE') , jika ini adalah palsu maka perangkat hanya mendukung 16 bit floating point tekstur. Anda dapat menggunakan tf.ENV.getBool('WEBGL_RENDER_FLOAT32_ENABLED') untuk memeriksa apakah TensorFlow.js saat ini menggunakan 32 tekstur bit.

Kompilasi shader & unggahan tekstur

TensorFlow.js menjalankan operasi pada GPU dengan menjalankan program shader WebGL. Shader ini dirakit dan dikompilasi dengan malas ketika pengguna meminta untuk menjalankan operasi. Kompilasi shader terjadi pada CPU di utas utama dan bisa lambat. TensorFlow.js akan meng-cache shader yang dikompilasi secara otomatis, membuat panggilan kedua ke operasi yang sama dengan tensor input dan output dengan bentuk yang sama jauh lebih cepat. Biasanya, aplikasi TensorFlow.js akan menggunakan operasi yang sama beberapa kali selama masa pakai aplikasi, sehingga melewati model pembelajaran mesin yang kedua jauh lebih cepat.

TensorFlow.js juga menyimpan data tf.Tensor sebagai WebGLTextures. Ketika tf.Tensor dibuat, kita tidak segera meng-upload data ke GPU, bukan kita menyimpan data pada CPU sampai tf.Tensor digunakan dalam operasi. Jika tf.Tensor digunakan kedua kalinya, data yang sudah di GPU sehingga tidak ada biaya upload. Dalam model pembelajaran mesin yang khas, ini berarti bobot diunggah selama prediksi pertama melalui model dan lintasan kedua melalui model akan jauh lebih cepat.

Jika Anda peduli dengan performa prediksi pertama melalui model atau kode TensorFlow.js Anda, sebaiknya pemanasan model dengan meneruskan Tensor input dengan bentuk yang sama sebelum data nyata digunakan.

Sebagai contoh:

const model = await tf.loadLayersModel(modelUrl);

// Warmup the model before using real data.
const warmupResult = model.predict(tf.zeros(inputShape));
warmupResult.dataSync();
warmupResult.dispose();

// The second predict() will be much faster
const result = model.predict(userData);

Backend TensorFlow Node.js

Di backend TensorFlow Node.js, 'node', TensorFlow C API digunakan untuk mempercepat operasi. Ini akan menggunakan akselerasi perangkat keras yang tersedia pada mesin, seperti CUDA, jika tersedia.

Dalam backend ini, seperti backend WebGL, operasi kembali tf.Tensor s serempak. Namun, tidak seperti backend WebGL, operasi selesai sebelum Anda mendapatkan kembali tensor. Ini berarti bahwa panggilan untuk tf.matMul(a, b) akan memblokir thread UI.

Karena alasan ini, jika Anda ingin menggunakan ini dalam aplikasi produksi, Anda harus menjalankan TensorFlow.js di utas pekerja agar tidak memblokir utas utama.

Untuk informasi lebih lanjut tentang Node.js, lihat panduan ini.

latar belakang WASM

TensorFlow.js menyediakan backend WebAssembly ( wasm ), yang menawarkan CPU percepatan dan dapat digunakan sebagai alternatif untuk vanili JavaScript CPU ( cpu ) dan WebGL dipercepat ( webgl ) backends. Untuk menggunakannya:

// Set the backend to WASM and wait for the module to be ready.
tf.setBackend('wasm');
tf.ready().then(() => {...});

Jika server Anda melayani .wasm file di jalan yang berbeda atau nama yang berbeda, penggunaan setWasmPath sebelum Anda menginisialisasi backend. Lihat "Menggunakan Bundlers" bagian dalam README untuk info lebih lanjut:

import {setWasmPath} from '@tensorflow/tfjs-backend-wasm';
setWasmPath(yourCustomPath);
tf.setBackend('wasm');
tf.ready().then(() => {...});

Mengapa WASM?

Wasm diperkenalkan pada tahun 2015 sebagai format biner berbasis web baru, memberikan program yang ditulis dalam JavaScript, C, C ++, dll kompilasi target untuk menjalankan di web. Wasm telah didukung oleh Chrome, Safari, Firefox, dan Ujung sejak 2017, dan didukung oleh 90% dari perangkat di seluruh dunia.

Pertunjukan

Wasm backend memanfaatkan perpustakaan XNNPACK untuk implementasi dioptimalkan dari operator jaringan saraf.

Versus JavaScript: binari wasm umumnya jauh lebih cepat daripada bundel JavaScript untuk browser untuk memuat, parse, dan mengeksekusi. JavaScript diketik secara dinamis dan sampah dikumpulkan, yang dapat menyebabkan pelambatan saat runtime.

Versus WebGL: WebGL lebih cepat daripada wasm untuk kebanyakan model, tapi untuk model kecil wasm bisa mengungguli WebGL karena biaya overhead tetap melaksanakan shader WebGL. Bagian “Kapan saya harus menggunakan WASM” di bawah ini membahas heuristik untuk membuat keputusan ini.

Portabilitas dan Stabilitas

WASM memiliki aritmatika float 32-bit portabel, menawarkan paritas presisi di semua perangkat. WebGL, di sisi lain, adalah spesifik perangkat keras dan perangkat yang berbeda dapat memiliki presisi yang bervariasi (misalnya mundur ke float 16-bit pada perangkat iOS).

Seperti WebGL, WASM secara resmi didukung oleh semua browser utama. Tidak seperti WebGL, WASM dapat berjalan di Node.js, dan digunakan di sisi server tanpa perlu mengompilasi pustaka asli.

Kapan saya harus menggunakan WASM?

Ukuran model dan permintaan komputasi

Secara umum, wasm adalah pilihan yang baik ketika model yang lebih kecil atau Anda peduli tentang perangkat yang lebih rendah-end yang tidak memiliki dukungan WebGL ( OES_texture_float ekstensi) atau memiliki GPU kurang kuat. Tabel di bawah ini menunjukkan inferensi kali (per TensorFlow.js 1.5.2) di Chrome pada 2018 MacBook Pro untuk 5 dari resmi didukung kami model di seluruh WebGL, wasm, dan backends CPU:

Model yang lebih kecil

Model yang lebih besar

Tabel di atas menunjukkan bahwa wasm adalah 10-30x lebih cepat dari dataran JS CPU backend di seluruh model, dan kompetitif dengan WebGL untuk model yang lebih kecil seperti BlazeFace , yang ringan (400kb), namun memiliki jumlah yang layak ops (~ 140). Mengingat bahwa program WebGL memiliki biaya overhead tetap per eksekusi operasi, ini menjelaskan mengapa model seperti BlazeFace lebih cepat di WASM.

Hasil ini akan bervariasi tergantung pada perangkat Anda. Cara terbaik untuk menentukan apakah WASM tepat untuk aplikasi Anda adalah dengan mengujinya di berbagai backend kami.

Inferensi vs Pelatihan

Untuk mengatasi penggunaan-kasus utama untuk penyebaran model pra-dilatih, pengembangan backend wasm akan memprioritaskan inferensi lebih pelatihan dukungan. Melihat daftar up-to-date dari ops didukung dalam wasm dan biarkan kami tahu jika model Anda memiliki op yang tidak didukung. Untuk model pelatihan, sebaiknya gunakan backend Node (TensorFlow C++) atau backend WebGL.

CPU bagian belakang

Backend CPU, 'cpu', adalah backend dengan performa paling rendah, namun paling sederhana. Semua operasi diimplementasikan dalam JavaScript vanilla, yang membuatnya kurang dapat diparalelkan. Mereka juga memblokir utas UI.

Backend ini bisa sangat berguna untuk pengujian, atau pada perangkat di mana WebGL tidak tersedia.

Bendera

TensorFlow.js memiliki serangkaian flag lingkungan yang dievaluasi secara otomatis dan menentukan konfigurasi terbaik di platform saat ini. Bendera ini sebagian besar internal, tetapi beberapa bendera global dapat dikontrol dengan API publik.

• tf.enableProdMode(): memungkinkan mode produksi, yang akan menghapus validasi Model, cek NaN, dan pemeriksaan kebenaran lain yang mendukung kinerja.
• tf.enableDebugMode() : memungkinkan mode debug, yang akan login ke konsol setiap operasi yang dijalankan, serta informasi kinerja runtime seperti jejak memori dan waktu eksekusi kernel Total. Perhatikan bahwa ini akan sangat memperlambat aplikasi Anda, jangan gunakan ini dalam produksi.