TensorFlow.js: Mengonversi Python TersimpanModel ke format TensorFlow.js

1. Pengantar

Jadi, Anda telah mengambil langkah pertama dengan TensorFlow.js, mencoba model buatan kami, atau bahkan membuat model sendiri. Namun, Anda melihat beberapa riset mutakhir di Python dan ingin tahu apakah riset tersebut akan berjalan di browser web untuk mewujudkan ide keren Anda kepada jutaan orang secara terukur. Terdengar familier? Jika demikian, CodeLab ini cocok untuk Anda.

Tim TensorFlow.js telah membuat alat praktis untuk mengonversi model yang dalam format SavedModel ke TensorFlow.js melalui konverter command line sehingga Anda dapat menikmati penggunaan model tersebut dengan jangkauan dan skala web.

Yang akan Anda pelajari

Dalam lab kode ini, Anda akan mempelajari cara menggunakan konverter command line TensorFlow.js untuk memindahkan SavedModel yang dibuat Python ke format model.json yang diperlukan untuk eksekusi di sisi klien dalam browser web.

Khususnya:

• Cara membuat model ML Python sederhana dan menyimpannya ke format yang diperlukan oleh konverter TensorFlow.js.
• Cara menginstal dan menggunakan konverter TensorFlow.js pada SavedModel yang Anda ekspor dari Python.
• Ambil file yang dihasilkan dari konversi dan gunakan di aplikasi web JS Anda.
• Pahami apa yang harus dilakukan jika terjadi kesalahan (tidak semua model akan dikonversi) dan opsi yang Anda miliki.

Bayangkan Anda dapat mengambil beberapa riset yang baru dirilis dan membuat model tersebut tersedia bagi jutaan developer JS secara global. Atau mungkin Anda akan menggunakannya sendiri dalam kreasi Anda, yang kemudian dapat dinikmati oleh siapa pun di dunia jika berjalan di browser web, karena tidak memerlukan penyiapan lingkungan atau dependensi yang rumit. Siap untuk mulai meretas? Ayo mulai!

Perhatikan: Codelab ini berfokus pada cara menggunakan dan memulai penggunaan konverter TensorFlow.js, sehingga tindakan pembuatan model itu sendiri akan menggunakan kode boilerplate agar kita bisa mendapatkan beberapa file untuk digunakan dalam tutorial. Untuk mempelajari cara membuat model Anda sendiri secara lebih mendetail, lihat codelab lainnya untuk hal ini.

Bagikan hasil konversi Anda kepada kami.

Anda dapat menggunakan apa yang kita pelajari hari ini untuk mencoba mengonversi beberapa model favorit Anda dari Python. Jika Anda berhasil melakukannya, dan membuat situs demo yang berfungsi untuk menampilkan model tersebut, tag kami di media sosial menggunakan hashtag #MadeWithTFJS agar project Anda mendapat peluang untuk ditampilkan di blog TensorFlow atau bahkan di acara show and tell mendatang. Kami ingin melihat lebih banyak riset luar biasa yang di-porting ke web dan memungkinkan lebih banyak orang menggunakan model tersebut dengan cara yang inovatif atau kreatif seperti contoh luar biasa ini.

2. Apa itu TensorFlow.js?

TensorFlow.js adalah library machine learning open source yang dapat berjalan di mana pun JavaScript dapat berjalan. TensorFlow.js didasarkan pada library TensorFlow asli yang ditulis dalam Python dan bertujuan untuk menciptakan kembali pengalaman developer dan serangkaian API ini untuk ekosistem JavaScript.

Di mana visibilitas dapat digunakan?

Mengingat portabilitas JavaScript, kini Anda dapat menulis dalam 1 bahasa dan melakukan machine learning di semua platform berikut dengan mudah:

• Sisi klien di browser web menggunakan JavaScript vanilla
• Sisi server dan bahkan perangkat IoT seperti Raspberry Pi yang menggunakan Node.js
• Aplikasi desktop yang menggunakan Electron
• Aplikasi seluler native menggunakan React Native

