-
Notifications
You must be signed in to change notification settings - Fork 0
/
eval_pq_tflite_model.py
133 lines (93 loc) · 4.01 KB
/
eval_pq_tflite_model.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
import numpy as np
import pandas as pd
import os
#import tensorflow as tf
import time
import tflite_runtime.interpreter as tflite
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
#from tensorflow.keras.utils import to_categorical
from sklearn.preprocessing import OneHotEncoder
#Read and arrange data for tensorflow
import opendatasets as od
od.download("https://www.kaggle.com/mohammedfarag/mitbihcsv")
data_set_path=os.path.join("mitbihcsv","mit_bih_data_set.csv")
data_set = pd.read_csv(data_set_path,dtype=float)
num_classes=6
data_set_np = data_set.to_numpy()
X = data_set_np[:,:-1]
y = data_set_np[:,-1]
scalar = StandardScaler()
X = scalar.fit_transform(X)
X_trn, X_tst, y_trn, y_tst = train_test_split(X, y, test_size=0.2,stratify=y, random_state=42)
# One hot Encoding of y
enc = OneHotEncoder()
enc.fit(y_trn.reshape(-1, 1))
y_trn_oh = enc.transform(y_trn.reshape(-1, 1)).toarray()
enc.fit(y_tst.reshape(-1, 1))
y_tst_oh = enc.transform(y_tst.reshape(-1, 1)).toarray()
X_trn_tf = np.expand_dims(X_trn, axis=2)
X_tst_tf = np.expand_dims(X_tst, axis=2)
X_tst = X_tst.astype('float32')
X_tst_tf = X_tst_tf.astype('float32')
tflite_model_file = 'pq_model.tflite'
# Load TFLite model and allocate tensors.
with open(tflite_model_file, 'rb') as fid:
tflite_model = fid.read()
interpreter = tflite.Interpreter(model_content=tflite_model)
interpreter.allocate_tensors()
#input_index = interpreter.get_input_details()[0]["index"]
#output_index = interpreter.get_output_details()[0]["index"]
# Load TFLite model and allocate tensors.
#interpreter = tf.lite.Interpreter(model_content=float_tflite_model)
#interpreter.allocate_tensors()
#get input and output tensors
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()
#Preprocess the image to required size and cast
input_shape = input_details[0]['shape']
input_data = np.expand_dims(X_tst_tf[0], 0)
#set the tensor to point to the input data to be inferred
input_index = interpreter.get_input_details()[0]["index"]
interpreter.set_tensor(input_details[0]['index'], input_data)
#Run the inference
interpreter.invoke()
output_details = interpreter.get_tensor(output_details[0]['index'])
# A helper function to evaluate the TF Lite model using "test" dataset.
def evaluate_tflite_model(tflite_model):
# Initialize TFLite interpreter using the model.
interpreter = tflite.Interpreter(model_content=tflite_model)
interpreter.allocate_tensors()
input_tensor_index = interpreter.get_input_details()[0]["index"]
output = interpreter.tensor(interpreter.get_output_details()[0]["index"])
# Run predictions on every image in the "test" dataset.
prediction_outputs = []
for data in X_tst_tf:
# Pre-processing: add batch dimension and convert to float32 to match with
# the model's input data format.
test_data = np.expand_dims(data, axis=0).astype(np.float32)
interpreter.set_tensor(input_tensor_index, test_data)
# Run inference.
interpreter.invoke()
# Post-processing: remove batch dimension and find the digit with highest
# probability.
prediction = np.argmax(output()[0])
prediction_outputs.append(prediction)
# Compare prediction results with ground truth labels to calculate accuracy.
accurate_count = 0
for index in range(len(prediction_outputs)):
if prediction_outputs[index] == y_tst[index]:
accurate_count += 1
accuracy = accurate_count * 1.0 / len(prediction_outputs)
return accuracy
# Evaluate the TF Lite float model. You'll find that its accurary is identical
# to the original TF (Keras) model because they are essentially the same model
# stored in different format.
start = time.time()
tflite_accuracy = evaluate_tflite_model(tflite_model)
end = time.time()
inference_time = (end-start)/X_tst_tf.shape[0]
throughput = X_tst_tf.shape[0]/(end-start)
print("Inference time on CPU is :", inference_time)
print("Throughput on CPU is :", throughput, "sequence per second")
print('tflite model accuracy = %.4f' % tflite_accuracy)