Cara menggunakan model TensorFlow ke pengeluaran menggunakan TF Serving

Pengenalan

Meletakkan model Pembelajaran Mesin (ML) ke pengeluaran telah menjadi topik yang berulang dan popular. Banyak syarikat dan kerangka kerja menawarkan penyelesaian berbeza yang bertujuan mengatasi masalah ini.

Untuk mengatasi masalah ini, Google melepaskan TensorFlow (TF) Serving dengan harapan dapat menyelesaikan masalah penggunaan model ML ke produksi.

Bahagian ini menawarkan tutorial langsung mengenai penyediaan Jaringan Segmentasi Semantik Konvolusional yang telah dilatih. Pada akhir artikel ini, Anda akan dapat menggunakan TF Serving untuk menyebarkan dan membuat permintaan ke Deep CNN yang terlatih dalam TF. Juga, saya akan membentangkan gambaran keseluruhan blok utama Serving TF, dan saya akan membincangkan APInya dan bagaimana semuanya berfungsi.

Satu perkara yang anda akan perhatikan dengan segera adalah bahawa ia memerlukan sedikit kod untuk benar-benar melayani model TF. Sekiranya anda ingin mengikuti tutorial dan menjalankan contoh pada mesin anda, ikuti seperti sedia kala. Tetapi, jika anda hanya ingin mengetahui mengenai TensorFlow Serving, anda boleh menumpukan perhatian pada dua bahagian pertama.

Karya ini menekankan beberapa kerja yang kita lakukan di sini di Daitan Group.

TensorFlow Serving Library - Gambaran Keseluruhan

Mari luangkan sedikit masa untuk memahami bagaimana TF Serving mengendalikan kitaran hidup penuh model ML. Di sini, kita akan membahas (pada tahap tinggi) setiap blok bangunan utama TF Serving. Matlamat bahagian ini adalah untuk memberikan pengenalan lembut kepada TF Serving APIs. Untuk gambaran mendalam, sila pergi ke halaman dokumentasi Serving TF.

TensorFlow Serving terdiri daripada beberapa abstraksi. Abstraksi ini menerapkan API untuk tugas yang berbeza. Yang paling penting adalah Servable, Loader, Source, dan Manager. Mari kita lihat bagaimana mereka berinteraksi.

Ringkasnya, kitaran hidup penyampaian bermula apabila TF Serving mengenal pasti model pada cakera. Komponen Sumber mengurusnya. Ia bertanggungjawab untuk mengenal pasti model baru yang harus dimuat. Dalam praktiknya, ia mengawasi sistem fail untuk mengenal pasti kapan versi model baru sampai ke cakera. Apabila melihat versi baru, ia akan berjalan dengan membuat Loader untuk versi model tertentu.

Ringkasnya, Loader mengetahui hampir semua perkara mengenai model tersebut. Ini termasuk bagaimana memuatkannya dan bagaimana memperkirakan sumber daya yang diperlukan model, seperti memori RAM dan GPU yang diminta. Loader mempunyai penunjuk ke model pada cakera bersama dengan semua meta-data yang diperlukan untuk memuatkannya. Tetapi ada tangkapan di sini: Loader tidak dibenarkan memuatkan modelnya sebentar lagi.

Setelah membuat Loader, Sumber mengirimkannya kepada Pengurus sebagai Versi Aspired.

Setelah menerima Versi Aspired model, Pengurus meneruskan proses penyampaian. Di sini, ada dua kemungkinan. Salah satunya ialah versi model pertama didorong untuk digunakan. Dalam keadaan ini, Pengurus akan memastikan bahawa sumber yang diperlukan ada. Setelah mereka berada, Pengurus memberikan izin kepada Loader untuk memuatkan model.

Yang kedua ialah kita mendorong versi baru dari model yang ada. Dalam kes ini, Pengurus harus berunding dengan plugin Dasar Dasar sebelum melangkah lebih jauh. Dasar Versi menentukan bagaimana proses memuat versi model baru berlaku.

