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

1. Pengantar

Anda telah mengambil langkah pertama dengan TensorFlow.js, mencoba model siap pakai kami, atau bahkan mungkin membuatnya sendiri - tetapi Anda melihat beberapa riset canggih muncul di Python dan ingin tahu apakah model ini akan berjalan di browser web dan mewujudkan ide keren tersebut bagi jutaan orang dengan cara yang skalabel. Apakah terdengar familier? Jika ya, inilah CodeLab untuk Anda.

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

Yang akan Anda pelajari

Di codelab ini, Anda akan mempelajari cara menggunakan konverter command line TensorFlow.js untuk mem-port SaveModel yang dihasilkan Python ke format model.json yang diperlukan untuk dieksekusi pada sisi klien di browser web.

Khususnya:

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

Bayangkan bila Anda dapat melakukan beberapa penelitian yang baru dirilis dan menyediakan model tersebut bagi jutaan developer JS di seluruh dunia. Atau mungkin Anda akan menggunakan ini sendiri dalam kreasi Anda sendiri, yang kemudian dapat dialami oleh siapa saja di seluruh dunia jika dijalankan di browser web, karena tidak diperlukan pengaturan lingkungan atau dependensi yang kompleks. Siap untuk meretas? Ayo mulai!

Harap Diperhatikan: Codelab ini berfokus pada cara menggunakan dan memulai pengonversi TensorFlow.js sehingga tindakan pembuatan model itu sendiri akan menggunakan kode boilerplate sehingga kita bisa mendapatkan beberapa file untuk digunakan dalam tutorial. Untuk mempelajari cara membuat model Anda sendiri secara lebih mendetail, lihat lab kode yang lain terkait hal ini.

Bagikan apa yang Anda konversi dengan kami.

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

2. Apa yang dimaksud dengan TensorFlow.js?

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

Di mana data tersebut dapat digunakan?

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

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

TensorFlow.js juga mendukung beberapa backend dalam setiap lingkungan ini (lingkungan berbasis hardware sebenarnya yang dapat dijalankan di dalamnya seperti CPU atau WebGL, misalnya. "Backend" dalam konteks ini bukan berarti lingkungan sisi server - backend untuk eksekusi dapat menjadi sisi klien di WebGL) untuk memastikan kompatibilitas dan juga menjaga semuanya berjalan cepat. Saat ini TensorFlow.js mendukung:

• Eksekusi WebGL pada kartu grafis perangkat (GPU) - ini adalah cara tercepat untuk menjalankan model yang lebih besar (berukuran lebih dari 3 MB) dengan akselerasi GPU.
• Eksekusi Web Assembly (WASM) pada CPU - untuk meningkatkan performa CPU di berbagai perangkat, termasuk ponsel generasi lama. Cara ini lebih cocok untuk model yang lebih kecil (berukuran kurang dari 3MB) yang sebenarnya dapat dijalankan lebih cepat pada 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 ada untuk Anda.

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

Kekuatan super sisi klien

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

Privasi

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

Speed

Karena Anda tidak harus mengirim data ke server jarak jauh, inferensi (tindakan mengklasifikasikan data) bisa lebih cepat. Yang lebih bagus 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 seluruh dunia dapat mengklik link yang Anda kirimkan kepada mereka, membuka halaman web di browser mereka, dan memanfaatkan apa yang telah Anda buat. Tidak perlu penyiapan Linux sisi server yang rumit dengan driver CUDA dan masih banyak lagi, hanya untuk menggunakan sistem machine learning.

Biaya

Tidak ada server berarti satu-satunya hal yang perlu Anda bayar adalah CDN untuk menghosting file HTML, CSS, JS, dan model Anda. Biaya CDN jauh lebih murah daripada mempertahankan server (kemungkinan dengan kartu grafis terpasang) yang berjalan 24/7.

Fitur sisi server

Memanfaatkan implementasi Node.js TensorFlow.js akan mengaktifkan fitur-fitur berikut.

Dukungan penuh CUDA

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

Ukuran Model

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

IOT

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

Speed

Node.js ditulis dalam JavaScript, yang berarti ia mendapatkan manfaat hanya dari kompilasi waktu. Ini berarti bahwa Anda mungkin akan sering melihat peningkatan performa saat menggunakan Node.js karena akan dioptimalkan pada runtime, terutama untuk pra-pemrosesan yang mungkin Anda lakukan. Contoh yang bagus dapat dilihat dalam studi kasus ini yang menunjukkan bagaimana Hugging Face menggunakan Node.js untuk mendapatkan peningkatan performa 2x lipat untuk model natural language processing mereka.

