def get_data_from_proto(
request: prediction_pb2.SeldonMessage,
) -> Union[np.ndarray, str, bytes, dict]:
"""
Extract the data payload from the SeldonMessage
Parameters
----------
request
SeldonMessage
Returns
-------
Data payload as numpy array or the raw message format. Numpy array will be returned if the "data" field was used.
"""
data_type = request.WhichOneof("data_oneof")
if data_type == "data":
datadef = request.data
return grpc_datadef_to_array(datadef)
elif data_type == "binData":
return request.binData
elif data_type == "strData":
return request.strData
elif data_type == "jsonData":
return MessageToDict(request.jsonData)
else:
raise SeldonMicroserviceException("Unknown data in SeldonMessage")
def construct_response(user_model: SeldonComponent, is_request: bool, client_request: prediction_pb2.SeldonMessage,
client_raw_response: Union[np.ndarray, str, bytes, dict]) -> prediction_pb2.SeldonMessage:
"""
Parameters
----------
user_model
Client user class
is_request
Whether this is part of the request flow as opposed to the response flow
client_request
The request received
client_raw_response
The raw client response from their model
Returns
-------
A SeldonMessage proto response
"""
data_type = client_request.WhichOneof("data_oneof")
meta = prediction_pb2.Meta()
meta_json: Dict = {}
tags = client_custom_tags(user_model)
if tags:
meta_json["tags"] = tags
metrics = client_custom_metrics(user_model)
if metrics:
meta_json["metrics"] = metrics
if client_request.meta:
if client_request.meta.puid:
meta_json["puid"] = client_request.meta.puid
json_format.ParseDict(meta_json, meta)
if isinstance(client_raw_response, np.ndarray) or isinstance(client_raw_response, list):
client_raw_response = np.array(client_raw_response)
if is_request:
names = client_feature_names(user_model, client_request.data.names)
else:
names = client_class_names(user_model, client_raw_response)
if data_type == "data": # If request is using defaultdata then return what was sent if is numeric response else ndarray
if np.issubdtype(client_raw_response.dtype, np.number):
default_data_type = client_request.data.WhichOneof("data_oneof")
else:
default_data_type = "ndarray"
else: # If numeric response return as tensor else return as ndarray
if np.issubdtype(client_raw_response.dtype, np.number):
default_data_type = "tensor"
else:
default_data_type = "ndarray"
data = array_to_grpc_datadef(default_data_type, client_raw_response, names)
return prediction_pb2.SeldonMessage(data=data, meta=meta)
elif isinstance(client_raw_response, str):
return prediction_pb2.SeldonMessage(strData=client_raw_response, meta=meta)
elif isinstance(client_raw_response, dict):
jsonDataResponse = ParseDict(client_raw_response, prediction_pb2.SeldonMessage().jsonData)
return prediction_pb2.SeldonMessage(jsonData=jsonDataResponse, meta=meta)
elif isinstance(client_raw_response, (bytes, bytearray)):
return prediction_pb2.SeldonMessage(binData=client_raw_response, meta=meta)
else:
raise SeldonMicroserviceException("Unknown data type returned as payload:" + client_raw_response)
def generate_test_requests() -> List[SeldonMessage]:
max_value = 9999
requests = []
inputs = max_value * np.random.rand(1024)
requests.append(
SeldonMessage(data=DefaultData(
tensor=Tensor(shape=inputs.shape, values=inputs))))
return requests
def predict_raw(self, request) -> SeldonMessage:
is_proto = True
if not isinstance(request, SeldonMessage):
# If `request` is a dict, parse it into a protobuf object
is_proto = False
request = ParseDict(request, SeldonMessage())
logger.debug("[PYTHON] Serialising request")
serialised = request.SerializeToString()
logger.debug("[PYTHON] Sending request to Java model")
prediction_raw = self._model.predictGRPC(serialised)
logger.debug("[PYTHON] De-serialising response")
response = SeldonMessage()
response.ParseFromString(bytes(prediction_raw))
if not is_proto:
response = MessageToDict(response)
return response
def extract_request_parts(request: prediction_pb2.SeldonMessage) -> Tuple[
Union[np.ndarray, str, bytes], Dict, prediction_pb2.DefaultData, str]:
"""
Parameters
----------
request
Input request
Returns
-------
Key parts of the request extracted
"""
features = get_data_from_proto(request)
meta = get_meta_from_proto(request)
datadef = request.data
data_type = request.WhichOneof("data_oneof")
return features, meta, datadef, data_type
def main():
model = NoJava()
# model = Baseline()
# model = ProtobufEncoding()
model = PayloadPassthrough()
model.load()
# payload = np.array([0.0, 1.1, 2.2, 3.3])
# prediction = model.predict(payload)
# message = SeldonMessage(
# data=DefaultData(tensor=Tensor(shape=[1], values=[0.0, 1.1, 2.2, 3.3]))
# )
# prediction = model.predict_raw(message)
for n in range(100000):
message = SeldonMessage(data=DefaultData(
tensor=Tensor(shape=[1], values=[0.0, 1.1, 2.2, 3.3])))
prediction = model.predict_raw(MessageToJson(message))
print(f"[PYTHON] Prediction was {prediction}")