Secara khusus, ketika memuat versi baru model, kita dapat memilih antara menjaga (1) ketersediaan atau (2) sumber. Dalam kes pertama, kami tertarik untuk memastikan sistem kami selalu tersedia untuk permintaan pelanggan masuk. Kami tahu bahawa Pengurus membenarkan Pemuat memuatkan grafik baru dengan bobot baru.

Pada ketika ini, kami mempunyai dua versi model yang dimuat pada masa yang sama. Tetapi Pengurus memunggah versi lama hanya setelah memuat selesai dan selamat untuk beralih antara model.

Sebaliknya, jika kita ingin menjimatkan sumber dengan tidak mempunyai penyangga tambahan (untuk versi baru), kita dapat memilih untuk mengekalkan sumber. Mungkin berguna untuk model yang sangat berat untuk memiliki sedikit jurang ketersediaan, sebagai pertukaran untuk menyimpan memori.

Pada akhirnya, apabila pelanggan meminta pegangan untuk model, Pengurus mengembalikan pegangan ke Servable.

Dengan gambaran keseluruhan ini, kami siap untuk menyelami aplikasi dunia nyata. Pada bahagian seterusnya, kami menerangkan cara melayani Rangkaian Neural Konvolusional (CNN) menggunakan TF Serving.

Mengeksport Model untuk Berkhidmat

Langkah pertama untuk melayani model ML yang dibina di TensorFlow adalah memastikannya dalam format yang betul. Untuk melakukan itu, TensorFlow menyediakan kelas SavedModel.

SavedModel adalah format serialisasi sejagat untuk model TensorFlow. Sekiranya anda biasa dengan TF, anda mungkin telah menggunakan TensorFlow Saver untuk mengekalkan pemboleh ubah model anda.

TensorFlow Saver menyediakan fungsi untuk menyimpan / memulihkan fail pusat pemeriksaan model ke / dari cakera. Sebenarnya, SavedModel membungkus TensorFlow Saver dan ia dimaksudkan sebagai cara standard mengeksport model TF untuk disajikan.

Objek SavedModel mempunyai beberapa ciri yang bagus.

Pertama, ia membolehkan anda menyimpan lebih dari satu meta-grafik ke satu objek SavedModel. Dengan kata lain, ini membolehkan kita mempunyai grafik yang berbeza untuk tugas yang berbeza.

Contohnya, andaikan anda baru sahaja melatih model anda. Dalam kebanyakan situasi, untuk membuat kesimpulan, grafik anda tidak memerlukan operasi khusus latihan. Ops ini mungkin merangkumi pemboleh ubah pengoptimum, tensor penjadualan kadar pembelajaran, ops pra-pemprosesan tambahan, dan sebagainya.

Lebih-lebih lagi, anda mungkin ingin menyajikan versi grafik dalam kuantiti untuk penggunaan mudah alih.

Dalam konteks ini, SavedModel membolehkan anda menyimpan grafik dengan konfigurasi yang berbeza. Dalam contoh kami, kami akan mempunyai tiga grafik yang berbeza dengan tag yang sesuai seperti "latihan", "inferensi", dan "mudah alih". Ketiga-tiga graf ini juga mempunyai sekumpulan pemboleh ubah yang sama - yang menekankan kecekapan memori.

Belum lama ini, ketika kami ingin menggunakan model TF pada peranti mudah alih, kami perlu mengetahui nama tensor input dan output untuk memberi makan dan mendapatkan data ke / dari model tersebut. Ini memerlukan pengaturcara untuk mencari tensor yang mereka perlukan di antara semua tensor grafik. Sekiranya tensor tidak disebutkan namanya dengan tepat, tugasnya akan sangat membosankan.

Untuk mempermudah, SavedModel menawarkan sokongan untuk SignatureDefs. Ringkasnya, SignatureDefs menentukan tandatangan pengiraan yang disokong oleh TensorFlow. Ini menentukan tensor input dan output yang tepat untuk graf pengiraan. Ringkasnya, dengan tanda tangan ini anda dapat menentukan node yang tepat untuk digunakan untuk input dan output.