TensorFlow.js juga mendukung beberapa backend dalam setiap lingkungan ini (lingkungan berbasis hardware aktual yang dapat dijalankannya seperti CPU atau WebGL). "Backend" dalam konteks ini tidak berarti lingkungan sisi server - backend untuk eksekusi bisa berupa sisi klien di WebGL misalnya) untuk memastikan kompatibilitas dan juga menjaga agar semuanya berjalan cepat. Saat ini, TensorFlow.js mendukung:

• Eksekusi WebGL di kartu grafis perangkat (GPU) - ini adalah cara tercepat untuk mengeksekusi model yang lebih besar (berukuran lebih dari 3 MB) dengan akselerasi GPU.
• Eksekusi Web Assembly (WASM) di CPU - untuk meningkatkan performa CPU di seluruh perangkat, termasuk ponsel generasi lama. Hal ini lebih cocok untuk model yang lebih kecil (berukuran kurang dari 3 MB) yang sebenarnya dapat dieksekusi lebih cepat di CPU dengan WASM daripada dengan WebGL karena overhead mengupload konten ke prosesor grafis.
• Eksekusi CPU - penggantian jika tidak ada lingkungan lain yang tersedia. Ini adalah yang paling lambat dari ketiganya, tetapi selalu tersedia untuk Anda.

Catatan: Anda dapat memilih untuk memaksa salah satu backend ini jika Anda mengetahui perangkat yang akan Anda gunakan untuk menjalankan kode, atau Anda cukup membiarkan TensorFlow.js memutuskan untuk Anda jika Anda tidak menentukannya.

Kemampuan super sisi klien

Menjalankan TensorFlow.js di browser web pada perangkat klien dapat memberikan beberapa manfaat yang patut dipertimbangkan.

Privasi

Anda dapat melatih dan mengklasifikasikan data di mesin klien tanpa pernah mengirim data ke server web pihak ketiga. Terkadang, hal ini mungkin menjadi persyaratan untuk mematuhi hukum setempat, seperti GDPR misalnya, atau saat memproses data apa pun yang mungkin ingin disimpan pengguna di perangkatnya dan tidak dikirim ke pihak ketiga.

Kecepatan

Karena Anda tidak perlu mengirim data ke server jarak jauh, inferensi (tindakan mengklasifikasikan data) dapat dilakukan lebih cepat. Lebih baik lagi, Anda memiliki akses langsung ke sensor perangkat seperti kamera, mikrofon, GPS, akselerometer, dan lainnya jika pengguna memberi Anda akses.

Jangkauan dan skala

Dengan sekali klik, siapa pun di dunia dapat mengklik link yang Anda kirimkan, membuka halaman web di browser mereka, dan memanfaatkan apa yang telah Anda buat. Anda tidak memerlukan penyiapan Linux sisi server yang rumit dengan driver CUDA dan banyak lagi hanya untuk menggunakan sistem machine learning.

Biaya

Tanpa server berarti satu-satunya yang perlu Anda bayar adalah CDN untuk menghosting file HTML, CSS, JS, dan model Anda. Biaya CDN jauh lebih murah daripada menjalankan server (yang berpotensi memiliki kartu grafis terpasang) 24/7.

Fitur sisi server

Memanfaatkan implementasi Node.js dari TensorFlow.js memungkinkan fitur berikut.

Dukungan CUDA penuh

Di sisi server, untuk akselerasi kartu grafis, Anda harus menginstal driver NVIDIA CUDA agar TensorFlow dapat berfungsi dengan kartu grafis (tidak seperti di browser yang menggunakan WebGL - tidak perlu penginstalan). Namun, dengan dukungan CUDA penuh, Anda dapat memanfaatkan kemampuan tingkat bawah kartu grafis sepenuhnya, sehingga menghasilkan waktu pelatihan dan inferensi yang lebih cepat. Performa setara dengan implementasi Python TensorFlow karena keduanya menggunakan backend C++ yang sama.

Ukuran Model

Untuk model canggih dari penelitian, Anda mungkin bekerja dengan model yang sangat besar, mungkin berukuran gigabyte. Model ini saat ini tidak dapat dijalankan di browser web karena batasan penggunaan memori per tab browser. Untuk menjalankan model yang lebih besar ini, Anda dapat menggunakan Node.js di server Anda sendiri dengan spesifikasi hardware yang diperlukan untuk menjalankan model tersebut secara efisien.

IOT

