class ModelZeroRPCService(object):
"""Provides methods that implement functionality of Model ZeroRPC Service."""
def __init__(self):
"""Initialize an instance of the service."""
self.model_manager = ModelManager()
self.model_manager.load_models(configuration=configuration.models)
for model in self.model_manager.get_models():
endpoint = MLModelZeroRPCCEndpoint(model_qualified_name=model["qualified_name"])
operation_name = "{}_predict".format(model["qualified_name"])
setattr(self, operation_name, endpoint)
def get_models(self):
"""Return list of models hosted in this service."""
# retrieving the list of models from the model manager
models = self.model_manager.get_models()
return models
def get_model_metadata(self, qualified_name):
"""Return metadata about a model hosted by the service."""
model_metadata = self.model_manager.get_model_metadata(qualified_name=qualified_name)
if model_metadata is not None:
return model_metadata
else:
raise ValueError("Metadata not found for this model.")
def test1(self):
""" testing the load_models() method """
# arrange
# instantiating the model manager class
model_manager = ModelManager()
# loading the MLModel objects from configuration
model_manager.load_models(configuration=[{
"module_name": "tests.model_manager_test",
"class_name": "MLModelMock"
}])
# act
exception_raised = False
model_object = None
# accessing the MLModelMock model object
try:
model_object = model_manager.get_model(
qualified_name="qualified_name")
except Exception as e:
exception_raised = True
print_tb(e)
# assert
self.assertFalse(exception_raised)
self.assertTrue(model_object is not None)
def test2(self):
"""testing the __init__() method with missing model"""
# arrange
# instantiating the model manager class
model_manager = ModelManager()
# loading the MLModel objects from configuration
model_manager.load_models(configuration=[{
"module_name": "tests.model_manager_test",
"class_name": "MLModelMock"
}])
# act
exception_raised = False
exception_message = None
try:
endpoint = MLModelZeroRPCCEndpoint(model_qualified_name="asdf")
except Exception as e:
exception_message = str(e)
print(exception_message)
exception_raised = True
# assert
self.assertTrue(exception_raised)
self.assertTrue(
exception_message == "'asdf' not found in ModelManager instance.")
def __init__(self):
"""Initialize an instance of the service."""
self.model_manager = ModelManager()
self.model_manager.load_models(configuration=configuration.models)
for model in self.model_manager.get_models():
endpoint = MLModelZeroRPCCEndpoint(model_qualified_name=model["qualified_name"])
operation_name = "{}_predict".format(model["qualified_name"])
setattr(self, operation_name, endpoint)
def test2(self):
"""testing that the ModelManager will return the same instance of an MLModel class from several different
instances of ModelManager"""
# arrange
# instantiating the model manager class
first_model_manager = ModelManager()
# loading the MLModel objects from configuration
first_model_manager.load_models(
configuration=[{
"module_name": "tests.model_manager_test",
"class_name": "MLModelMock"
}])
# act
first_model_object = first_model_manager.get_model(
qualified_name="iris_model")
# instantiating the ModelManager class again
second_model_manager = ModelManager()
second_model_object = second_model_manager.get_model(
qualified_name="iris_model")
# assert
self.assertTrue(str(first_model_object) == str(second_model_object))
def test1(self):
"""testing the __init__() method"""
# arrange
# instantiating the model manager class
model_manager = ModelManager()
# loading the MLModel objects from configuration
model_manager.load_models(configuration=[{
"module_name": "tests.model_manager_test",
"class_name": "MLModelMock"
}])
# act
endpoint = MLModelZeroRPCCEndpoint(
model_qualified_name="qualified_name")
# assert
self.assertTrue(
str(type(endpoint._model)) ==
"<class 'tests.model_manager_test.MLModelMock'>")
def test4(self):
""" testing that the ModelManager returns None when a model is not found """
# arrange
model_manager = ModelManager()
model_manager.load_models(configuration=[{
"module_name": "tests.model_manager_test",
"class_name": "MLModelMock"
}])
# act
exception_raised = False
exception_message = ""
try:
model = model_manager.get_model(qualified_name="asdf")
except Exception as e:
exception_raised = True
exception_message = str(e)
# assert
self.assertFalse(exception_raised)
self.assertTrue(model is None)
def test3(self):
""" testing that the ModelManager only allows MLModel objects to be stored """
# arrange
model_manager = ModelManager()
# act
exception_raised = False
exception_message = ""
try:
model_manager.load_models(configuration=[{
"module_name": "tests.model_manager_test",
"class_name":
"SomeClass" # using the class defined at the top of this file to test
}])
except Exception as e:
exception_raised = True
exception_message = str(e)
# assert
self.assertTrue(exception_raised)
self.assertTrue(
exception_message ==
"The ModelManager can only hold references to objects of type MLModel."
)
def __init__(self, model_qualified_name):
"""Create a ZeroRPC endpoint for a model.
:param model_qualified_name: The qualified name of the model that will be hosted in this endpoint.
:type model_qualified_name: str
:returns: An instance of MLModelZeroRPCCEndpoint.
:rtype: MLModelZeroRPCCEndpoint
"""
model_manager = ModelManager()
model_instance = model_manager.get_model(model_qualified_name)
if model_instance is None:
raise ValueError("'{}' not found in ModelManager instance.".format(
model_qualified_name))
self._model = model_manager.get_model(model_qualified_name)
# overriding the docstring of the object
self.__doc__ = "Predict with the {}.".format(self._model.display_name)
logger.info("Initializing endpoint for model: {}".format(
self._model.qualified_name))