Membuat aplikasi iOS untuk memprediksi nilai

1. Sebelum memulai

Dalam codelab ini, Anda akan mempelajari cara menjalankan inferensi regresi dari aplikasi iOS menggunakan TensorFlow Serve dengan REST dan gRPC.

Prasyarat

• Pengetahuan dasar tentang pengembangan iOS dengan Swift
• Pengetahuan dasar tentang machine learning dengan TensorFlow, seperti pelatihan dan deployment
• Pengetahuan dasar tentang Colaboratory
• Pengetahuan dasar tentang terminal, Python, dan Docker

Yang akan Anda pelajari

• Cara melatih model regresi dengan TensorFlow.
• Cara membuat aplikasi iOS sederhana dan membuat prediksi dengan model terlatih melalui TensorFlow Serve (REST dan gRPC).
• Cara menampilkan hasil di UI.

Yang Anda butuhkan

• Akses ke Colab
• Versi terbaru Xcode
• CocoaPods
• Docker
• Dash
• Compiler buffer protokol (hanya diperlukan jika ingin membuat ulang stub gRPC sendiri)
• Plugin generator kode yang cepat-gRPC (hanya diperlukan jika Anda ingin membuat stub gRPC sendiri)

Catatan: Mulai bulan Maret 2022, dukungan M1 untuk Penayangan TensorFlow masih dalam pengembangan, jadi Anda tidak dapat menjalankan Penayangan TensorFlow di Mac M1. Namun, Anda tetap dapat menjalankan aplikasi iOS di Mac M1.

2. Memulai persiapan

Untuk mendownload kode codelab ini:

1. Buka repositori GitHub untuk codelab ini.
2. Klik Code > Download zip untuk mendownload semua kode untuk codelab ini.

3. Ekstrak file zip yang didownload untuk mengekstrak folder root codelabs dengan semua resource yang Anda butuhkan.

Untuk codelab ini, Anda hanya memerlukan file dalam subdirektori TFServing/RegressioniOS di repositori, yang berisi dua folder:

• Folder starter berisi kode awal yang Anda buat untuk codelab ini.
• Folder finished berisi kode yang sudah selesai untuk aplikasi contoh yang telah selesai.

3 Mendownload dependensi untuk project

Mendownload pod yang diperlukan

• Di folder starter/iOS, jalankan:

pod install

Cocoapods akan menginstal semua library yang diperlukan dan membuat file regression.xcworkspace baru.

4. Menjalankan aplikasi awal

• Klik dua kali file regression.xcworkspace untuk membuka Xcode.

Catatan: Codelab ini mengasumsikan bahwa Anda menggunakan Simulator. Jika Anda menggunakan iPhone fisik, ubah localhost dalam kode ke alamat IP server Anda, yang menjalankan Penayangan TensorFlow.

Menjalankan dan menjelajahi aplikasi

1. Ubah target perangkat ke iPhone apa pun, seperti iPhone 13.

2. Klik 'Run', lalu tunggu Xcode mengompilasi project dan mulai aplikasi awal di Simulator.

Catatan: Selama kompilasi, Xcode mengeluarkan sejumlah peringatan tentang library CNIOBoringSSL dan gRPC-Swift. Anda dapat mengabaikannya.

UI-nya cukup sederhana. Ada kotak teks tempat Anda dapat mengetik nomor, yang dikirim ke backend Penayangan TensorFlow dengan REST atau gRPC. Backend melakukan regresi pada nilai input dan menampilkan nilai yang diprediksi ke aplikasi klien, yang menampilkan hasilnya di UI lagi.

Jika Anda memasukkan angka dan mengklik Infer, tidak ada yang terjadi karena aplikasi belum dapat berkomunikasi dengan backend.

5. Melatih model regresi sederhana dengan TensorFlow

Regresi adalah salah satu tugas ML yang paling umum. Tujuannya adalah memprediksi satu kuantitas berkelanjutan berdasarkan input. Misalnya, berdasarkan cuaca hari ini, prediksi suhu tertinggi besok.

Melatih model regresi

1. Buka link ini di browser Anda.

Colab memuat notebook Python.

2. Di notebook Python, impor library TensorFlow dan NumPy, lalu buat enam pasang data pelatihan dengan xs sebagai input dan ys sebagai label.

Jika Anda memetakan titik data ini pada grafik, titik data tersebut sebenarnya berada pada garis lurus karena dihasilkan dari persamaan y = 2x -1.

3. Gunakan Keras API untuk membuat jaringan neural dua lapis yang sederhana guna memprediksi nilai y berdasarkan input x, lalu mengompilasi dan menyesuaikan model tersebut.