Node.js didukung di komputer papan tunggal populer seperti Raspberry Pi, yang berarti Anda juga dapat menjalankan model TensorFlow.js di perangkat tersebut.

Kecepatan

Node.js ditulis dalam JavaScript yang berarti Node.js diuntungkan dari kompilasi tepat waktu. Artinya, Anda mungkin sering melihat peningkatan performa saat menggunakan Node.js karena akan dioptimalkan saat runtime, terutama untuk pra-pemrosesan yang mungkin Anda lakukan. Contoh yang bagus tentang hal ini dapat dilihat dalam studi kasus ini yang menunjukkan cara Hugging Face menggunakan Node.js untuk mendapatkan peningkatan performa 2x untuk model pemrosesan bahasa alami mereka.

Sekarang Anda telah memahami dasar-dasar TensorFlow.js, tempat TensorFlow.js dapat berjalan, dan beberapa manfaatnya. Mari kita mulai melakukan hal-hal yang berguna dengannya.

3. Menyiapkan sistem Anda

Untuk tutorial ini, kita akan menggunakan Ubuntu - distribusi Linux populer yang digunakan banyak orang dan tersedia di Compute Engine Google Cloud sebagai image dasar jika Anda memilih untuk mengikuti di virtual machine berbasis cloud.

Pada saat penulisan, kita dapat memilih image Ubuntu 18.04.4 LTS saat membuat instance Compute Engine vanilla baru yang akan kita gunakan. Tentu saja Anda dapat menggunakan komputer Anda sendiri, atau bahkan sistem operasi yang berbeda jika Anda memilih untuk melakukannya, tetapi petunjuk penginstalan dan dependensi mungkin berbeda di antara sistem.

Menginstal TensorFlow (versi Python)

Nah, karena Anda mungkin mencoba mengonversi beberapa model berbasis Python yang ada yang Anda temukan / atau akan tulis, sebelum kita dapat mengekspor file "SavedModel" dari Python, Anda harus menyiapkan TensorFlow versi Python di instance Anda jika "SavedModel" belum tersedia untuk didownload.

Hubungkan SSH ke mesin cloud yang Anda buat di atas, lalu ketik perintah berikut di jendela terminal:

Jendela terminal:

sudo apt update
sudo apt-get install python3

Hal ini akan memastikan kita telah menginstal Python 3 di komputer. Python 3.4 atau yang lebih tinggi harus diinstal untuk menggunakan TensorFlow.

Untuk memverifikasi bahwa versi yang benar telah diinstal, ketik berikut:

Jendela terminal:

python3 --version

Anda akan melihat beberapa output yang menunjukkan nomor versi seperti Python 3.6.9. Jika Anda melihatnya tercetak dengan benar dan lebih tinggi dari 3,4, kita siap melanjutkan.

Selanjutnya, kita akan menginstal PIP untuk Python 3 yang merupakan pengelola paket Python, lalu mengupdatenya. Jenis:

Jendela terminal:

sudo apt install python3-pip
pip3 install --upgrade pip

Sekali lagi, kita dapat memverifikasi penginstalan pip3 melalui:

Jendela terminal:

pip3 --version

Pada saat penulisan, kita melihat pip 20.2.3 dicetak ke terminal setelah menjalankan perintah ini.

Sebelum kita dapat menginstal TensorFlow, paket Python "setuptools" harus memiliki versi 41.0.0 atau yang lebih tinggi. Jalankan perintah berikut untuk memastikan versinya telah diupdate ke versi terbaru:

Jendela terminal:

pip3 install -U setuptools

Terakhir, kita dapat menginstal TensorFlow untuk Python:

Jendela terminal:

pip3 install tensorflow

Proses ini mungkin memerlukan waktu beberapa saat, jadi harap tunggu hingga selesai dieksekusi.

Peringatan: Dalam tutorial ini, kita akan menginstal TensorFlow versi khusus CPU untuk penyiapan yang cepat. Jika ingin menggunakan GPU instance, Anda harus menginstal TensorFlow versi GPU, yang dapat memberikan waktu pelatihan yang jauh lebih cepat. Namun, versi ini bergantung pada penginstalan driver NVIDIA CUDA, yang berada di luar cakupan codelab ini. Anda dapat menemukan detail selengkapnya tentang menginstal TensorFlow versi GPU di sini.

