Tensorflow Lite Converter

By | October 23, 2021
0 Comment
Print Friendly, PDF & Email
3,712 Views

Tensorflow Lite Converter –  merupakan cara terbaik untuk membuat aplikasi berbasis android dengan menggunakan deep machine learning sebagai core engine nya. Jadi terkadang permintaan client project bermacam-macam, salah satunya adalah membuat ponsel menjadi lebih cerdas.

Saya akan membahas sedikit mengenai tensorflow lite yang merupakan library yang dijalankan di device kecil seperti ponsel pintar, Adapun caranya sangat mudah kok, kalian cukup melakukan training pada PC kemudian hasilnya akan diconvert ke tensorflow lite. Sesuai dokumentasi di https://www.tensorflow.org/lite/convert

Sesuai kegunaannya yaitu

The TensorFlow Lite converter takes a TensorFlow model and generates a TensorFlow Lite model (an optimized FlatBuffer format identified by the .tflite file extension).

Kalian bisa menggunakan 2 cara yaitu via Python API atau Command Line, nah yang saya akan bahas menggunakan Python API saja. Kalian bisa melihat skema berikut

Jadi ada 3 cara input yang digunakan yaitu

  1. keras model : langsung dari kode yang kita gunakan
  2. save model : dari file hasil pelatihan dengan format hdf5
  3. concrete function : sebuah function

Oiya, jangan lupa ya kan ada 2 jenis version tensorflow, caranya pun berbeda.

  1. Convert a TensorFlow 2.x model using tf.lite.TFLiteConverter
    1. tf.lite.TFLiteConverter.from_saved_model() (recommended): Converts a SavedModel.
    2. tf.lite.TFLiteConverter.from_keras_model(): Converts a Keras model.
    3. tf.lite.TFLiteConverter.from_concrete_functions(): Converts concrete functions.
  2. Convert a TensorFlow 1.x model using tf.compat.v1.lite.TFLiteConverter
    1. tf.compat.v1.lite.TFLiteConverter.from_saved_model(): Converts a SavedModel.
    2. tf.compat.v1.lite.TFLiteConverter.from_keras_model_file(): Converts a Keras model.
    3. tf.compat.v1.lite.TFLiteConverter.from_session(): Converts a GraphDef from a session.
    4. tf.compat.v1.lite.TFLiteConverter.from_frozen_graph(): Converts a Frozen GraphDef from a file.

Untuk memudahkan, saya singkat saja tensorflow lite menjadi tflite

Syarat Kebutuhan

Agar kita seragam, saya akan memberikan informasi penting yaitu saya menggunakan

  1. Python 3.6.3 :: Anaconda, Inc.
  2. Name: tensorflow; Version: 2.5.0rc2
  3. Name: numpy; Version: 1.19.2
  4. Name: Keras; Version: 2.3.1
  5. Name: h5py; Version: 3.0.0;Oiya ada issue terkait format hdf5, jadi kalian gunakan h5py 3.0.0 saja
    1. https://github.com/tensorflow/tensorflow/issues/44467
    2. https://stackoverflow.com/questions/53740577/does-any-one-got-attributeerror-str-object-has-no-attribute-decode-whi
See also  Merge File CSV di Pandas: Panduan Lengkap dan Praktis

Ini penting karena ada banyak jenis tensorflow, jadi biar nggak salah ataupun terjadi bugs

Simpan tflite dari Model Keras

Untuk mempermudah model keras yang kita buat, saya akan membuat logika XOR dengan model sequential berikut

import numpy as np
import tensorflow as tf
from keras.models import Sequential
from keras.layers.core import Dense

inputs = np.array([[0, 0],
                   [0, 1],
                   [1, 0],
                   [1, 1]])

target = np.array([0, 1, 1, 0])

#cara 1
model = Sequential()
model.add(Dense(16, input_dim=2, activation='relu'))
model.add(Dense(1, activation='sigmoid'))

model.compile(loss='mean_squared_error',
            optimizer='adam',
            metrics=['accuracy'])
model.fit(inputs, target, epochs=100,verbose=2)

result = model.predict(inputs).round()
print(result)

hasilnya sangat sempurna, machine dapat bekerja dengan baik! karena result sesuai  target

Epoch 100/100
1/1 - 0s - loss: 0.2403 - accuracy: 1.0000
[[0.]
 [1.]
 [1.]
 [0.]]

Nah sekarang kita akan simpan kedalam tensorflow lite dari keras model

converter_model = tf.lite.TFLiteConverter.from_keras_model(model)
tflite_model = converter_model.convert()

# Save the model.
with open('model.tflite', 'wb') as f:
  f.write(tflite_model)

Cukup simpel ya! akan terdapat file model.tflite dengan ukuran kecil yaitu 1.53 KB

Simpan tflite dari Save Model

Nah kita akan coba bobot dan bias tersebut diatas menjadi hdf5

model.save('model xor.h5')

Nah akan tercipta file model xor.h5 dengan ukuran cukup besar! yaitu 24.9 KB

Kalau kita buka dengan hdf5, akan tampil sebagai berikut berupa bobot dan biasnya