Sekarang Anda telah memahami dasar-dasar TensorFlow.js, tempat TensorFlow.js dapat dijalankan, dan beberapa manfaatnya, mari kita mulai melakukan hal-hal yang bermanfaat dengan TensorFlow.js.

3. Menyiapkan sistem

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

Saat penulisan, kita dapat memilih image Ubuntu 18.04.4 LTS saat membuat instance mesin komputasi 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 setiap sistem.

Menginstal TensorFlow (versi Python)

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

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

Jendela terminal:

sudo apt update
sudo apt-get install python3

Ini akan memastikan kita telah menginstal Python 3 pada komputer. Python 3.4 atau yang lebih tinggi harus diinstal untuk menggunakan TensorFlow.

Untuk memverifikasi bahwa versi yang diinstal sudah benar, ketik hal berikut:

Jendela terminal:

python3 --version

Anda akan melihat beberapa output yang menunjukkan nomor versi seperti Python 3.6.9. Jika Anda melihat printer ini dicetak dengan benar dan nilainya lebih besar dari 3,4, kami siap untuk melanjutkan.

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

Jendela terminal:

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

Sekali lagi, kami dapat memverifikasi penginstalan pip3 melalui:

Jendela terminal:

pip3 --version

Saat menulis, kita melihat pip 20.2.3 yang dicetak ke terminal setelah menjalankan perintah ini.

Sebelum kita dapat menginstal TensorFlow, kita memerlukan paket Python "setuptools" ke versi 41.0.0 atau yang lebih tinggi. Jalankan perintah berikut untuk memastikannya diupdate ke versi terbaru:

Jendela terminal:

pip3 install -U setuptools

Terakhir, sekarang kita dapat menginstal TensorFlow untuk Python:

Jendela terminal:

pip3 install tensorflow

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

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

Mari kita periksa TensorFlow yang diinstal dengan benar. Buat file Python bernama test.py di direktori Anda 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 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 terinstal.

Peringatan: Jika Anda melihat banyak pop-up peringatan terkait numpy, cukup masukkan kode 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 - ini tidak masalah karena kami menginstal TensorFlow versi CPU, bukan yang GPU. Anda dapat mengabaikannya.

4. Membuat model Python

Langkah berikutnya dari codelab ini akan memandu pembuatan model Python sederhana untuk menunjukkan cara menyimpan model terlatih yang dihasilkan ini dalam "SavedModel" format untuk kemudian digunakan dengan pengonversi command line TensorFlow.js. Prinsipnya akan sama untuk model Python apa pun yang Anda coba konversi, tetapi kita harus membuat kode ini tetap sederhana sehingga semua orang dapat memahaminya.

Mari kita edit file test.py yang telah kita buat di bagian pertama dan perbarui kodenya menjadi 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 (input) x 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), sekarang kita akan melihat beberapa file dan folder baru yang dibuat di direktori saat ini:

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

Sekarang kita telah menghasilkan file yang perlu digunakan oleh pengonversi TensorFlow.js untuk mengonversi model ini agar dapat berjalan di browser.

5. Mengonversi SaveModel ke format TensorFlow.js

Menginstal pengonversi TensorFlow.js

Untuk menginstal konverter, jalankan perintah berikut:

Jendela terminal:

pip3 install tensorflowjs

Itu cukup 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 secara eksplisit meneruskan parameter ke konverter:

Jendela terminal:

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

Apa yang terjadi? 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 mencatat bahwa kami mengimpor Keras dan menggunakan API lapisan tingkat yang lebih tinggi untuk membuat model. Jika Anda belum menggunakan Keras di kode Python, Anda mungkin ingin 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 format lain tersebut lebih lanjut di sini.

Dua parameter berikutnya menentukan folder tempat model tersimpan berada - dalam demo di atas, kita menentukan direktori saat ini, dan terakhir, menentukan direktori yang ingin dijadikan sebagai output konversi, yang kita tentukan di atas sebagai folder bernama "predict_houses_tfjs" pada direktori saat ini.

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

• model.json
• Grup1-shard1of1.bin

Ini adalah file yang kita perlukan untuk menjalankan model di {i>browser<i} web. Simpan file ini karena kami akan menggunakannya di bagian berikutnya.

Perlu Diperhatikan: File TensorFlow.js sisi klien akan selalu terdiri dari model.json dan setidaknya satu file .bin. File biner di-sharding dalam potongan-potongan 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 sehingga kita dapat mengaksesnya melalui halaman web. Untuk demo ini, kita akan menggunakan Glitch.com agar mudah untuk Anda ikuti. Namun, jika Anda berasal dari latar belakang teknik web, Anda dapat memilih untuk menjalankan server http sederhana pada instance server Ubuntu Anda saat ini untuk melakukan ini. Anda yang menentukan.

Mengupload file ke Glitch

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

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