Mari kita periksa apakah TensorFlow telah diinstal dengan benar. Buat file Python bernama test.py di direktori saat ini:

Jendela terminal:

nano test.py

Setelah nano terbuka, kita dapat menulis beberapa kode Python untuk mencetak versi TensorFlow yang diinstal:

test.py:

import tensorflow as tf
print(tf.__version__)

Tekan CTRL + O untuk menulis perubahan ke disk, lalu tekan CTRL + X untuk keluar dari editor nano.

Sekarang kita dapat menjalankan file Python ini untuk melihat versi TensorFlow yang dicetak ke layar:

Jendela terminal:

python3 test.py

Pada saat penulisan, kita melihat 2.3.1 dicetak ke konsol untuk versi TensorFlow Python yang diinstal.

Peringatan: Jika Anda melihat banyak pop-up peringatan terkait numpy, cukup masukkan perintah berikut di terminal untuk mengupgrade versi numpy Anda:

pip uninstall numpy

pip install numpy==1.16.4

Anda mungkin masih melihat beberapa peringatan terkait GPU / libcudart - hal ini tidak masalah karena kita menginstal TensorFlow versi CPU, bukan GPU. Anda dapat mengabaikannya.

4. Membuat model Python

Langkah berikutnya dalam codelab ini akan membahas cara membuat model Python sederhana untuk menunjukkan cara menyimpan model terlatih yang dihasilkan dalam format "SavedModel" untuk kemudian digunakan dengan konverter command line TensorFlow.js. Prinsipnya akan serupa untuk model Python apa pun yang Anda coba konversi, tetapi kita akan menjaga kesederhanaan kode ini agar semua orang dapat memahaminya.

Mari edit file test.py yang kita buat di bagian pertama dan perbarui kodenya sebagai berikut:

test.py:

import tensorflow as tf
print(tf.__version__)

# Import NumPy - package for working with arrays in Python.
import numpy as np

# Import useful keras functions - this is similar to the
# TensorFlow.js Layers API functionality.
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense

# Create a new dense layer with 1 unit, and input shape of [1].
layer0 = Dense(units=1, input_shape=[1])
model = Sequential([layer0])

# Compile the model using stochastic gradient descent as optimiser
# and the mean squared error loss function.
model.compile(optimizer='sgd', loss='mean_absolute_error')

# Provide some training data! Here we are using some fictional data 
# for house square footage and house price (which is simply 1000x the 
# square footage) which our model must learn for itself.
xs = np.array([800.0, 850.0, 900.0, 950.0, 980.0, 1000.0, 1050.0, 1075.0, 1100.0, 1150.0, 1200.0, 1250.0, 1300.0, 1400.0, 1500.0, 1600.0, 1700.0, 1800.0, 1900.0, 2000.0], dtype=float)

ys = np.array([800000.0, 850000.0, 900000.0, 950000.0, 980000.0, 1000000.0, 1050000.0, 1075000.0, 1100000.0, 1150000.0, 1200000.0,  1250000.0, 1300000.0, 1400000.0, 1500000.0, 1600000.0, 1700000.0, 1800000.0, 1900000.0, 2000000.0], dtype=float)

# Train the model for 500 epochs.
model.fit(xs, ys, epochs=500, verbose=0)

# Test the trained model on a test input value
print(model.predict([1200.0]))

# Save the model we just trained to the "SavedModel" format to the
# same directory our test.py file is located.
tf.saved_model.save(model, './')

Kode ini akan melatih regresi linear yang sangat sederhana untuk mempelajari cara memperkirakan hubungan antara x (input) dan y (output) yang diberikan. Kemudian, kita akan menyimpan model terlatih yang dihasilkan ke disk. Periksa komentar inline untuk mengetahui detail selengkapnya tentang fungsi setiap baris.

Jika kita memeriksa direktori setelah menjalankan program ini (dengan memanggil python3 test.py), kita akan melihat beberapa file dan folder baru yang dibuat di direktori saat ini:

• test.py
• saved_model.pb
• aset
• variabel

Sekarang kita telah membuat file yang diperlukan oleh konverter TensorFlow.js untuk mengonversi model ini agar dapat berjalan di browser.

