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