xs = np.array([-1.0,  0.0, 1.0, 2.0, 3.0, 4.0], dtype=float)
ys = np.array([-3.0, -1.0, 1.0, 3.0, 5.0, 7.0], dtype=float)

model = tf.keras.Sequential([
   tf.keras.layers.Dense(units=10, input_shape=[1]),
   tf.keras.layers.Dense(units=1),
   ])

model.compile(optimizer='sgd',
             loss='mean_squared_error')

history = model.fit(xs, ys, epochs=500, verbose=0)

print("Finished training the model")

print(model.predict([10.0]))

Model memerlukan waktu beberapa detik untuk dilatih dan Anda dapat melihat nilai yang diprediksi untuk input 10 adalah 18.999996, yang merupakan prediksi yang cukup bagus karena kebenaran dasar adalah 2 * 10 -1 = 19.

4. Mengekspor model:

model_dir = './regression/'
version = 123
export_path = os.path.join(model_dir, str(version))
model.save(export_path, save_format="tf")
print('\nexport_path = {}'.format(export_path))
!ls -l {export_path}

5. Kompresi SaveModel yang diekspor menjadi satu file regression.zip:

!zip -r regression.zip ./regression

6. Klik Runtime > Run all di menu navigasi untuk menjalankan notebook, lalu tunggu hingga lari selesai.
7. Klik File, lalu download file regression.zip.

6. Men-deploy model regresi dengan Penayangan TensorFlow

• Untuk men-deploy model dengan TensorFlow Serve, buka kompresi file regression.zip yang didownload dengan alat dekompresi, seperti 7-Zip.

Struktur folder akan terlihat seperti gambar ini:

Anda dapat merujuk ke folder regression sebagai folder SavedModel. 123 adalah contoh nomor versi. Jika mau, Anda dapat memilih nomor lain.

Memulai TensorFlow Serving

• Di terminal Anda, mulai Penayangan TensorFlow dengan Docker, tetapi ganti placeholder PATH/TO/SAVEDMODEL dengan jalur absolut folder regression di komputer Anda.

docker pull tensorflow/serving

docker run -it --rm -p 8500:8500 -p 8501:8501 -v "PATH/TO/SAVEDMODEL:/models/regression" -e MODEL_NAME=regression tensorflow/serving

Docker otomatis mendownload gambar Penayangan TensorFlow terlebih dahulu, yang memerlukan waktu satu menit. Setelah itu, Penayangan TensorFlow akan dimulai. Log akan terlihat seperti cuplikan kode ini:

2022-02-25 06:01:12.513231: I external/org_tensorflow/tensorflow/cc/saved_model/loader.cc:206] Restoring SavedModel bundle.
2022-02-25 06:01:12.585012: I external/org_tensorflow/tensorflow/core/platform/profile_utils/cpu_utils.cc:114] CPU Frequency: 3000000000 Hz
2022-02-25 06:01:13.395083: I external/org_tensorflow/tensorflow/cc/saved_model/loader.cc:190] Running initialization op on SavedModel bundle at path: /models/ssd_mobilenet_v2_2/123
2022-02-25 06:01:13.837562: I external/org_tensorflow/tensorflow/cc/saved_model/loader.cc:277] SavedModel load for tags { serve }; Status: success: OK. Took 1928700 microseconds.
2022-02-25 06:01:13.877848: I tensorflow_serving/servables/tensorflow/saved_model_warmup_util.cc:59] No warmup data file found at /models/ssd_mobilenet_v2_2/123/assets.extra/tf_serving_warmup_requests
2022-02-25 06:01:13.929844: I tensorflow_serving/core/loader_harness.cc:87] Successfully loaded servable version {name: regression version: 123}
2022-02-25 06:01:13.985848: I tensorflow_serving/model_servers/server_core.cc:486] Finished adding/updating models
2022-02-25 06:01:13.985987: I tensorflow_serving/model_servers/server.cc:367] Profiler service is enabled
2022-02-25 06:01:13.988994: I tensorflow_serving/model_servers/server.cc:393] Running gRPC ModelServer at 0.0.0.0:8500 ...
[warn] getaddrinfo: address family for nodename not supported
2022-02-25 06:01:14.033872: I tensorflow_serving/model_servers/server.cc:414] Exporting HTTP/REST API at:localhost:8501 ...
[evhttp_server.cc : 245] NET_LOG: Entering the event loop ...

Catatan: Setelah memulai gambar docker Penayangan TensorFlow, Anda dapat membuka http://localhost:8501/v1/models/<MODEL_NAME>/metadata untuk memeriksa detail tensor input dan output. Dalam codelab ini, ganti <MODEL_NAME> dengan regression.

7. Menghubungkan aplikasi iOS dengan Penayangan TensorFlow melalui REST