Untuk menggunakan API perkhidmatan terbina dalam, TF Serving memerlukan model untuk memasukkan satu atau lebih SignatureDefs.

Untuk membuat tandatangan seperti itu, kita perlu memberikan definisi untuk input, output, dan nama kaedah yang diinginkan. Input dan Output mewakili pemetaan dari rentetan ke objek TensorInfo (lebih lanjut mengenai ini). Di sini, kami menentukan tensor lalai untuk memberi makan dan menerima data ke dan dari grafik. The method_name parameter mensasarkan salah satu daripada API TF peringkat tinggi yang disediakan.

Pada masa ini, terdapat tiga API yang disajikan: Klasifikasi, Ramalan, dan Regresi. Setiap definisi tandatangan sepadan dengan RPC API tertentu. The Classification SegnatureDef digunakan untuk Classify RPC API. Predict SegnatureDef digunakan untuk Predict RPC API, dan di.

Untuk tandatangan Klasifikasi, mesti ada tensor input (untuk menerima data) dan sekurang-kurangnya satu daripada dua kemungkinan tensor output: kelas dan / atau skor. Regression SignatureDef memerlukan tepat satu tensor untuk input dan satu lagi untuk output. Terakhir, tandatangan Predict memungkinkan untuk mendapatkan jumlah tegangan input dan output yang dinamik.

Di samping itu, SavedModel menyokong penyimpanan aset untuk kes di mana inisialisasi ops bergantung pada fail luaran. Juga, ia mempunyai mekanisme untuk membersihkan peranti sebelum membuat SavedModel.

Sekarang, mari kita lihat bagaimana kita dapat melakukannya dalam praktik.

Menetapkan persekitaran

Sebelum kita memulakan, klon pelaksanaan TensorFlow DeepLab-v3 ini dari Github.

DeepLab adalah ConvNet segmentasi semantik terbaik Google. Pada asasnya, rangkaian mengambil gambar sebagai input dan mengeluarkan gambar seperti topeng yang memisahkan objek tertentu dari latar belakang.

Versi ini dilatih pada set data segmentasi Pascal VOC. Oleh itu, ia dapat membahagikan dan mengenali sehingga 20 kelas. Sekiranya anda ingin mengetahui lebih lanjut mengenai Segmentasi Semantik dan DeepLab-v3, lihat Diving ke Rangkaian Segmentasi Semantik Konvolusional dan Deeplab_V3.

Semua fail yang berkaitan dengan penyampaian berada di: ./deeplab_v3/serving/. Di sana, anda akan menemui dua fail penting: deeplab_saved_model.py dan deeplab_client.ipynb

Sebelum melangkah lebih jauh, pastikan untuk memuat turun model terlatih Deeplab-v3. Pergi ke repositori GitHub di atas, klik pada pautan pusat pemeriksaan, dan muat turun folder bernama 16645 / .

Pada akhirnya, anda harus mempunyai folder bernama tboard_logs / dengan folder 16645 / diletakkan di dalamnya.

Sekarang, kita perlu membuat dua persekitaran maya Python. Satu untuk Python 3 dan satu lagi untuk Python 2. Untuk setiap env, pastikan untuk memasang pergantungan yang diperlukan. Anda boleh menemuinya dalam fail serve_requirements.txt dan client_requirements.txt.

Kami memerlukan dua enjin Python kerana model kami, DeepLab-v3, dikembangkan di bawah Python 3. Walau bagaimanapun, API TensorFlow Serving Python hanya diterbitkan untuk Python 2. Oleh itu, untuk mengeksport model dan menjalankan perkhidmatan TF, kami menggunakan Python 3 env . Untuk menjalankan kod klien menggunakan TF Serving python API, kami menggunakan paket PIP (hanya tersedia untuk Python 2).