5. Mengonversi SavedModel ke format TensorFlow.js

Menginstal konverter TensorFlow.js

Untuk menginstal konverter, jalankan perintah berikut:

Jendela terminal:

pip3 install tensorflowjs

Itu mudah.

Perhatikan: Tersedia juga wizard yang dapat Anda instal menggunakan pip3 install tensorflowjs[wizard]

Setelah diinstal, Anda dapat menjalankan perintah tensorflowjs_wizard yang akan memandu Anda melalui proses konversi dengan cara yang lebih mudah seperti yang ditunjukkan di sini:

Dengan asumsi kita menggunakan konverter command line (tensorflowjs_converter) dan bukan versi wizard yang ditampilkan di atas, kita dapat memanggil perintah berikut untuk mengonversi model tersimpan yang baru saja kita buat dan meneruskan parameter secara eksplisit ke konverter:

Jendela terminal:

tensorflowjs_converter \
    --input_format=keras_saved_model \
    ./ \
    ./predict_houses_tfjs

Apa yang terjadi di sini? Pertama, kita memanggil biner tensorflowjs_converter yang baru saja kita instal dan menentukan bahwa kita mencoba mengonversi model tersimpan keras.

Dalam contoh kode di atas, Anda akan melihat bahwa kami mengimpor Keras dan menggunakan API lapisan tingkat yang lebih tinggi untuk membuat model. Jika Anda belum menggunakan keras dalam kode Python, Anda dapat menggunakan format input yang berbeda:

• keras - untuk memuat format keras (jenis file HDF5)
• tf_saved_model - untuk memuat model yang menggunakan API inti tensorflow, bukan keras.
• tf_frozen_model - untuk memuat model yang berisi bobot yang dibekukan.
• tf_hub - untuk memuat model yang dihasilkan dari TensorFlow Hub.

Anda dapat mempelajari lebih lanjut format lainnya di sini.

2 parameter berikutnya menentukan folder tempat model yang disimpan berada - dalam demo di atas, kita menentukan direktori saat ini, dan terakhir kita menentukan direktori tempat kita ingin menghasilkan konversi, yang kita tentukan di atas sebagai folder bernama "predict_houses_tfjs" di direktori saat ini.

Menjalankan perintah di atas akan membuat folder baru di direktori saat ini bernama predict_houses_tfjs yang berisi :

• model.json
• Group1-shard1of1.bin

Ini adalah file yang kita perlukan untuk menjalankan model di browser web. Simpan file ini karena kita akan menggunakannya di bagian berikutnya.

Perhatikan: File TensorFlow.js sisi klien akan selalu terdiri dari model.json dan setidaknya satu file .bin. File biner dipecah menjadi beberapa bagian berukuran 4 MB untuk mengoptimalkan pengiriman paralel aset tersebut ke browser web di sisi klien.

6. Menggunakan model yang dikonversi di browser

Menghosting file yang dikonversi

Pertama, kita harus menempatkan file model.json dan *.bin yang dihasilkan di server web agar kita dapat mengaksesnya melalui halaman web. Untuk demo ini, kita akan menggunakan Glitch.com agar Anda dapat mengikutinya dengan mudah. Namun, jika Anda memiliki latar belakang teknik web, Anda dapat memilih untuk menjalankan server http sederhana di instance server Ubuntu saat ini untuk melakukannya. Anda yang menentukan.

Mengupload file ke Glitch

1. Login ke Glitch.com
2. Gunakan link ini untuk Meng-clone project TensorFlow.js boilerplate kami. Ini berisi file html, css, dan js kerangka yang mengimpor library TensorFlow.js untuk kita siap digunakan.
3. Klik folder "assets" di panel sebelah kiri.
4. Klik "upload aset" dan pilih group1-shard1of1.bin untuk diupload ke folder ini. Setelah diupload, tampilannya akan seperti ini:
5. Jika Anda mengklik file group1-shard1of1.bin yang baru saja diupload, Anda akan dapat menyalin URL ke lokasinya. Salin jalur ini sekarang seperti yang ditunjukkan:
6. Sekarang edit model.json menggunakan editor teks favorit Anda di komputer lokal dan telusuri (menggunakan CTRL+F) file group1-shard1of1.bin yang akan disebutkan di suatu tempat di dalamnya.