Bagaimana selanjutnya??

Namun kalian wajib simpan dalam format pb – protobuffer lho! jangan HDF5! agar bisa dikonvert ke tensorflow lite

Caranya mudah koq, misalkan kita akan simpan pada direktori model pb

model.save('model pb',save_format='pb')

maka akan otomatis ter create sebuah direktori dengan nama model pb yang isinya sebagai berikut

Simpan model kedalam tensorflow lite dengan mengubah file save model menjadi tensorflow lite

converter = tf.lite.TFLiteConverter.from_saved_model('model pb')
tflite_model = converter.convert()

# Save the model.
with open('model2.tflite', 'wb') as f:
  f.write(tflite_model)

Tapi bilamana kita hanya punya save model dengan format hdf5? bisa kalian coba dengan teknik berikut

converter = tf.compat.v1.lite.TFLiteConverter.from_keras_model_file('model xor.h5')
# Save the model.
with open('model3.tflite', 'wb') as f:
  f.write(tflite_model)

atau dengan cara loading dulu ke dalam sebuah variabel, kemudian simpan dengan teknik keras model

See also  Python Pandas Merging DataFrames

Loading Model dari PB dan HDF5

Saya akan bahas mengenai cara loading model dari HDF5 dan PB, untuk loading model dari HDF5 cukup gunakan perintah

model3 = tf.keras.models.load_model('model xor.h5')
model3.predict(inputs)

Sedangkan untuk format pb, bisa kalian gunakan perintah berikut

from tensorflow.keras.models import load_model
model2 = load_model('model pb', compile = False)
model2.predict(inputs)

 

Menggunakan tflite

tflite merupakan binary file yang ditulis dalam format bahasa C, oleh karena itu bisa digunakan dalam beragam bahasa. Sesuai dengan dokumentasi https://www.tensorflow.org/lite/guide/inference. Ada banyak cara menggunakannya, tapi kalian harus pahami dulu konsep kerjanya, saya langsung comot saja ya. TensorFlow Lite inference typically follows the following steps:

  1. Loading a model : You must load the .tflite model into memory, which contains the model’s execution graph.

  2. Transforming data: Raw input data for the model generally does not match the input data format expected by the model. For example, you might need to resize an image or change the image format to be compatible with the model.

  3. Running inference: This step involves using the TensorFlow Lite API to execute the model. It involves a few steps such as building the interpreter, and allocating tensors, as described in the following sections.

  4. Interpreting output: When you receive results from the model inference, you must interpret the tensors in a meaningful way that’s useful in your application. For example, a model might return only a list of probabilities. It’s up to you to map the probabilities to relevant categories and present it to your end-user.

Sesuai dokumentasi di link tersebut, bahwa

TensorFlow inference APIs are provided for most common mobile/embedded platforms such as Android, iOS and Linux, in multiple programming languages.

Yup kalian bisa menggunakan beragam bahasa disitu seperti Java dengan JNI (java native interface), objective C, C++, Python juga tentunya. Tapi saya akan bahas mengenai di python saja

See also  Algoritma Dynamic Time Warping

Dengan bagian khusus yaitu if the model doesn’t have SignatureDefs defined. Ok langsung saja kita coba dengan inputs[1,1]

import tensorflow as tf
import numpy as np
#Another example if the model doesn't have SignatureDefs defined.
TFLITE_FILE_PATH  = 'model.tflite'

# Load the TFLite model and allocate tensors.
interpreter = tf.lite.Interpreter(model_path = TFLITE_FILE_PATH)
interpreter.allocate_tensors()

# Get input and output tensors.
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()

# Test the model on random input data.
input_shape = input_details[0]['shape']

input_data = np.array([[1,1]], dtype=np.float32)
interpreter.set_tensor(input_details[0]['index'], input_data)

interpreter.invoke()

# The function `get_tensor()` returns a copy of the tensor data.
# Use `tensor()` in order to get a pointer to the tensor.
output_data = interpreter.get_tensor(output_details[0]['index'])
print(output_data)

Hasilnya

[[0.37520707]] #atau bila dibulatkan menjadi 0

Sedikit tambahan mengenai signature def yang telah dikenalkan pada tensorflow versi 2.5 (Available starting from TensorFlow 2.5). Oiya untuk java, maka kalian harus menggunakan android karena melibatkan package -> Android library dependency: org.tensorflow:tensorflow-lite

Kesimpulan

Kalian bisa mengurangi / reduce ukuran model dengan converter ke tensorflow lite yang bisa digunakan untuk OS or Android atau an embedded device! Hal ini bisa dicapai karena

  • Quantization yaitu mengubah reduces the precision of the numbers used to represent different parameters of the TensorFlow model and this makes models light-weight. Artinya dengan mengubah format 32 bit floating point hanya menjadi 16 bit yaitu pada bobot dan bias model
  • Weight Pruning achieves model sparsity, and sparse models are compressed more efficiently. Artinya dengan teknik compresi hal ini mudah karena adanya sparsity pada model. Misalkan untuk mengkompresi sebuah array sparsity diag(3,3) tentu lebih efisien jika dikompress.