Setelah diedit, hasilnya akan terlihat seperti ini (perhatikan bagaimana jalur server utama telah dihapus sehingga hanya nama file yang diupload yang dihasilkan yang dipertahankan): 7. Sekarang, simpan dan upload file model.json yang telah diedit ini ke glitch dengan mengklik aset, lalu klik "upload aset" (penting). Jika Anda tidak menggunakan tombol fisik, lalu 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 akan diasumsikan saat TensorFlow.js mencoba mendownload file biner untuk model tertentu. Jika telah melakukannya dengan benar, Anda akan melihat 2 file dalam folder assets seperti ini:

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

Peringatan: Jika Anda memutuskan untuk tidak menggunakan Glitch.com, tetapi menjalankan server web sendiri, Anda tidak perlu mengedit file model.json selama Anda menayangkan file dari direktori yang sama di server web Anda. Cukup pastikan keduanya berada di folder yang sama dan dapat diakses dari kode sisi klien.

Memuat model

Sekarang 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 dan ganti konten file ini dengan kode berikut setelah Anda mengubah const MODEL_URL agar mengarah ke link Glitch.com yang dihasilkan 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 agar mengarah ke jalur model.json akan menghasilkan output yang ditampilkan di bawah.

Perlu Diperhatikan: Untuk menjalankan kode Anda, cukup klik "show" di bagian atas situs Glitch, lalu pilih "new window" (jendela baru) atau "di samping kode" untuk melihat pratinjau langsung dari kode yang dijalankan.

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

Membandingkan ini dengan kode Python di awal codelab ini, kita dapat mengonfirmasi bahwa ini adalah jaringan yang sama dengan 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 melakukan konversi

Ada kalanya model yang lebih kompleks yang dikompilasi untuk menggunakan operasi yang kurang umum tidak akan didukung untuk konversi. Versi TensorFlow.js yang berbasis browser adalah penulisan ulang lengkap dari TensorFlow dan oleh karena itu kami saat ini tidak mendukung semua operasi level rendah yang dimiliki TensorFlow C++ API (ada 1.000) - meskipun dari waktu ke waktu, semakin banyak yang ditambahkan seiring kami berkembang dan saat operasi inti menjadi lebih stabil.

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

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

Perlu Diperhatikan: Anda dapat menemukan daftar operasi TensorFlow.js yang saat ini didukung di sini. Perlu diperhatikan bahwa hal ini hanya berlaku untuk implementasi browser web sisi klien TensorFlow.js dan tidak berlaku untuk TensorFlow.js versi Node.js yang menggunakan binding C++ yang sama seperti yang dimiliki 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. Implementasikan operasi yang hilang ini di TensorFlow.js - kami adalah project open source dan menyambut kontribusi untuk hal-hal seperti operasi baru. Lihat panduan ini 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 melanjutkan konversi dengan cara apa pun (hal ini akan mengasumsikan bahwa operasi ini tersedia di build baru TensorFlow.js yang Anda buat dan memiliki operasi yang tidak ada yang didukung).
2. Tentukan bagian kode Python yang menghasilkan operasi yang tidak didukung di file savedmodel yang Anda ekspor. Dalam sekumpulan kecil kode, hal ini mungkin mudah ditemukan, tetapi dalam model yang lebih kompleks, hal ini dapat memerlukan penyelidikan karena saat ini tidak ada metode untuk mengidentifikasi panggilan fungsi Python tingkat tinggi yang menghasilkan operasi tertentu sekali dalam format file savedmodel. Namun, setelah ditemukan, Anda berpotensi mengubahnya untuk menggunakan metode lain yang didukung.

8. Selamat

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

Rangkuman

Dalam codelab ini, kita telah mempelajari cara:

1. Menyiapkan lingkungan Linux untuk menginstal TensorFlow berbasis Python
2. Mengekspor 'SavedModel' Python
3. Menginstal pengonversi command line TensorFlow.js
4. Menggunakan pengonversi command line TensorFlow.js untuk membuat file sisi klien yang diperlukan
5. Menggunakan file yang dihasilkan dalam aplikasi web yang sebenarnya
6. Identifikasi model yang tidak akan menghasilkan konversi dan apa yang perlu diimplementasikan untuk memungkinkan model tersebut melakukan konversi di masa mendatang.

Apa selanjutnya?

Jangan lupa untuk memberi kami tag pada produk apa pun yang Anda buat menggunakan #MadeWithTFJS agar dapat ditampilkan di media sosial atau bahkan dipajang di acara TensorFlow mendatang. Kami ingin melihat apa yang Anda konversi dan gunakan dari sisi klien pada browser!

Codelab TensorFlow.js lainnya untuk mempelajari lebih dalam

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

Situs yang bisa dilihat

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