def pb_response_validation(cls, resp, expected_resp_pb_file):
cls.assertEqual(resp.status_code, 200)
cls.assertTrue(resp.headers.get('x-ms-request-id'))
cls.assertEqual(resp.headers.get('Content-Type'),
'application/octet-stream')
actual_result = predict_pb2.PredictResponse()
actual_result.ParseFromString(resp.content)
expected_result = predict_pb2.PredictResponse()
with open(expected_resp_pb_file, 'rb') as f:
expected_result.ParseFromString(f.read())
for k in expected_result.outputs.keys():
cls.assertEqual(actual_result.outputs[k].data_type,
expected_result.outputs[k].data_type)
count = 1
for i in range(0, len(expected_result.outputs[k].dims)):
cls.assertEqual(actual_result.outputs[k].dims[i],
expected_result.outputs[k].dims[i])
count = count * int(actual_result.outputs[k].dims[i])
actual_array = numpy.frombuffer(actual_result.outputs[k].raw_data,
dtype=numpy.float32)
expected_array = numpy.frombuffer(expected_result.outputs[k].raw_data,
dtype=numpy.float32)
cls.assertEqual(len(actual_array), len(expected_array))
cls.assertEqual(len(actual_array), count)
for i in range(0, count):
cls.assertTrue(
compare_floats(actual_array[i],
expected_array[i],
rel_tol=0.001))
def test_mnist_happy_path(self):
input_data_file = os.path.join(self.test_data_path, 'mnist_test_data_set_0_input.pb')
output_data_file = os.path.join(self.test_data_path, 'mnist_test_data_set_0_output.pb')
with open(input_data_file, 'rb') as f:
request_payload = f.read()
request = predict_pb2.PredictRequest()
request.ParseFromString(request_payload)
uri = "{}:{}".format(self.server_ip, self.server_port)
test_util.test_log(uri)
with grpc.insecure_channel(uri) as channel:
stub = prediction_service_pb2_grpc.PredictionServiceStub(channel)
actual_result = stub.Predict(request)
expected_result = predict_pb2.PredictResponse()
with open(output_data_file, 'rb') as f:
expected_result.ParseFromString(f.read())
for k in expected_result.outputs.keys():
self.assertEqual(actual_result.outputs[k].data_type, expected_result.outputs[k].data_type)
count = 1
for i in range(0, len(expected_result.outputs['Plus214_Output_0'].dims)):
self.assertEqual(actual_result.outputs['Plus214_Output_0'].dims[i], expected_result.outputs['Plus214_Output_0'].dims[i])
count = count * int(actual_result.outputs['Plus214_Output_0'].dims[i])
actual_array = numpy.frombuffer(actual_result.outputs['Plus214_Output_0'].raw_data, dtype=numpy.float32)
expected_array = numpy.frombuffer(expected_result.outputs['Plus214_Output_0'].raw_data, dtype=numpy.float32)
self.assertEqual(len(actual_array), len(expected_array))
self.assertEqual(len(actual_array), count)
for i in range(0, count):
self.assertTrue(test_util.compare_floats(actual_array[i], expected_array[i], rel_tol=0.001))
def gen_output_pb(pb_full_path, output_name, response_file_path):
t = onnx_ml_pb2.TensorProto()
with open(pb_full_path, 'rb') as fin:
t.ParseFromString(fin.read())
predict_response = predict_pb2.PredictResponse()
predict_response.outputs[output_name].CopyFrom(t)
with open(response_file_path, "wb") as fout:
fout.write(predict_response.SerializeToString())
def test_mnist_happy_path(self):
input_data_file = os.path.join(self.test_data_path, 'mnist_test_data_set_0_input.pb')
output_data_file = os.path.join(self.test_data_path, 'mnist_test_data_set_0_output.pb')
with open(input_data_file, 'rb') as f:
request_payload = f.read()
content_type_headers = ['application/x-protobuf', 'application/octet-stream', 'application/vnd.google.protobuf']
for h in content_type_headers:
request_headers = {
'Content-Type': h,
'Accept': 'application/x-protobuf'
}
url = self.url_pattern.format(self.server_ip, self.server_port, 'default_model', 12345)
test_util.test_log(url)
r = requests.post(url, headers=request_headers, data=request_payload)
self.assertEqual(r.status_code, 200)
self.assertEqual(r.headers.get('Content-Type'), 'application/x-protobuf')
self.assertTrue(r.headers.get('x-ms-request-id'))
actual_result = predict_pb2.PredictResponse()
actual_result.ParseFromString(r.content)
expected_result = predict_pb2.PredictResponse()
with open(output_data_file, 'rb') as f:
expected_result.ParseFromString(f.read())
for k in expected_result.outputs.keys():
self.assertEqual(actual_result.outputs[k].data_type, expected_result.outputs[k].data_type)
count = 1
for i in range(0, len(expected_result.outputs['Plus214_Output_0'].dims)):
self.assertEqual(actual_result.outputs['Plus214_Output_0'].dims[i], expected_result.outputs['Plus214_Output_0'].dims[i])
count = count * int(actual_result.outputs['Plus214_Output_0'].dims[i])
actual_array = numpy.frombuffer(actual_result.outputs['Plus214_Output_0'].raw_data, dtype=numpy.float32)
expected_array = numpy.frombuffer(expected_result.outputs['Plus214_Output_0'].raw_data, dtype=numpy.float32)
self.assertEqual(len(actual_array), len(expected_array))
self.assertEqual(len(actual_array), count)
for i in range(0, count):
self.assertTrue(test_util.compare_floats(actual_array[i], expected_array[i], rel_tol=0.001))
def __get_inference(url: str, port_number: str, data: np.array) -> dict:
inference_url = '{url}:{port_number}/v1/models/mymodel/versions/1:predict'.format(
url=url, port_number=port_number)
header = __get_request_header()
data = __get_request_message(data)
response = requests.post(inference_url, headers=header, data=data)
response_message = predict_pb2.PredictResponse()
response_message.ParseFromString(response.content)
return __parse_response(response_message)
def Predict(self, request, context):
"""Run predict op for each request.
Args:
request: The TensorProto which contains the map of "inputs". The request.inputs looks like {'features': dtype: DT_FLOAT tensor_shape { dim { size: 2 } } tensor_content: "\000\000 A\000\000?" }.
context: The grpc.beta._server_adaptations._FaceServicerContext object.
Returns:
The TensorProto which contains the map of "outputs". The response.outputs looks like {'softmax': dtype: DT_FLOAT tensor_shape { dim { size: 2 } } tensor_content: "\\\326\242=4\245k?\\\326\242=4\245k?" }
"""
request_map = request.inputs
feed_dict = {}
for k, v in self.inputs.items():
# Convert TensorProto objects to numpy
feed_dict[v] = tensor_util.MakeNdarray(request_map[k])
# Example result: {'key': array([ 2., 2.], dtype=float32), 'prediction': array([1, 1]), 'softmax': array([[ 0.07951042, 0.92048955], [ 0.07951042, 0.92048955]], dtype=float32)}
predict_result = self.sess.run(self.outputs, feed_dict=feed_dict)
response = predict_pb2.PredictResponse()
for k, v in predict_result.items():
# Convert numpy objects to TensorProto
response.outputs[k].CopyFrom(tensor_util.make_tensor_proto(v))
return response