def TransformInput():
request = extract_message()
logger.debug("Request: %s", request)
sanity_check_request(request)
if hasattr(user_model, "transform_input_rest"):
return jsonify(user_model.transform_input_rest(request))
else:
features = get_data_from_json(request)
names = request.get("data", {}).get("names")
transformed = transform_input(user_model, features, names)
logger.debug("Transformed: %s", transformed)
# If predictions is an numpy array or we used the default data then return as numpy array
if isinstance(transformed, np.ndarray) or "data" in request:
new_feature_names = get_feature_names(user_model, names)
transformed = np.array(transformed)
data = array_to_rest_datadef(transformed, new_feature_names,
request.get("data", {}))
response = {"data": data, "meta": {}}
else:
response = {"binData": transformed, "meta": {}}
tags = get_custom_tags(user_model)
if tags:
response["meta"]["tags"] = tags
metrics = get_custom_metrics(user_model)
if metrics:
response["meta"]["metrics"] = metrics
return jsonify(response)
def TransformOutput():
request = extract_message()
logger.debug("Request: %s", request)
sanity_check_request(request)
if hasattr(user_model, "transform_output_rest"):
return jsonify(user_model.transform_output_rest(request))
else:
features = get_data_from_json(request)
names = request.get("data", {}).get("names")
meta = get_meta_from_json(request)
transformed = transform_output(user_model,
features,
names,
meta=meta)
logger.debug("Transformed: %s", transformed)
if isinstance(transformed, np.ndarray) or "data" in request:
new_class_names = get_class_names(user_model, names)
data = array_to_rest_datadef(transformed, new_class_names,
request.get("data", {}))
response = {"data": data, "meta": {}}
else:
response = {"binData": transformed, "meta": {}}
tags = get_custom_tags(user_model)
if tags:
response["meta"]["tags"] = tags
metrics = get_custom_metrics(user_model)
if metrics:
response["meta"]["metrics"] = metrics
return jsonify(response)
def TransformOutput(self, request, context):
if hasattr(self.user_model, "transform_output_grpc"):
return self.user_model.transform_output_grpc(request)
else:
features = get_data_from_proto(request)
datadef = request.data
data_type = request.WhichOneof("data_oneof")
# Construct meta data
meta = prediction_pb2.Meta()
metaJson = {}
tags = get_custom_tags(self.user_model)
if tags:
metaJson["tags"] = tags
metrics = get_custom_metrics(self.user_model)
if metrics:
metaJson["metrics"] = metrics
json_format.ParseDict(metaJson, meta)
transformed = transform_output(self.user_model, features,
datadef.names)
if isinstance(transformed, np.ndarray) or data_type == "data":
transformed = np.array(transformed)
class_names = get_class_names(self.user_model, datadef.names)
if data_type == "data":
default_data_type = request.data.WhichOneof("data_oneof")
else:
default_data_type = "tensor"
data = array_to_grpc_datadef(transformed, class_names,
default_data_type)
return prediction_pb2.SeldonMessage(data=data, meta=meta)
else:
return prediction_pb2.SeldonMessage(binData=transformed,
meta=meta)
def Route():
request = extract_message()
logger.debug("Request: %s", request)
sanity_check_request(request)
if hasattr(user_router, "route_rest"):
return jsonify(user_router.route_rest(request))
else:
datadef = request.get("data")
features = rest_datadef_to_array(datadef)
routing = np.array(
[[route(user_router, features, datadef.get("names"))]])
# TODO: check that predictions is 2 dimensional
class_names = []
data = array_to_rest_datadef(routing, class_names, datadef)
response = {"data": data, "meta": {}}
tags = get_custom_tags(user_router)
if tags:
response["meta"]["tags"] = tags
metrics = get_custom_metrics(user_router)
if metrics:
response["meta"]["metrics"] = metrics
return jsonify(response)
def Route(self, request, context):
if hasattr(self.user_model, "route_grpc"):
return self.user_model.route_grpc(request)
else:
datadef = request.data
features = grpc_datadef_to_array(datadef)
routing = np.array([[route(self.user_model, features, datadef.names)]])
# TODO: check that predictions is 2 dimensional
class_names = []
data = array_to_grpc_datadef(
routing, class_names, request.data.WhichOneof("data_oneof"))
# Construct meta data
meta = prediction_pb2.Meta()
metaJson = {}
tags = get_custom_tags(self.user_model)
if tags:
metaJson["tags"] = tags
metrics = get_custom_metrics(self.user_model)
if metrics:
metaJson["metrics"] = metrics
json_format.ParseDict(metaJson, meta)
return prediction_pb2.SeldonMessage(data=data, meta=meta)
def Aggregate():
request = extract_message()
logger.debug("Request: %s", request)
sanity_check_seldon_message_list(request)
if hasattr(user_model, "aggregate_rest"):
return jsonify(user_model.aggregate_rest(request))
else:
features_list = []
names_list = []
for msg in request["seldonMessages"]:
features = get_data_from_json(msg)
names = msg.get("data", {}).get("names")
features_list.append(features)
names_list.append(names)
aggregated = aggregate(user_model, features_list, names_list)
logger.debug("Aggregated: %s", aggregated)
# If predictions is a numpy array or we used the default data then return as numpy array
if isinstance(
aggregated,
np.ndarray) or "data" in request["seldonMessages"][0]:
new_feature_names = get_feature_names(user_model,
names_list[0])
aggregated = np.array(aggregated)
data = array_to_rest_datadef(
aggregated, new_feature_names,
request["seldonMessages"][0].get("data", {}))
response = {"data": data, "meta": {}}
else:
response = {"binData": aggregated, "meta": {}}
tags = get_custom_tags(user_model)
if tags:
response["meta"]["tags"] = tags
metrics = get_custom_metrics(user_model)
if metrics:
response["meta"]["metrics"] = metrics
return jsonify(response)
def Predict(self, request, context):
if hasattr(self.user_model, "predict_grpc"):
return self.user_model.predict_grpc(request)
else:
features = get_data_from_proto(request)
meta = get_meta_from_proto(request)
datadef = request.data
data_type = request.WhichOneof("data_oneof")
predictions = predict(self.user_model,
features,
datadef.names,
meta=meta)
# Construct meta data
meta = prediction_pb2.Meta()
metaJson = {}
tags = get_custom_tags(self.user_model)
if tags:
metaJson["tags"] = tags
metrics = get_custom_metrics(self.user_model)
if metrics:
metaJson["metrics"] = metrics
json_format.ParseDict(metaJson, meta)
if isinstance(predictions, np.ndarray) or data_type == "data":
predictions = np.array(predictions)
if len(predictions.shape) > 1:
class_names = get_class_names(self.user_model,
predictions.shape[1])
else:
class_names = []
if data_type == "data":
default_data_type = request.data.WhichOneof("data_oneof")
else:
default_data_type = "tensor"
data = array_to_grpc_datadef(predictions, class_names,
default_data_type)
return prediction_pb2.SeldonMessage(data=data, meta=meta)
else:
return prediction_pb2.SeldonMessage(binData=predictions,
meta=meta)
def Aggregate(self, request, context):
if hasattr(self.user_model, "aggregate_grpc"):
return self.user_model.aggregate_grpc(request)
else:
features_list = []
names_list = []
for msg in request.seldonMessages:
features = get_data_from_proto(msg)
features_list.append(features)
names_list.append(msg.data.names)
data_type = request.seldonMessages[0].WhichOneof("data_oneof")
aggregated = aggregate(self.user_model, features_list, names_list)
# Construct meta data
meta = prediction_pb2.Meta()
metaJson = {}
tags = get_custom_tags(self.user_model)
if tags:
metaJson["tags"] = tags
metrics = get_custom_metrics(self.user_model)
if metrics:
metaJson["metrics"] = metrics
json_format.ParseDict(metaJson, meta)
if isinstance(aggregated, np.ndarray) or data_type == "data":
aggregated = np.array(aggregated)
feature_names = get_feature_names(self.user_model, [])
if data_type == "data":
default_data_type = request.seldonMessages[
0].data.WhichOneof("data_oneof")
else:
default_data_type = "tensor"
data = array_to_grpc_datadef(aggregated, feature_names,
default_data_type)
return prediction_pb2.SeldonMessage(data=data, meta=meta)
else:
return prediction_pb2.SeldonMessage(binData=aggregated,
meta=meta)
def Predict():
request = extract_message()
logger.debug("Request: %s", request)
sanity_check_request(request)
if hasattr(user_model, "predict_rest"):
return jsonify(user_model.predict_rest(request))
else:
features = get_data_from_json(request)
names = request.get("data", {}).get("names")
meta = get_meta_from_json(request)
predictions = predict(user_model, features, names, meta=meta)
logger.debug("Predictions: %s", predictions)
# If predictions is an numpy array or we used the default data then return as numpy array
if isinstance(predictions, np.ndarray) or "data" in request:
predictions = np.array(predictions)
if len(predictions.shape) > 1:
class_names = get_class_names(user_model,
predictions.shape[1])
else:
class_names = []
data = array_to_rest_datadef(predictions, class_names,
request.get("data", {}))
response = {"data": data, "meta": {}}
else:
response = {"binData": predictions, "meta": {}}
tags = get_custom_tags(user_model)
if tags:
response["meta"]["tags"] = tags
metrics = get_custom_metrics(user_model)
if metrics:
response["meta"]["metrics"] = metrics
return jsonify(response)