Ganti nama file ini dengan URL yang Anda salin dari langkah 5, tetapi hapus https://cdn.glitch.com/ di awal yang dihasilkan oleh gangguan dari jalur yang disalin.

Setelah diedit, tampilannya akan seperti ini (perhatikan bagaimana jalur server di awal telah dihapus sehingga hanya nama file yang diupload yang disimpan): 7. Sekarang simpan dan upload file model.json yang telah diedit ini ke glitch dengan mengklik aset, lalu klik tombol "upload an asset" (penting). Jika Anda tidak menggunakan tombol fisik, dan melakukan tarik lalu lepas, file akan diupload sebagai file yang dapat diedit, bukan di CDN yang tidak akan berada di folder yang sama dan jalur relatif diasumsikan saat TensorFlow.js mencoba mendownload file biner untuk model tertentu. Jika Anda telah melakukannya dengan benar, Anda akan melihat 2 file di folder assets seperti ini:

Bagus! Sekarang kita siap menggunakan file tersimpan dengan beberapa kode sebenarnya di browser.

Peringatan: Jika Anda memutuskan untuk tidak menggunakan Glitch.com dan menjalankan server web sendiri, tidak ada pengeditan pada file model.json yang diperlukan selama Anda menyajikan file dari direktori yang sama di server web. Cukup pastikan file tersebut berada di folder yang sama dan dapat diakses dari kode sisi klien.

Memuat model

Setelah menghosting file yang dikonversi, kita dapat menulis halaman web sederhana untuk memuat file ini dan menggunakannya untuk membuat prediksi. Buka script.js di folder project Glitch, lalu ganti konten file ini dengan konten berikut setelah Anda mengubah const MODEL_URL agar mengarah ke link Glitch.com yang dibuat untuk file model.json yang Anda upload di Glitch:

script.js:

// Grab a reference to our status text element on the web page.
// Initially we print out the loaded version of TFJS.
const status = document.getElementById('status');
status.innerText = 'Loaded TensorFlow.js - version: ' + tf.version.tfjs;

// Specify location of our Model.json file we uploaded to the Glitch.com CDN.
const MODEL_URL = ‘YOUR MODEL.JSON URL HERE! CHANGE THIS!';
// Specify a test value we wish to use in our prediction.
// Here we use 950, so we expect the result to be close to 950,000.
const TEST_VALUE = 950.0

// Create an asynchronous function.
async function run() {
    // Load the model from the CDN.
    const model = await tf.loadLayersModel(MODEL_URL);

    // Print out the architecture of the loaded model.
    // This is useful to see that it matches what we built in Python.
    console.log(model.summary());

    // Create a 1 dimensional tensor with our test value.
    const input = tf.tensor1d([TEST_VALUE]);

    // Actually make the prediction.
    const result = model.predict(input);

    // Grab the result of prediction using dataSync method
    // which ensures we do this synchronously.
    status.innerText = 'Input of ' + TEST_VALUE + 
        'sqft predicted as $' + result.dataSync()[0];
}

// Call our function to start the prediction!
run();

Menjalankan kode di atas setelah Anda mengubah konstanta MODEL_URL untuk mengarah ke jalur model.json akan menghasilkan output yang ditampilkan di bawah.

Perhatikan: Untuk menjalankan kode, cukup klik "show" di bagian atas situs Glitch, lalu pilih "new window" atau "next to code" untuk melihat pratinjau langsung kode yang sedang berjalan.

Jika kita memeriksa konsol browser web (Tekan F12 untuk menampilkan alat developer di browser), kita juga dapat melihat deskripsi model untuk model yang dimuat yang mencetak:

Dengan membandingkannya dengan kode Python kita di awal codelab ini, kita dapat mengonfirmasi bahwa ini adalah jaringan yang sama yang kita buat dengan 1 input padat dan satu lapisan padat dengan 1 node.

Selamat! Anda baru saja menjalankan model terlatih Python yang dikonversi di browser web.

7. Model yang tidak berkonversi