Perhatikan bahawa anda boleh melepaskan Python 2 env dengan menggunakan Serving APIs dari bazel. Rujuk kepada Pemasangan Serving TF untuk maklumat lebih lanjut.

Dengan langkah itu selesai, mari kita mulakan dengan perkara yang sangat penting.

Bagaimana hendak melakukannya

Untuk menggunakan SavedModel, TensorFlow menyediakan kelas utiliti peringkat tinggi yang mudah digunakan yang dipanggil SavedModelBuilder. Kelas SavedModelBuilder menyediakan fungsi untuk menyimpan pelbagai grafik meta, pemboleh ubah yang berkaitan, dan aset.

Mari kita teliti contoh bagaimana mengeksport model CNN Deep Segmentation untuk disajikan.

Seperti yang disebutkan di atas, untuk mengeksport model, kami menggunakan kelas SavedModelBuilder. Ia akan menghasilkan fail penyangga protokol SavedModel bersama dengan pemboleh ubah dan aset model (jika perlu).

Mari membedah kodnya.

The SavedModelBuilder menerima (sebagai input) direktori tempat menyimpan data model. Di sini, variabel export_path adalah gabungan dari base_path_base dan model_version . Hasilnya, versi model yang berbeza akan disimpan dalam direktori berasingan di dalam folder export_path_base .

Katakanlah kami mempunyai versi dasar model kami dalam pengeluaran, tetapi kami ingin menggunakan versi baru dari model ini. Kami telah meningkatkan ketepatan model kami dan ingin menawarkan versi baru ini kepada pelanggan kami.

Untuk mengeksport versi lain dari grafik yang sama, kita hanya dapat menetapkan FLAGS.model_version ke nilai bilangan bulat yang lebih tinggi. Kemudian folder yang berbeza (memegang versi baru model kami) akan dibuat di dalam folder export_path_base .

Sekarang, kita perlu menentukan input dan output Tensor model kita. Untuk melakukan itu, kami menggunakan SignatureDefs. Tandatangan menentukan jenis model yang ingin kita eksport. Ia menyediakan pemetaan dari rentetan (nama Tensor logik) ke objek TensorInfo. Ideanya ialah, daripada merujuk kepada nama tensor sebenar untuk input / output, klien dapat merujuk kepada nama logik yang ditentukan oleh tandatangan.

Untuk menyajikan Semantic Segmentation CNN, kami akan membuat Predict Signature . Perhatikan bahawa fungsi build_signature_def () mengambil pemetaan untuk tensor input dan output serta API yang diinginkan.

SignatureDef memerlukan spesifikasi: input, output, dan nama kaedah. Perhatikan bahawa kami menjangkakan tiga nilai untuk input - gambar, dan dua tensor lagi yang menentukan dimensinya (tinggi dan lebar). Untuk output , kami menentukan hanya satu hasil - topeng output segmentasi.

Perhatikan bahawa rentetan 'gambar', 'tinggi', 'lebar' dan 'segmen_ peta' bukan tensor. Sebaliknya, ia adalah nama logik yang merujuk kepada tensor input_tensor , image_height_tensor , dan image_width_tensor . Oleh itu, mereka boleh menjadi rentetan unik yang anda suka.

Juga, pemetaan dalam SignatureDefs berkaitan dengan objek protobuf TensorInfo, bukan tensor sebenar. Untuk membuat objek TensorInfo, kami menggunakan fungsi utiliti: tf.saved_model.utils.build_tensor_info (tensor) .

Iaitu ia. Sekarang kita memanggil fungsi add_meta_graph_and_variables () untuk membina objek buffer protokol SavedModel. Kemudian kami menjalankan kaedah save () dan ia akan meneruskan snapshot model kami ke disk yang mengandungi pemboleh ubah dan aset model.

Kita sekarang boleh menjalankan deeplab_saved_model.py untuk mengeksport model kita.

