def inference_tf(input, url, token=''):
request = predict_pb2.PredictRequest()
response = predict_pb2.PredictResponse()
request.model_spec.name = 'mnist'
request.model_spec.signature_name = 'predict_images'
request.inputs['images'].CopyFrom(
tf.make_tensor_proto(input, shape=[1, 784]))
data = request.SerializeToString()
data_type = "application/proto"
headers = {
# !!! set content type
'content-type': data_type,
# !!! replace your token
'Authorization': "AppCode " + token
}
res = requests.post(url, data, headers=headers, verify=False)
if (res.status_code == 200 and res.headers['Content-Type'] == data_type):
# print res.content
response.ParseFromString(res.content)
v = response.outputs['scores'].float_val
return np.array(v).flatten().tolist()
else:
# handle error msg
print(res.content)
def sendRequest(url):
request = predict_pb2.PredictRequest()
response = predict_pb2.PredictResponse()
request.model_spec.name = 'inception'
request.model_spec.signature_name = 'predict_images'
request.inputs['images'].CopyFrom(
tf.make_tensor_proto(getImageData(), shape=[1]))
data = request.SerializeToString()
data_type = "application/proto"
headers = {
# !!! set content type
'content-type': data_type,
# !!! replace your token
'Authorization': "AppCode YOUR_CODE"
}
res = requests.post(url, data, headers=headers)
if (res.status_code == 200 and res.headers['Content-Type'] == data_type):
# print res.content
response.ParseFromString(res.content)
le = len(response.outputs["classes"].string_val)
for i in range(le):
print("{} score: {}".format(
response.outputs["classes"].string_val[i],
response.outputs["scores"].float_val[i]))
else:
# handle error msg
print(res.headers['X-Ddy-Error-Message'])
print(res.content)
def sendRequest(url):
request = predict_pb2.PredictRequest()
response = predict_pb2.PredictResponse()
request.model_spec.name = 'resnet'
request.model_spec.signature_name = 'predict'
array = np.ones(224 * 224 * 3).reshape(224, 224, 3).astype(np.float32)
request.inputs['input'].CopyFrom(
tf.make_tensor_proto(array, shape=[1, 224, 224, 3]))
data = request.SerializeToString()
data_type = "application/proto"
headers = {
# !!! set content type
'content-type': data_type,
# !!! replace your token
'Authorization': "AppCode TOKEN"
}
res = requests.post(url, data, headers=headers, verify=False)
if (res.status_code == 200 and res.headers['Content-Type'] == data_type):
# print res.content
response.ParseFromString(res.content)
print(response)
else:
# handle error msg
print(res)
def sendRequest(url):
request = predict_pb2.PredictRequest()
response = predict_pb2.PredictResponse()
request.model_spec.name = 'mnist'
request.model_spec.signature_name = 'predict_images'
array = np.random.ranf(784).reshape(1, 784).astype(np.float32)
request.inputs['images'].CopyFrom(tf.make_tensor_proto(array))
data = request.SerializeToString()
data_type = "application/proto"
#!!! Add Appcode here
token = "YOUR_CODE"
headers = {
# !!! set content type
'content-type': data_type,
# !!! replace your token
'Authorization': "AppCode " + token
}
res = requests.post(url, data, headers=headers, verify=False)
if (res.status_code == 200 and res.headers['Content-Type'] == data_type):
# print res.content
response.ParseFromString(res.content)
print(MessageToDict(response))
else:
# handle error msg
print(res.headers['X-Ddy-Error-Message'])
print(res.content)
def test_pb_request():
data = [x for x in xrange(784)]
tensor_proto = tf.make_tensor_proto(values=np.asarray(data),
shape=[1, len(data)],
dtype=tf.float32)
request = predict_pb2.PredictRequest()
request.model_spec.name = "generic_model"
request.model_spec.signature_name = DEFAULT_SERVING_SIGNATURE_DEF_KEY
request.inputs[PREDICT_INPUTS].CopyFrom(tensor_proto)
serialized_output = requests.post("http://localhost:8080/invocations",
data=request.SerializeToString(),
headers={
'Content-type':
'application/octet-stream',
'Accept': 'application/octet-stream'
}).content
predict_response = predict_pb2.PredictResponse()
predict_response.ParseFromString(serialized_output)
probabilities = predict_response.outputs['probabilities']
assert len(probabilities.float_val) == 10
for v in probabilities.float_val:
assert v <= 1.
assert v >= 0.
def _CreatePredictResponse(values: List[float],
shape: List[int]) -> predict_pb2.PredictResponse:
"""Returns a PredictResponse used in below unit tests."""
tensor_proto = tf.make_tensor_proto([], shape=shape, dtype=np.float32)
tensor_proto.float_val.extend(values)
resp = predict_pb2.PredictResponse(
outputs={_MODEL_CONFIG.response[0].key: tensor_proto})
return resp
def decode_proto(msg, proto_name):
print(proto_name)
if proto_name == "tensorflow.serving.PredictResponse":
pr: predict_pb2.PredictResponse = predict_pb2.PredictResponse()
pr.ParseFromString(msg.value())
print(MessageToJson(pr))
else:
print("unknown proto received ", proto_name)
def _prepare_output_with_make_tensor_proto(inference_output,
model_available_outputs):
response = predict_pb2.PredictResponse()
for response_output_name in model_available_outputs:
model_output_name = model_available_outputs[response_output_name]
response.outputs[response_output_name].CopyFrom(
make_tensor_proto(inference_output[model_output_name]))
return response
def test_convert_predict_response_regression(self):
"""Test converting a PredictResponse to a RegressionResponse."""
predict = predict_pb2.PredictResponse()
output = predict.outputs['scores']
dim = output.tensor_shape.dim.add()
dim.size = 2
output.float_val.extend([0.1, 0.2])
bundle = inference_utils.ServingBundle('', '', 'regression', '', '',
True, '', 'scores')
converted = common_utils.convert_predict_response(predict, bundle)
self.assertAlmostEqual(0.1, converted.result.regressions[0].value)
self.assertAlmostEqual(0.2, converted.result.regressions[1].value)
def prepare_output_as_list(inference_output, model_available_outputs):
response = predict_pb2.PredictResponse()
for key, value in model_available_outputs.items():
if value in inference_output:
dtype = dtypes.as_dtype(inference_output[value].dtype)
output_tensor = tensor_pb2.TensorProto(
dtype=dtype.as_datatype_enum,
tensor_shape=tensor_shape.as_shape(
inference_output[value].shape).as_proto())
result = inference_output[value].flatten()
tensor_util._NP_TO_APPEND_FN[dtype.as_numpy_dtype](output_tensor,
result)
response.outputs[key].CopyFrom(output_tensor)
return response
def _prepare_output_as_AppendArrayToTensorProto(inference_output,
model_available_outputs):
response = predict_pb2.PredictResponse()
for response_output_name, model_output_name in \
model_available_outputs.items():
if model_output_name in inference_output:
dtype = dtypes.as_dtype(inference_output[model_output_name].dtype)
output_tensor = tensor_pb2.TensorProto(
dtype=dtype.as_datatype_enum,
tensor_shape=tensor_shape.as_shape(
inference_output[model_output_name].shape).as_proto())
result = inference_output[model_output_name].flatten()
tensor_util._NP_TO_APPEND_FN[dtype.as_numpy_dtype](output_tensor,
result)
response.outputs[response_output_name].CopyFrom(output_tensor)
return response
def do_inference(hostport, work_dir, concurrency, num_tests):
"""Tests PredictionService over Tensor-Bridge.
Args:
hostport: Host:port address of the PredictionService.
work_dir: The full path of working directory for test data set.
concurrency: Maximum number of concurrent requests.
num_tests: Number of test images to use.
Returns:
The classification error rate.
Raises:
IOError: An error occurred processing test data set.
"""
test_data_set = mnist_input_data.read_data_sets(work_dir).test
error = 0
for _ in range(num_tests):
request = predict_pb2.PredictRequest()
request.model_spec.name = 'mnist'
request.model_spec.signature_name = 'predict_images'
image, label = test_data_set.next_batch(1)
request.inputs['images'].CopyFrom(
tf.contrib.util.make_tensor_proto(image[0],
shape=[1, image[0].size]))
response = requests.post(
'http://' + hostport + '/tensor-bridge/v1/prediction',
json=MessageToDict(request,
preserving_proto_field_name=True,
including_default_value_fields=True))
result = ParseDict(response.json(),
predict_pb2.PredictResponse(),
ignore_unknown_fields=True)
scores = numpy.array(result.outputs['scores'].float_val)
prediction = numpy.argmax(scores)
if label[0] != prediction:
error += 1
return error / num_tests
def do_inference(work_dir, concurrency, num_tests, input_dir):
"""
Tests PredictionService with concurrent requests.
Args:
work_dir: The full path of working directory for test data set.
concurrency: Maximum number of concurrent requests.
num_tests: Number of test images to use.
input_dir: Path to dir which contains prediction results.
Returns:
The classification error rate.
Raises:
IOError: An error occurred processing test data set.
"""
expected_labels = np.load(os.path.join(work_dir, "labels.npy"))
result_counter = _ResultCounter(num_tests, concurrency)
for i in range(num_tests):
result_counter.throttle()
sys.stdout.write(".")
sys.stdout.flush()
with open(os.path.join(input_dir, "{}.pb".format(i)),
mode="rb") as pb_file:
result_pb = pb_file.read()
resp = predict_pb2.PredictResponse()
resp.ParseFromString(result_pb)
response = np.array(resp.outputs[MODEL_OUTPUT_NAME].float_val)
prediction = np.argmax(response)
if expected_labels[i] != prediction:
result_counter.inc_error()
result_counter.inc_done()
result_counter.dec_active()
return result_counter.get_error_rate()
def test_convert_predict_response_classification(self):
"""Test converting a PredictResponse to a ClassificationResponse."""
predict = predict_pb2.PredictResponse()
output = predict.outputs['probabilities']
dim = output.tensor_shape.dim.add()
dim.size = 3
dim = output.tensor_shape.dim.add()
dim.size = 2
output.float_val.extend([1., 0., .9, .1, .8, .2])
bundle = inference_utils.ServingBundle('', '', 'classification', '',
'', True, '', 'probabilities')
converted = common_utils.convert_predict_response(predict, bundle)
self.assertEqual("0",
converted.result.classifications[0].classes[0].label)
self.assertAlmostEqual(
1, converted.result.classifications[0].classes[0].score)
self.assertEqual("1",
converted.result.classifications[0].classes[1].label)
self.assertAlmostEqual(
0, converted.result.classifications[0].classes[1].score)
self.assertEqual("0",
converted.result.classifications[1].classes[0].label)
self.assertAlmostEqual(
.9, converted.result.classifications[1].classes[0].score)
self.assertEqual("1",
converted.result.classifications[1].classes[1].label)
self.assertAlmostEqual(
.1, converted.result.classifications[1].classes[1].score)
self.assertEqual("0",
converted.result.classifications[2].classes[0].label)
self.assertAlmostEqual(
.8, converted.result.classifications[2].classes[0].score)
self.assertEqual("1",
converted.result.classifications[2].classes[1].label)
self.assertAlmostEqual(
.2, converted.result.classifications[2].classes[1].score)
def Predict(self, request, context):
"""Predict -- provides access to loaded TensorFlow model.
"""
global q
global stream
if "vertices" in request.inputs:
print("vertices")
vertices = tensor_util.MakeNdarray(request.inputs["vertices"])
q.put(vertices)
elif "audio" in request.inputs:
print('audio')
# audio = tensor_util.MakeNdarray(request.inputs['audio'])
print(type(request.inputs['audio'].string_val[0]))
audio = request.inputs['audio'].string_val[0]
# print(request.inputs['audio'])
stream.write(audio)
elif "subtitle" in request.inputs:
print('subtitle')
subtitles.put(request.inputs['subtitle'].string_val[0])
dumbresult = predict_pb2.PredictResponse()
dumbresult.outputs["message"].CopyFrom(tf.make_tensor_proto("OK"))
return dumbresult
def Predict(self, request, context):
"""
Predict -- provides access to loaded TensorFlow model.
"""
# check if model with was requested
# is available on server with proper version
model_name = request.model_spec.name
requested_version = request.model_spec.version.value
valid_model_spec, version = check_availability_of_requested_model(
models=self.models,
requested_version=requested_version,
model_name=model_name)
if not valid_model_spec:
context.set_code(StatusCode.NOT_FOUND)
context.set_details(
WRONG_MODEL_SPEC.format(model_name, requested_version))
logger.debug(
"PREDICT, invalid model spec from request, {} - {}".format(
model_name, requested_version))
return predict_pb2.PredictResponse()
start_time = datetime.datetime.now()
occurred_problem, inference_input, batch_size, code = \
prepare_input_data(models=self.models, model_name=model_name,
version=version, data=request.inputs,
rest=False)
deserialization_end_time = datetime.datetime.now()
duration = \
(deserialization_end_time - start_time).total_seconds() * 1000
logger.debug(
"PREDICT; input deserialization completed; {}; {}; {}ms".format(
model_name, version, duration))
if occurred_problem:
context.set_code(code)
context.set_details(inference_input)
logger.debug(
"PREDICT, problem with input data. Exit code {}".format(code))
return predict_pb2.PredictResponse()
self.models[model_name].engines[version].in_use.acquire()
inference_start_time = datetime.datetime.now()
inference_output = self.models[model_name].engines[version] \
.infer(inference_input, batch_size)
inference_end_time = datetime.datetime.now()
self.models[model_name].engines[version].in_use.release()
duration = \
(inference_end_time - inference_start_time).total_seconds() * 1000
logger.debug(
"PREDICT; inference execution completed; {}; {}; {}ms".format(
model_name, version, duration))
response = prepare_output_as_list(
inference_output=inference_output,
model_available_outputs=self.models[model_name].engines[version].
model_keys['outputs'])
response.model_spec.name = model_name
response.model_spec.version.value = version
response.model_spec.signature_name = SIGNATURE_NAME
serialization_end_time = datetime.datetime.now()
duration = \
(serialization_end_time -
inference_end_time).total_seconds() * 1000
logger.debug("PREDICT; inference results serialization completed;"
" {}; {}; {}ms".format(model_name, version, duration))
return response
def Predict(self, request, context):
"""
Predict -- provides access to loaded TensorFlow model.
"""
# check if requested model
# is available on server with proper version
model_name = request.model_spec.name
requested_version = request.model_spec.version.value
valid_model_spec, version = check_availability_of_requested_model(
models=self.models,
requested_version=requested_version,
model_name=model_name)
if not valid_model_spec:
context.set_code(StatusCode.NOT_FOUND)
context.set_details(
WRONG_MODEL_SPEC.format(model_name, requested_version))
logger.debug(
"PREDICT, invalid model spec from request, {} - {}".format(
model_name, requested_version))
return predict_pb2.PredictResponse()
target_engine = self.models[model_name].engines[version]
start_time = datetime.datetime.now()
inference_input, error_message = \
prepare_input_data(target_engine=target_engine,
data=request.inputs,
service_type=GRPC)
deserialization_end_time = datetime.datetime.now()
duration = \
(deserialization_end_time - start_time).total_seconds() * 1000
logger.debug(
"PREDICT; input deserialization completed; {}; {}; {}ms".format(
model_name, version, duration))
if error_message is not None:
code = statusCodes['invalid_arg'][GRPC]
context.set_code(code)
context.set_details(error_message)
logger.debug(
"PREDICT, problem with input data. Exit code {}".format(code))
return predict_pb2.PredictResponse()
target_engine = self.models[model_name].engines[version]
target_engine.in_use.acquire()
################################################
# Reshape network inputs if needed
reshape_param = target_engine.detect_shapes_incompatibility(
inference_input)
if reshape_param is not None:
error_message = target_engine.reshape(reshape_param)
if error_message is not None:
code = statusCodes['invalid_arg'][GRPC]
context.set_code(code)
context.set_details(error_message)
target_engine.in_use.release()
return predict_pb2.PredictResponse()
################################################
inference_start_time = datetime.datetime.now()
inference_output, error_message = target_engine.infer(inference_input)
if error_message is not None:
code = statusCodes['invalid_arg'][GRPC]
context.set_code(code)
context.set_details(error_message)
target_engine.in_use.release()
return predict_pb2.PredictResponse()
inference_end_time = datetime.datetime.now()
target_engine.in_use.release()
duration = \
(inference_end_time - inference_start_time).total_seconds() * 1000
logger.debug(
"PREDICT; inference execution completed; {}; {}; {}ms".format(
model_name, version, duration))
response = prepare_output_as_list(
inference_output=inference_output,
model_available_outputs=target_engine.model_keys['outputs'])
response.model_spec.name = model_name
response.model_spec.version.value = version
response.model_spec.signature_name = SIGNATURE_NAME
serialization_end_time = datetime.datetime.now()
duration = \
(serialization_end_time -
inference_end_time).total_seconds() * 1000
logger.debug("PREDICT; inference results serialization completed;"
" {}; {}; {}ms".format(model_name, version, duration))
return response
def Predict(self, request, context):
if ("input_image" in request.inputs):
print("[%.6f] Received face request" % time.time())
image = tensor_util.MakeNdarray(request.inputs["input_image"])
worker_request = predict_pb2.PredictRequest()
worker_request.inputs['input_image'].CopyFrom(
tf.make_tensor_proto(image))
face_detector = FaceDetector()
face_detector.PreProcess(worker_request, self.stub)
face_detector.Apply()
prnet_request = face_detector.PostProcess()
if "bounding_box" in prnet_request.inputs:
prnet_image_cropper = PRNetImageCropper()
prnet_image_cropper.PreProcess(prnet_request, self.stub)
prnet_image_cropper.Apply()
next_request = prnet_image_cropper.PostProcess()
prn = PRNet()
prn.PreProcess(next_request, self.stub)
prn.Apply()
key_points, vertices = prn.PostProcess()
visualizer_request = predict_pb2.PredictRequest()
visualizer_request.inputs['prnet_output'].CopyFrom(
tf.make_tensor_proto(key_points))
visualizer_request.inputs['vertices'].CopyFrom(
tf.make_tensor_proto(vertices))
self.q.put(visualizer_request)
worker_response = predict_pb2.PredictResponse()
worker_response.outputs["message"].CopyFrom(
tf.make_tensor_proto("OK"))
return worker_response
elif ("input_audio" in request.inputs):
print("[%.6f] Received audio request" % time.time())
wav = tensor_util.MakeNdarray(request.inputs["input_audio"])
# Speech recognition module
speech_recognition = Deepspeech2()
pre = speech_recognition.PreProcess([wav], self.stub)
app = speech_recognition.Apply(pre)
post = speech_recognition.PostProcess(*app)
print("post: %s" % post)
# Encoding english text
encoder = TextEncoder()
encoded_text = encoder.Apply(post)
# Translation module
translation = Transformer()
pre = translation.PreProcess([encoded_text], self.stub)
app = translation.Apply(pre)
post = translation.PostProcess(*app)
# Decoding German text
decoder = TextDecoder()
decoded_text = decoder.Apply(post)
print("Translation: %s" % decoded_text)
visualizer_request = predict_pb2.PredictRequest()
visualizer_request.inputs['subtitle'].CopyFrom(
tf.contrib.util.make_tensor_proto(decoded_text))
self.q.put(visualizer_request)
worker_response = predict_pb2.PredictResponse()
worker_response.outputs["message"].CopyFrom(
tf.make_tensor_proto("OK"))
return worker_response
def Predict(self, request, context):
"""
Predict -- provides access to loaded TensorFlow model.
"""
# check if requested model
# is available on server with proper version
model_name = request.model_spec.name
requested_version = request.model_spec.version.value
valid_model_spec, version = check_availability_of_requested_model(
models=self.models,
requested_version=requested_version,
model_name=model_name)
if not valid_model_spec:
context.set_code(StatusCode.NOT_FOUND)
context.set_details(
WRONG_MODEL_SPEC.format(model_name, requested_version))
logger.debug(
"PREDICT, invalid model spec from request, {} - {}".format(
model_name, requested_version))
return predict_pb2.PredictResponse()
target_engine = self.models[model_name].engines[version]
deserialization_start_time = datetime.datetime.now()
inference_input, error_message = \
prepare_input_data(target_engine=target_engine,
data=request.inputs,
service_type=GRPC)
duration = (datetime.datetime.now() -
deserialization_start_time).total_seconds() * 1000
logger.debug(
"PREDICT; input deserialization completed; {}; {}; {} ms".format(
model_name, version, duration))
if error_message is not None:
code = statusCodes['invalid_arg'][GRPC]
context.set_code(code)
context.set_details(error_message)
logger.debug(
"PREDICT, problem with input data. Exit code {}".format(code))
return predict_pb2.PredictResponse()
target_engine = self.models[model_name].engines[version]
inference_request = Request(inference_input)
target_engine.requests_queue.put(inference_request)
inference_output, used_ireq_index = inference_request.wait_for_result()
if type(inference_output) is str:
code = statusCodes['invalid_arg'][GRPC]
context.set_code(code)
context.set_details(inference_output)
logger.debug("PREDICT, problem during inference execution. Exit "
"code {}".format(code))
target_engine.free_ireq_index_queue.put(used_ireq_index)
return predict_pb2.PredictResponse()
serialization_start_time = datetime.datetime.now()
response = prepare_output(
inference_output=inference_output,
model_available_outputs=target_engine.model_keys['outputs'])
response.model_spec.name = model_name
response.model_spec.version.value = version
response.model_spec.signature_name = SIGNATURE_NAME
duration = (datetime.datetime.now() -
serialization_start_time).total_seconds() * 1000
logger.debug("PREDICT; inference results serialization completed;"
" {}; {}; {} ms".format(model_name, version, duration))
target_engine.free_ireq_index_queue.put(used_ireq_index)
return response
def Predict(self, request, context):
try:
start_time_millis = self.getCurrentTimeinMillis()
time_1 = datetime.now()
if self._Validations(request, context):
time_2 = datetime.now()
predict_request = {}
for k, v in request.inputs.items():
predict_request[k] = tensor_util.MakeNdarray(
request.inputs[k])
if v.dtype == dtypes.string:
predict_request[k] = predict_request[k].astype(str)
time_3 = datetime.now()
for k, v in predict_request.items():
LOG.info("the key :%s", k)
LOG.info("the value :%s", v)
# Add the more specific try catch request for predict request
try:
predict_outputs = self.model.wrapper_predict_func(
predict_request)
LOG.info("the output from the model's predict function %s",
predict_outputs)
response = tensorflow__serving_dot_apis_dot_predict__pb2.PredictResponse(
)
except grpc.RpcError as grpc_error:
end_time_millis = self.getCurrentTimeinMillis()
LOG.error("Error while doing Prediction")
requestDurationInMillis = str(end_time_millis -
start_time_millis)
self.logRequests(self.model.model_name,
requestDurationInMillis, str(0))
LOG.error("grpc error : %s", str(grpc_error))
s = getattr(grpc_error, 'message', str(grpc_error))
raise grpc.RpcError(grpc_error)
return None
for k, v in predict_outputs.items():
# Disabling this pylint error after checking that this line adheres to
# tensorflow documentation
# pylint: disable=E1101
response.outputs[k].CopyFrom(
tf.contrib.util.make_tensor_proto(v))
''' here print the response time taken to serve the request '''
time_4 = datetime.now()
end_time_millis = self.getCurrentTimeinMillis()
validation_time_ms = (time_2 - time_1).microseconds
parse_time = (time_3 - time_2).microseconds
handle_time = (time_4 - time_3).microseconds
model_metrics = {
"mlf_mc_model_name": self.model.model_name,
"mlf_mc_token_validation_time_ms":
validation_time_ms / 1000,
"mlf_mc_parse_time_ms": parse_time / 1000,
"mlf_mc_handle_time_ms": handle_time / 1000
}
self.collect_metrics(self.model.model_name, model_metrics)
requestDurationInMillis = str(end_time_millis -
start_time_millis)
self.logRequests(self.model.model_name,
requestDurationInMillis, str(1))
return response
else:
requestDurationInMillis = self.getCurrentTimeinMillis()
LOG.error(
"Error while validating JWT token, token not validated successfully"
)
self.logRequests(self.model.model_name,
requestDurationInMillis, str(0))
return None
except Exception as ex:
s = getattr(ex, 'message', str(ex))
raise Exception(s)
return None
def __init__(self, model_spec=None, outputs=None, **kwargs):
super().__init__(predict_pb2.PredictResponse(),
model_spec=model_spec,
outputs=outputs,
**kwargs)
def do_inference(hostport):
# Read file and create feature_dict for each record
total = 0
right = 0
with open("test_data.csv") as inf:
for line in inf:
# Read data, using python, into our features
age, workclass, fnlwgt, education, education_num, marital_status, occupation, relationship, race, gender, capital_gain, capital_loss, hours_per_week, native_country, income = line.strip(
).split(",")
# Create a feature_dict for train.example - Get Feature Columns using
feature_dict = {
'age': _float_feature(value=int(age)),
'workclass': _bytes_feature(value=workclass.encode()),
'fnlwgt': _float_feature(value=int(fnlwgt)),
'education': _bytes_feature(value=education.encode()),
'education_num': _float_feature(value=int(education_num)),
'marital_status':
_bytes_feature(value=marital_status.encode()),
'occupation': _bytes_feature(value=occupation.encode()),
'relationship': _bytes_feature(value=relationship.encode()),
'race': _bytes_feature(value=race.encode()),
'gender': _bytes_feature(value=gender.encode()),
'capital_gain': _float_feature(value=int(capital_gain)),
'capital_loss': _float_feature(value=int(capital_loss)),
'hours_per_week': _float_feature(value=float(hours_per_week)),
'native_country':
_bytes_feature(value=native_country.encode()),
}
# Prepare data
data = tf.train.Example(features=tf.train.Features(
feature=feature_dict))
serialized = data.SerializeToString()
# prepare request object
request = predict_pb2.PredictRequest()
request.model_spec.name = 'default'
request.model_spec.signature_name = 'serving_default'
request.inputs['inputs'].CopyFrom(
tf.contrib.util.make_tensor_proto(serialized, shape=[1]))
# print("DEBUG")
# print(MessageToDict(request,preserving_proto_field_name=True,including_default_value_fields=False))
#get inference
response = requests.post(hostport + '/tensor-bridge/v1/prediction',
json=MessageToDict(
request,
preserving_proto_field_name=True,
including_default_value_fields=False))
result = ParseDict(response.json(),
predict_pb2.PredictResponse(),
ignore_unknown_fields=True)
# DEBUG
# print('--------------------------')
# print(line)
# print('Raw response', response.json())
# print('Result: ', result)
# print(response.json()["outputs"]["scores"]["float_val"])
total = total + 1
if float(response.json()["outputs"]["scores"]["float_val"]
[1]) <= .5:
prediction = "<=50K"
# print("predicted: <=50K")
# print("Actual: ",income)
else:
prediction = ">50K"
# print("predicted: >50K")
# print("Actual: ",income)
if income == prediction:
right = right + 1
print('--------------------------')
print('--------------------------')
print("Accuracy: ", right / total)
print('--------------------------')
print('--------------------------')
return