Backend sudah siap, jadi Anda dapat mengirim permintaan klien ke Penayangan TensorFlow untuk membuat prediksi. Ada dua cara untuk mengirim permintaan ke Penayangan TensorFlow:

• REST
• gRPC

Mengirim permintaan dan menerima respons dengan REST

Ada tiga langkah sederhana:

1. Buat permintaan REST.
2. Kirim permintaan REST ke Penayangan TensorFlow.
3. Ekstrak hasil prediksi dari respons REST dan render UI.

Anda akan melakukan langkah-langkah berikut dalam file iOS/regression/ViewController.swift.

Membuat permintaan REST

1. Saat ini, fungsi doInference() tidak mengirimkan permintaan REST ke Penayangan TensorFlow. Anda perlu mengimplementasikan cabang REST ini untuk membuat permintaan REST:

if (connectionMode[picker.selectedRow(inComponent: 0)] == "REST") {
    print("Using REST")
    // TODO: Add code to send a REST request to TensorFlow Serving.

}

Penayangan TensorFlow mengharapkan permintaan POST yang berisi nilai tunggal, sehingga Anda perlu menyematkan nilai input dalam JSON, yang merupakan payload permintaan.

2. Tambahkan kode ini ke cabang REST:

//Create the REST request.
let json: [String: Any] = ["signature_name" : "serving_default", "instances" : [[value]]]

let jsonData = try? JSONSerialization.data(withJSONObject: json)

let url = URL(string: "http://localhost:8501/v1/models/regression:predict")!
var request = URLRequest(url: url)
request.httpMethod = "POST"

// Insert JSON data into the request.
request.httpBody = jsonData

Mengirim permintaan REST ke Penayangan TensorFlow

• Tambahkan kode ini segera setelah kode di cabang REST:

// Send the REST request.
let task = URLSession.shared.dataTask(with: request) { data, response, error in
    guard let data = data, error == nil else {
        print(error?.localizedDescription ?? "No data")
        return
    }

    // TODO: Add code to process the response.
}

task.resume()

Memproses respons REST dari TensorFlow Serving

• Tambahkan kode ini ke cuplikan kode sebelumnya tepat setelah komentar TODO: Add code to process the response.:

// Process the REST response.
let results: RESTResults = try! JSONDecoder().decode(RESTResults.self, from: data)
DispatchQueue.main.async{
    self.txtOutput.text = String(results.predictions[0][0])
}

Sekarang fungsi pascapemrosesan mengekstrak nilai yang diprediksi dari respons dan menampilkan hasilnya di UI.

Menjalankan aplikasi

1. Klik 'Run' lalu tunggu Xcode meluncurkan aplikasi di Simulator.
2. Masukkan nomor di kotak teks, lalu klik Buat inferensi.

Sekarang Anda melihat prediksi nilai di UI.

8 Menghubungkan aplikasi iOS dengan Penayangan TensorFlow melalui gRPC

Selain REST, Penayangan TensorFlow juga mendukung gRPC.

gRPC adalah framework Modern Procedure Call (RPC) modern yang bersifat open source dan berperforma tinggi, yang dapat berjalan di lingkungan apa pun. Layanan ini dapat secara efisien menghubungkan layanan di dan ke seluruh pusat data dengan dukungan yang dapat dicolokkan untuk load balancing, perekaman aktivitas, pemeriksaan kesehatan, dan autentikasi. Telah diamati bahwa dalam praktiknya, gRPC lebih berperforma daripada REST.

Mengirim permintaan dan menerima respons dengan gRPC

Ada empat langkah sederhana:

1. Opsional: Buat kode stub klien gRPC.
2. Buat permintaan gRPC.
3. Kirim permintaan gRPC ke Penayangan TensorFlow.
4. Ekstrak hasil yang diprediksi dari respons gRPC dan render UI.

Anda akan melakukan langkah-langkah berikut dalam file iOS/regression/ViewController.swift.

Opsional: Membuat kode stub klien gRPC

Catatan: Langkah ini bersifat opsional karena kode awal sudah menyertakan kode stub klien gRPC. Namun, jika Anda ingin membuat stub klien sendiri, sebaiknya baca langkah-langkah ini untuk memahami prosesnya. Pastikan Anda telah menyiapkan compiler Protocol Buffer dan plugin generator kode Swift gRPC dengan benar jika mencobanya sendiri.

Untuk menggunakan gRPC dengan TensorFlow Serve, Anda harus mengikuti alur kerja gRPC. Untuk mempelajari detailnya lebih lanjut, lihat dokumentasi gRPC.

Penayangan TensorFlow dan TensorFlow menentukan file .proto untuk Anda. Mulai TensorFlow dan TensorFlow Serve 2.8, file .proto berikut adalah yang diperlukan:

tensorflow/core/example/example.proto
tensorflow/core/example/feature.proto
tensorflow/core/protobuf/struct.proto
tensorflow/core/protobuf/saved_object_graph.proto
tensorflow/core/protobuf/saver.proto
tensorflow/core/protobuf/trackable_object_graph.proto
tensorflow/core/protobuf/meta_graph.proto
tensorflow/core/framework/node_def.proto
tensorflow/core/framework/attr_value.proto
tensorflow/core/framework/function.proto
tensorflow/core/framework/types.proto
tensorflow/core/framework/tensor_shape.proto
tensorflow/core/framework/full_type.proto
tensorflow/core/framework/versions.proto
tensorflow/core/framework/op_def.proto
tensorflow/core/framework/graph.proto
tensorflow/core/framework/tensor.proto
tensorflow/core/framework/resource_handle.proto
tensorflow/core/framework/variable.proto

tensorflow_serving/apis/inference.proto
tensorflow_serving/apis/classification.proto
tensorflow_serving/apis/predict.proto
tensorflow_serving/apis/regression.proto
tensorflow_serving/apis/get_model_metadata.proto
tensorflow_serving/apis/input.proto
tensorflow_serving/apis/prediction_service.proto
tensorflow_serving/apis/model.proto

Untuk membuat kode stub klien gRPC:

1. Di terminal Anda, buka folder starter/src/proto/ lalu buat stub:

bash generate_grpc_stub_swift.sh

Sejumlah file .swift dibuat di folder starter/src/proto/generated/import.

2. Jika belum disalin ke project Anda, tarik semua file .swift yang dihasilkan ke dalam project di Xcode.

Membuat permintaan gRPC

Serupa dengan permintaan REST, Anda membuat permintaan gRPC di cabang gRPC.

if (connectionMode[picker.selectedRow(inComponent: 0)] == "REST") {

}
else {
    print("Using gRPC")
    // TODO: add code to send a gRPC request to TF Serving

}

• Untuk membuat permintaan gRPC, tambahkan kode ini ke cabang gRPC:

//Create the gRPC request.
let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
let channel = ClientConnection.insecure(group: group).connect(host: "localhost", port: 8500)
let stub = Tensorflow_Serving_PredictionServiceClient(channel: channel)

var modelSpec = Tensorflow_Serving_ModelSpec()
modelSpec.name = "regression"
modelSpec.signatureName = "serving_default"

// Prepare the input tensor.
var batchDim = Tensorflow_TensorShapeProto.Dim()
batchDim.size = 1
var inputDim = Tensorflow_TensorShapeProto.Dim()
inputDim.size = 1
var inputTensorShape = Tensorflow_TensorShapeProto()
inputTensorShape.dim = [batchDim, inputDim]
var inputTensor = Tensorflow_TensorProto()
inputTensor.dtype = Tensorflow_DataType.dtFloat
inputTensor.tensorShape = inputTensorShape
inputTensor.floatVal = [Float(value)]

var request = Tensorflow_Serving_PredictRequest()
request.modelSpec = modelSpec
request.inputs = ["dense_input" : inputTensor]

let callOptions = CallOptions(timeLimit: .timeout(.seconds(15)))

Mengirim permintaan gRPC ke TensorFlow Serving

• Tambahkan kode ini ke cabang gRPC tepat setelah kode di cuplikan kode sebelumnya:

// Send the gRPC request.
let call = stub.predict(request, callOptions: callOptions)

Memproses respons gRPC dari TensorFlow Serving

• Tambahkan kode ini segera setelah kode dalam cuplikan kode sebelumnya:

// Process the response.
call.response.whenSuccess { response in
    let result = response.outputs["dense_1"]?.floatVal[0]
    DispatchQueue.main.async{
        self.txtOutput.text = String(describing: result!)
    }
}
call.response.whenFailure { error in
    print("Call failed with error\n\(error)")
}

Sekarang fungsi pascapemrosesan mengekstrak nilai yang diprediksi dari respons dan menampilkan hasilnya di UI.

Menjalankan aplikasi

1. Klik 'Run' di menu navigasi, lalu tunggu Xcode meluncurkan aplikasi di Simulator.
2. Masukkan nomor di kotak teks, lalu klik Buat inferensi.

Sekarang Anda melihat prediksi nilai di UI.

9. Selamat

Anda menggunakan TensorFlow Serve untuk menambahkan kemampuan regresi ke aplikasi.

Pelajari lebih lanjut

• Halaman beranda Penayangan TensorFlow
• Halaman beranda gRPC
• Regresi dasar: Memprediksi efisiensi bahan bakar