Terkadang, model yang lebih kompleks yang dikompilasi untuk menggunakan operasi yang kurang umum tidak akan didukung untuk konversi. TensorFlow.js versi berbasis browser adalah penulisan ulang TensorFlow secara menyeluruh dan oleh karena itu, saat ini kami tidak mendukung semua operasi tingkat rendah yang dimiliki TensorFlow C++ API (ada ribuan) - meskipun seiring waktu, lebih banyak operasi ditambahkan seiring pertumbuhan kami dan seiring operasi inti menjadi lebih stabil.

Pada saat penulisan, salah satu fungsi tersebut di TensorFlow Python yang menghasilkan op yang tidak didukung saat diekspor sebagai savedmodel adalah linalg.diag. Jika kita mencoba mengonversi savedmodel yang menggunakan ini di Python (yang mendukung operasi yang dihasilkan), kita akan melihat error yang mirip dengan yang ditunjukkan di bawah:

Di sini kita dapat melihat dengan warna merah bahwa panggilan linalg.diag dikompilasi untuk menghasilkan op bernama MatrixDiagV3 yang tidak didukung oleh TensorFlow.js di browser web pada saat penulisan codelab ini.

Perhatikan: Anda dapat menemukan daftar operasi TensorFlow.js yang saat ini didukung di sini. Perhatikan bahwa ini hanya untuk penerapan TensorFlow.js di browser web sisi klien dan tidak berlaku untuk TensorFlow.js versi Node.js yang menggunakan binding C++ yang sama dengan Python, sehingga semua model tersimpan dapat berjalan tanpa konversi di Node.js saat menggunakan TensorFlow.js di sisi server.

Apa yang harus dilakukan?

Ada dua opsi.

1. Terapkan op yang tidak ada ini di TensorFlow.js - kami adalah project open source dan menerima kontribusi untuk hal-hal seperti op baru. Baca panduan tentang cara menulis operasi baru untuk TensorFlow.js. Jika berhasil melakukannya, Anda dapat menggunakan tanda Skip_op_check pada konverter command line kami untuk mengabaikan error ini dan tetap melanjutkan konversi (konverter akan mengasumsikan bahwa operasi ini tersedia di build TensorFlow.js baru yang Anda buat dan yang mendukung operasi yang tidak ada).
2. Tentukan bagian kode Python yang menghasilkan operasi yang tidak didukung dalam file savedmodel yang Anda ekspor. Dalam sekumpulan kecil kode, hal ini mungkin mudah ditemukan, tetapi dalam model yang lebih kompleks, hal ini memerlukan penyelidikan yang cukup banyak karena saat ini tidak ada metode untuk mengidentifikasi panggilan fungsi Python tingkat tinggi yang menghasilkan operasi tertentu setelah dalam format file savedmodel. Setelah ditemukan, Anda dapat mengubahnya untuk menggunakan metode lain yang didukung.

8. Selamat

Selamat, Anda telah melakukan langkah pertama dalam menggunakan model Python melalui TensorFlow.js di browser web.

Rangkuman

Dalam lab kode ini, kita telah mempelajari cara:

1. Menyiapkan lingkungan Linux untuk menginstal TensorFlow berbasis Python
2. Mengekspor ‘SavedModel' Python
3. Menginstal konverter command line TensorFlow.js
4. Gunakan konverter command line TensorFlow.js untuk membuat file sisi klien yang diperlukan
5. Menggunakan file yang dihasilkan di aplikasi web nyata
6. Identifikasi model yang tidak akan melakukan konversi dan apa yang perlu diterapkan agar model tersebut dapat melakukan konversi pada masa mendatang.

Apa selanjutnya?

Jangan lupa untuk men-tag kami di platform apa pun yang Anda buat dengan hashtag #MadeWithTFJS agar berkesempatan ditampilkan di media sosial atau bahkan dipamerkan di acara TensorFlow mendatang. Kami ingin melihat apa yang Anda konversi dan gunakan di sisi klien di browser.

Codelab TensorFlow.js lainnya untuk memperdalam pemahaman

• Menulis jaringan neural dari awal di TensorFlow.js
• Membuat webcam pintar yang dapat mendeteksi objek
• Klasifikasi gambar kustom menggunakan pemelajaran transfer di TensorFlow.js

Situs untuk dipelajari

• Situs resmi TensorFlow.js
• Model siap pakai TensorFlow.js
• TensorFlow.js API
• Demo#MadeWithTFJS dari komunitas