Sekiranya semuanya berjalan lancar, anda akan melihat folder ./serving/versions/1 . Perhatikan bahawa '1' mewakili versi model semasa. Di dalam setiap sub-direktori versi, anda akan melihat fail berikut:

  • save_model.pb atau save_model.pbtxt. Ini adalah fail SavedModel yang bersiri. Ia merangkumi satu atau lebih definisi grafik model, serta definisi tanda tangan.
  • Pemboleh ubah. Folder ini mengandungi pemboleh ubah bersiri grafik.

Sekarang, kami bersedia melancarkan pelayan model kami. Untuk melakukannya, jalankan:

$ tensorflow_model_server --port=9000 --model_name=deeplab --model_base_path=

The model_base_path merujuk kepada mana model yang dieksport diselamatkan. Kami juga tidak menentukan folder versi di jalan. Kawalan pemodelan model dikendalikan oleh TF Serving.

Menjana Permintaan Pelanggan

Kod pelanggan sangat mudah. Lihatlah di: deeplab_client.ipynb.

Pertama, kita membaca gambar yang ingin kita hantar ke pelayan dan menukarnya ke format yang betul.

Seterusnya, kami membuat rintisan gRPC. Stub ini membolehkan kita memanggil kaedah pelayan jauh. Untuk melakukannya, kami membuat kelas beta_create_PredictionService_stub dari modul prediction_service_pb2 . Pada ketika ini, rintisan memegang logik yang diperlukan untuk memanggil prosedur jarak jauh (dari pelayan) seolah-olah mereka tempatan.

Sekarang, kita perlu membuat dan menetapkan objek permintaan. Oleh kerana pelayan kami mengimplementasikan TensorFlow Predict API, kami perlu menguraikan permintaan Predict. Untuk mengeluarkan permintaan Predict, pertama, kami memberi contoh kelas PredictRequest dari modul prediksi_pb2 . Kami juga perlu menentukan model_spec.name dan model_spec.signature_name parameter. Yang nama param adalah 'MODEL_NAME hujah yang kita ditakrifkan apabila kami melancarkan pelayan. Dan signature_name merujuk kepada nama logik diberikan kepada signature_def_map () parameter daripada add_meta_graph rutin ().

Seterusnya, kita mesti menyediakan data input seperti yang ditentukan dalam tandatangan pelayan. Ingat bahawa, di pelayan, kami menentukan Predict API untuk mengharapkan gambar serta dua skalar (tinggi dan lebar gambar). Untuk memasukkan data input ke objek permintaan, TensorFlow menyediakan utiliti tf.make_tensor_proto () . Kaedah ini membuat objek TensorProto dari objek numpy / Python. Kita dapat menggunakannya untuk memasukkan gambar dan dimensinya ke objek permintaan.

Nampaknya kami sudah bersedia untuk memanggil pelayan. Untuk melakukan itu, kami memanggil kaedah Predict () (menggunakan rintisan) dan meneruskan objek permintaan sebagai argumen.

Untuk permintaan yang mengembalikan satu respons, gRPC menyokong kedua-duanya: panggilan segerak dan tidak segerak. Oleh itu, jika anda ingin melakukan beberapa kerja semasa permintaan sedang diproses, kami dapat memanggil Predict.future () dan bukannya Predict () .

Sekarang kita dapat mengambil dan menikmati hasilnya.

Harap anda menyukai artikel ini. Terima kasih untuk membaca!

Sekiranya anda mahukan lebih banyak, lihat:

Cara melatih FaceID ConvNet anda sendiri menggunakan pelaksanaan TensorFlow Eager

Wajah ada di mana-mana - dari foto dan video di laman web media sosial, hingga aplikasi keselamatan pengguna sepertiā€¦ medium.freecodecamp.org Menyelam ke dalam Jaringan Segmentasi Semantik Konvolusional dan Deeplab_V3

Jaringan Neural Konvolusional Dalam (DCNN) telah mencapai kejayaan yang luar biasa dalam pelbagai aplikasi Computer Visionā€¦ medium.freecodecamp.org