def delete_model(self, model_name):
model_server_config = model_server_config_pb2.ModelServerConfig()
config_list = model_server_config_pb2.ModelConfigList()
with lock(DEFAULT_LOCK_FILE):
try:
config_file = self._read_model_config(MODEL_CONFIG_FILE)
config_list_text = config_file.strip('\n').strip('}').strip('model_config_list: {')
config_list = text_format.Parse(text=config_list_text, message=config_list)
for config in config_list.config:
if config.name == model_name:
config_list.config.remove(config)
model_server_config.model_config_list.CopyFrom(config_list)
req = model_management_pb2.ReloadConfigRequest()
req.config.CopyFrom(model_server_config)
self.stub.HandleReloadConfigRequest(req)
self._delete_model_from_config_file(model_server_config)
# no such model exists
raise Exception(404, '{} not loaded yet.'.format(model_name))
except grpc.RpcError as e:
raise Exception(e.code(), e.details())
return 'Model {} unloaded.'.format(model_name)
def main(config_path, host):
models = load_config(config_path)
channel = grpc.insecure_channel(host)
stub = model_service_pb2_grpc.ModelServiceStub(channel)
request = model_management_pb2.ReloadConfigRequest()
model_server_config = model_server_config_pb2.ModelServerConfig()
config_list = model_server_config_pb2.ModelConfigList()
for model in models:
image_config = config_list.config.add()
image_config.name = model['config']['name']
image_config.base_path = model['config']['base_path']
image_config.model_platform = model['config']['model_platform']
model_server_config.model_config_list.CopyFrom(config_list)
request.config.CopyFrom(model_server_config)
print(request.ListFields())
print('Sending request')
response = stub.HandleReloadConfigRequest(request, 30)
if response.status.error_code == 0:
print('Reload successful')
else:
print('Reload failed!')
print(response.status.error_code)
print(response.status.error_message)
def read_add_rewrite_config():
"""
测试读取一个config文件，新加一个配置信息，并且reload过后回写
test:read a config_file and add a new model, then reload and rewrite to the config_file
:return:
"""
with open("model_config.ini", "r") as f:
config_ini = f.read()
#print(config_ini)
model_server_config = model_server_config_pb2.ModelServerConfig()
model_server_config = text_format.Parse(text=config_ini,
message=model_server_config)
one_config = model_server_config.model_config_list.config.add(
) # add one more config
one_config.name = "test2"
one_config.base_path = "/home/sparkingarthur/tools/tf-serving-custom/serving/my_models/test2"
one_config.model_platform = "tensorflow"
print(model_server_config)
channel = grpc.insecure_channel('10.200.24.101:8009')
stub = model_service_pb2_grpc.ModelServiceStub(channel)
request = model_management_pb2.ReloadConfigRequest()
request.config.CopyFrom(model_server_config)
responese = stub.HandleReloadConfigRequest(request, 10)
if responese.status.error_code == 0:
print("reload sucessfully")
else:
print("reload error!")
print(responese.status.error_code)
print(responese.status.error_message)
new_config = text_format.MessageToString(model_server_config)
with open("model_config.ini", "w+") as f:
f.write(new_config)
def parse_config_file():
"""
测试读取config_file并回写
:return:
"""
with open("model_config.ini", "r") as f:
config_ini = f.read()
print(config_ini)
channel = grpc.insecure_channel('yourip:port')
stub = model_service_pb2_grpc.ModelServiceStub(channel)
request = model_management_pb2.ReloadConfigRequest(
) ##message ReloadConfigRequest
model_server_config = model_server_config_pb2.ModelServerConfig()
x = text_format.Parse(text=config_ini,
message=model_server_config) # 非官方认证的方法
x = text_format.MessageToString(model_server_config)
with open("x.txt", "w+") as f:
f.write(x)
print(x)
print(model_server_config.IsInitialized())
request.config.CopyFrom(model_server_config)
# print(request.ListFields())
responese = stub.HandleReloadConfigRequest(request, 10)
if responese.status.error_code == 0:
print("reload sucessfully")
else:
print("reload error!")
print(responese.status.error_code)
print(responese.status.error_message)
def run():
channel = grpc.insecure_channel(sys.argv[1])
stub = model_service_pb2_grpc.ModelServiceStub(channel)
request = model_management_pb2.ReloadConfigRequest() ##message ReloadConfigRequest
model_server_config = model_server_config_pb2.ModelServerConfig()
config_list = model_server_config_pb2.ModelConfigList()##message ModelConfigList
one_config = config_list.config.add() #####try to add one model config
one_config.name= "svm_cls"
one_config.base_path = "/models/svm_cls"
one_config.model_platform="tensorflow"
#one_config.model_version_policy.specific.versions.append(4)
model_server_config.model_config_list.CopyFrom(config_list)
request.config.CopyFrom(model_server_config)
#print(request.IsInitialized())
#print(request.ListFields())
responese = stub.HandleReloadConfigRequest(request,10)
if responese.status.error_code == 0:
print("Reload sucessfully")
else:
print("Reload failed!")
print(responese.status.error_code)
print(responese.status.error_message)
def update():
config_file = "models/model.config"
host_port = "localhost:8500"
channel = grpc.insecure_channel(host_port)
stub = model_service_pb2_grpc.ModelServiceStub(channel)
request = model_management_pb2.ReloadConfigRequest()
# read config file
config_content = open(config_file, "r").read()
model_server_config = model_server_config_pb2.ModelServerConfig()
model_server_config = text_format.Parse(text=config_content, message=model_server_config)
#print model_server_config.model_config_list.config
#print(request.IsInitialized())
#print(request.ListFields())
request.config.CopyFrom(model_server_config)
request_response = stub.HandleReloadConfigRequest(request, 10)
if request_response.status.error_code == 0:
print("TF Serving config file updated.")
else:
print("Failed to update config file.")
print(request_response.status.error_code)
print(request_response.status.error_message)
def updateConfigurations():
channel = grpc.insecure_channel(const.host + ":" + const.port)
stub = model_service_pb2_grpc.ModelServiceStub(channel)
request = model_management_pb2.ReloadConfigRequest()
model_server_config = model_server_config_pb2.ModelServerConfig()
# Create a config to add to the list of served models
configurations = open("models.conf", "r").read()
config_list = model_server_config_pb2.ModelConfigList()
model_server_config = text_format.Parse(text=configurations,
message=model_server_config)
request.config.CopyFrom(model_server_config)
print(request.IsInitialized())
print(request.ListFields())
response = stub.HandleReloadConfigRequest(request, 10)
if response.status.error_code == 0:
return {"status": 200, "message": "Reload sucessfully"}
else:
return {
"status": response.status.error_code,
"message": response.status.error_message
}
def add_model(self, model_name, base_path, model_platform='tensorflow'):
# read model configs from existing model config file
model_server_config = model_server_config_pb2.ModelServerConfig()
config_list = model_server_config_pb2.ModelConfigList()
with lock(DEFAULT_LOCK_FILE):
try:
config_file = self._read_model_config(MODEL_CONFIG_FILE)
model_server_config = text_format.Parse(
text=config_file, message=model_server_config)
new_model_config = config_list.config.add()
new_model_config.name = model_name
new_model_config.base_path = base_path
new_model_config.model_platform = model_platform
# send HandleReloadConfigRequest to tensorflow model server
model_server_config.model_config_list.MergeFrom(config_list)
req = model_management_pb2.ReloadConfigRequest()
req.config.CopyFrom(model_server_config)
self.stub.HandleReloadConfigRequest(
request=req,
timeout=GRPC_REQUEST_TIMEOUT_IN_SECONDS,
wait_for_ready=True)
self._add_model_to_config_file(model_name, base_path,
model_platform)
except grpc.RpcError as e:
if e.code() is grpc.StatusCode.INVALID_ARGUMENT:
raise MultiModelException(409, e.details())
elif e.code() is grpc.StatusCode.DEADLINE_EXCEEDED:
raise MultiModelException(408, e.details())
raise MultiModelException(500, e.details())
return 'Successfully loaded model {}'.format(model_name)
def delete_model(self, model_name):
model_server_config = model_server_config_pb2.ModelServerConfig()
config_list = model_server_config_pb2.ModelConfigList()
with lock(DEFAULT_LOCK_FILE):
try:
config_file = self._read_model_config(MODEL_CONFIG_FILE)
config_list_text = config_file.strip('\n').strip('}').strip(
'model_config_list: {')
config_list = text_format.Parse(text=config_list_text,
message=config_list)
for config in config_list.config:
if config.name == model_name:
config_list.config.remove(config)
model_server_config.model_config_list.CopyFrom(
config_list)
req = model_management_pb2.ReloadConfigRequest()
req.config.CopyFrom(model_server_config)
self.stub.HandleReloadConfigRequest(
request=req,
timeout=GRPC_REQUEST_TIMEOUT_IN_SECONDS,
wait_for_ready=True)
return self._delete_model_from_config_file(
model_server_config)
# no such model exists
raise FileNotFoundError
except grpc.RpcError as e:
if e.code() is grpc.StatusCode.DEADLINE_EXCEEDED:
raise MultiModelException(408, e.details())
raise MultiModelException(500, e.details())
return 'Model {} unloaded.'.format(model_name)
def run_reload_one_config():
"""
测试gRPC的reloadconfig接口
:return:
"""
channel = grpc.insecure_channel('yourip:port')
stub = model_service_pb2_grpc.ModelServiceStub(channel)
request = model_management_pb2.ReloadConfigRequest(
) ##message ReloadConfigRequest
model_server_config = model_server_config_pb2.ModelServerConfig()
config_list = model_server_config_pb2.ModelConfigList(
) ##message ModelConfigList
####try to add one config
one_config = config_list.config.add() #
one_config.name = "test1"
one_config.base_path = "/home/model/model1"
one_config.model_platform = "tensorflow"
model_server_config.model_config_list.CopyFrom(config_list) #one of
request.config.CopyFrom(model_server_config)
print(request.IsInitialized())
print(request.ListFields())
responese = stub.HandleReloadConfigRequest(request, 10)
if responese.status.error_code == 0:
print("reload sucessfully")
else:
print("reload error!")
print(responese.status.error_code)
print(responese.status.error_message)
def initialise_blank_config(self):
"""Initialises the class instance with a blank model configuration"""
message = model_server_config_pb2.ModelServerConfig(
model_config_list=model_server_config_pb2.ModelConfigList(
config=[]))
self.config: dict = json_format.MessageToDict(message)
self.config["modelConfigList"]["config"] = []
self._models: List[dict] = self.config["modelConfigList"]["config"]
def parse_config_file(self, filepath: str) -> dict:
"""Parses the protobuf message and returns it as a dictionary
Returns:
dict: Dict representation of the protobuf message.
"""
with open(filepath, "r") as file:
config_file = file.read()
message_format = model_server_config_pb2.ModelServerConfig()
message = text_format.Parse(text=config_file, message=message_format)
self.config: dict = json_format.MessageToDict(message)
self._models: List[dict] = self.config["modelConfigList"]["config"]
def to_proto(self) -> ModelServerConfig:
"""Returns the dict representation of the model config file as a
protobuf message
Returns:
ModelServerConfig: Protobuf representation of the config file
"""
return json_format.Parse(
json.dumps(self.config),
message=model_server_config_pb2.ModelServerConfig(),
ignore_unknown_fields=False,
)
def __initialize(self):
setproctitle.setproctitle('tf-serving')
tf_serving_config_file = './config/tf_serving.json'
with open(tf_serving_config_file, 'r') as fp:
serving_config = json.load(fp)
grpc_port = serving_config['gprc_port']
use_batch = serving_config['use_batch']
options = [('grpc.max_send_message_length', 1024 * 1024 * 1024), ('grpc.max_receive_message_length', 1024 * 1024 * 1024)]
model_config_file = './config/tf_serving_model.conf'
cmd = 'tensorflow_model_server --port={} --rest_api_port={} --model_config_file={}'.format(grpc_port-1, grpc_port, model_config_file)
if use_batch:
batch_parameter_file = './config/batching.conf'
cmd = cmd + ' --enable_batching=true --batching_parameters_file={}'.format(batch_parameter_file)
self.serving_cmds = []
self.serving_cmds.append(cmd)
print(self.serving_cmds)
system_env = os.environ.copy()
self.process = subprocess.Popen(self.serving_cmds, env=system_env, shell=True)
## start grpc
self.grpc_channel = grpc.insecure_channel('127.0.0.1:{}'.format(grpc_port-1), options=options)
self.grpc_stub = model_service_pb2_grpc.ModelServiceStub(self.grpc_channel)
# wait for start tf serving
time.sleep(3)
# reload model
model_server_config = model_server_config_pb2.ModelServerConfig()
config_list = model_server_config_pb2.ModelConfigList()
model_config_json_file = './config/model.json'
with open(model_config_json_file, 'r') as fp:
model_configs = json.load(fp)
model_dir = model_configs['model_dir']
model_list = model_configs['models']
for model_info in model_list:
print(model_info)
model_config = model_server_config_pb2.ModelConfig()
model_config.name = model_info['name']
model_config.base_path = os.path.abspath(os.path.join(model_dir, model_info['path']))
model_config.model_platform = 'tensorflow'
config_list.config.append(model_config)
model_server_config.model_config_list.CopyFrom(config_list)
request = model_management_pb2.ReloadConfigRequest()
request.config.CopyFrom(model_server_config)
grpc_response = self.grpc_stub.HandleReloadConfigRequest(request, 30)
print(grpc_port)
return
def _load_model_config(
self, model_config_path: str,
source: SourceBase) -> model_server_config_pb2.ModelServerConfig:
"""
returns ModelServerConfig
"""
# load and parse
model_config_data = source.load_object(model_config_path)
models_config = model_server_config_pb2.ModelServerConfig()
tf.Parse(model_config_data, models_config)
return models_config
def run():
channel = grpc.insecure_channel('192.168.199.198:8500')
stub = model_service_pb2_grpc.ModelServiceStub(channel)
# message ReloadConfigRequest
request = model_management_pb2.ReloadConfigRequest()
model_server_config = model_server_config_pb2.ModelServerConfig()
# message ModelConfigList
config_list = model_server_config_pb2.ModelConfigList()
print(config_list)
####try to add
one_config = config_list.config.add()
one_config.name = "saved_model_half1"
one_config.base_path = "/models/saved_model_half_plus_two_cpu"
one_config.model_platform = "tensorflow"
one_config = config_list.config.add()
one_config.name = "saved_model_half2"
one_config.base_path = "/models/saved_model_half_plus_two_cpu"
one_config.model_platform = "tensorflow"
one_config = config_list.config.add()
one_config.name = "saved_model_half3"
one_config.base_path = "/models/saved_model_half_plus_two_cpu"
one_config.model_platform = "tensorflow"
one_config = config_list.config.add()
one_config.name = "saved_model_half4"
one_config.base_path = "/models/saved_model_half_plus_two_cpu"
one_config.model_platform = "tensorflow"
# one_config = config_list.config.add()
# one_config.name = "saved_model_half5"
# one_config.base_path = "/models/saved_model_half_plus_two_cpu_bak"
# one_config.model_platform = "tensorflow"
model_server_config.model_config_list.CopyFrom(config_list) # one of
request.config.CopyFrom(model_server_config)
print(request.IsInitialized())
print(request.ListFields())
response = stub.HandleReloadConfigRequest(request, 10)
if response.status.error_code == 0:
print("reload sucessfully")
else:
print("reload error!")
print(response.status.error_code)
print(response.status.error_message)
def remove_models(
self,
model_names: List[str],
model_versions: List[List[str]],
timeout: Optional[float] = None,
) -> None:
"""
Remove models to TFS.
Args:
model_names: List of model names to add.
model_versions: List of lists - each element is a list of versions for a given model name.
Raises:
grpc.RpcError in case something bad happens while communicating.
StatusCode.DEADLINE_EXCEEDED when timeout is encountered. StatusCode.UNAVAILABLE when the service is unreachable.
cortex_internal.lib.exceptions.CortexException if a non-0 response code is returned (i.e. model couldn't be unloaded).
"""
request = model_management_pb2.ReloadConfigRequest()
model_server_config = model_server_config_pb2.ModelServerConfig()
for model_name, versions in zip(model_names, model_versions):
for model_version in versions:
self._remove_model_from_dict(model_name, model_version)
config_list = model_server_config_pb2.ModelConfigList()
remaining_model_names = self._get_model_names()
for model_name in remaining_model_names:
versions, model_disk_path = self._get_model_info(model_name)
versions = [int(version) for version in versions]
model_config = config_list.config.add()
model_config.name = model_name
model_config.base_path = model_disk_path
model_config.model_version_policy.CopyFrom(
ServableVersionPolicy(specific=Specific(versions=versions))
)
model_config.model_platform = "tensorflow"
model_server_config.model_config_list.CopyFrom(config_list)
request.config.CopyFrom(model_server_config)
response = self._service.HandleReloadConfigRequest(request, timeout)
if not (response and response.status.error_code == 0):
if response:
raise CortexException(
"couldn't unload user-requested models {} - failed with error code {}: {}".format(
model_names, response.status.error_code, response.status.error_message
)
)
else:
raise CortexException("couldn't unload user-requested models")
def ReloadRequest(self,
model_server_address,
model_config_file):
"""Send AdminService.Reload request."""
print 'Sending Reload request...'
# Prepare request
config = model_server_config_pb2.ModelServerConfig()
with open(model_config_file, "r") as f:
text_format.Parse(f.read(), config)
# Send request
host, port = model_server_address.split(':')
channel = implementations.insecure_channel(host, int(port))
stub = admin_service_pb2.beta_create_AdminService_stub(channel)
result = stub.Reload(config, RPC_TIMEOUT)
print "result of reload", result
def load(path: str) -> model_server_config_pb2.ModelConfig:
"""
read model config in tf format https://www.tensorflow.org/tfx/serving/serving_config
"""
logger.info('loading model config: {}'.format(path))
# read serving config
config_str = open(path)\
.read()
# parse
model_server_config = model_server_config_pb2.ModelServerConfig()
tf.Parse(config_str, model_server_config)
return model_server_config
def main(_):
channel = grpc.insecure_channel(':8500')
stub = model_service_pb2_grpc.ModelServiceStub(channel)
request = model_management_pb2.ReloadConfigRequest()
model_server_config = model_server_config_pb2.ModelServerConfig()
_, _, _, _, _, model_configs_text = build_from_config(os.getcwd())
text_format.Parse(model_configs_text, model_server_config)
request.config.CopyFrom(model_server_config)
responese = stub.HandleReloadConfigRequest(request, 10)
if responese.status.error_code == 0:
print("successful update model")
else:
print("fail")
print(responese.status.error_code)
print(responese.status.error_message)
class ModelLoader:
"""
This class provides the interface to load new models into TensorFlow Serving. This is implemented through a
gRPC call to the TFS api which triggers it to look for directories matching the name of the model specified
"""
channel = Channel.service_channel()
request = model_management_pb2.ReloadConfigRequest()
model_server_config = model_server_config_pb2.ModelServerConfig()
conf = model_server_config_pb2.ModelConfigList()
@classmethod
def set_config(cls, model_name: str) -> None:
config = cls.conf.config.add()
config.name = model_name
config.base_path = '/models/' + model_name
config.model_platform = 'tensorflow'
cls.model_server_config.model_config_list.CopyFrom(cls.conf)
cls.request.config.CopyFrom(cls.model_server_config)
@classmethod
def load(cls, model_name: str) -> None:
"""Load model
This will send the gRPC request. In particular, it will open a gRPC channel and communicate with the
ReloadConfigRequest api to inform TFS of a change in configuration
Parameters
----------
model_name : str
Name of the model, as specified in the instantiated Learner class
Returns
-------
None
"""
cls.set_config(model_name)
log.info(cls.request.IsInitialized())
log.info(cls.request.ListFields())
response = cls.channel.HandleReloadConfigRequest(
cls.request, ServerManager.PREDICTION_TIMEOUT)
if response.status.error_code == 0:
p.print_success(f'Loaded model {model_name} successfully')
else:
p.print_error(
f'Loading failed, {response.status.error_code}: {response.status.error_message}'
)
def setUp(cls):
cls.models = [
{
"name": "model_A",
"base_path": "/path/to/model/A/"
},
{
"name": "B",
"base_path": "/path/to/model/B/"
},
]
model_config = model_server_config_pb2.ModelServerConfig(
model_config_list=model_server_config_pb2.ModelConfigList(config=[
model_server_config_pb2.ModelConfig(name=m["name"],
base_path=m["base_path"])
for m in cls.models
]))
cls.model_config_file = tempfile.NamedTemporaryFile()
with open(cls.model_config_file.name, "w") as file:
file.write(str(model_config))
cls.t = TFServingModelServerConfig()
def add_model_config(host, name):
channel = grpc.insecure_channel(host)
stub = model_service_pb2_grpc.ModelServiceStub(channel)
request = model_management_pb2.ReloadConfigRequest()
model_server_config = model_server_config_pb2.ModelServerConfig()
config_list = model_server_config_pb2.ModelConfigList()
one_config = config_list.config.add()
one_config.name = name
one_config.base_path = os.path.join('/models', name)
one_config.model_platform = 'tensorflow'
model_server_config.model_config_list.CopyFrom(config_list)
request.config.CopyFrom(model_server_config)
response = stub.HandleReloadConfigRequest(request, 10)
if response.status.error_code == 0:
print('Reload successful')
else:
print('Reload failed: {}: {}'.format(response.status.error_code,
response.status.error_message))
def __init__(self, model_config_list=None, custom_model_config=None):
super().__init__(model_server_config_pb2.ModelServerConfig(),
model_config_list=model_config_list,
custom_model_config=custom_model_config)
def getConfigurations():
channel = grpc.insecure_channel(const.host + ":" + const.port)
stub = model_service_pb2_grpc.ModelServiceStub(channel)
model_server_config = model_server_config_pb2.ModelServerConfig()
return model_server_config
def add_models(
self,
model_names: List[str],
model_versions: List[List[str]],
model_disk_paths: List[str],
signature_keys: List[Optional[str]],
skip_if_present: bool = False,
timeout: Optional[float] = None,
max_retries: int = 0,
) -> None:
"""
Add models to TFS. If they can't be loaded, use remove_models to remove them from TFS.
Args:
model_names: List of model names to add.
model_versions: List of lists - each element is a list of versions for a given model name.
model_disk_paths: The common model disk path of multiple versioned models of the same model name (i.e. modelA/ for modelA/1 and modelA/2).
skip_if_present: If the models are already loaded, don't make a new request to TFS.
signature_keys: The signature keys as set in cortex_internal.yaml. If an element is set to None, then "predict" key will be assumed.
max_retries: How many times to call ReloadConfig before giving up.
Raises:
grpc.RpcError in case something bad happens while communicating.
StatusCode.DEADLINE_EXCEEDED when timeout is encountered. StatusCode.UNAVAILABLE when the service is unreachable.
cortex_internal.lib.exceptions.CortexException if a non-0 response code is returned (i.e. model couldn't be loaded).
cortex_internal.lib.exceptions.UserException when a model couldn't be validated for the signature def.
"""
request = model_management_pb2.ReloadConfigRequest()
model_server_config = model_server_config_pb2.ModelServerConfig()
num_added_models = 0
for model_name, versions, model_disk_path in zip(
model_names, model_versions, model_disk_paths
):
for model_version in versions:
versioned_model_disk_path = os.path.join(model_disk_path, model_version)
num_added_models += self._add_model_to_dict(
model_name, model_version, versioned_model_disk_path
)
if skip_if_present and num_added_models == 0:
return
config_list = model_server_config_pb2.ModelConfigList()
current_model_names = self._get_model_names()
for model_name in current_model_names:
versions, model_disk_path = self._get_model_info(model_name)
versions = [int(version) for version in versions]
model_config = config_list.config.add()
model_config.name = model_name
model_config.base_path = model_disk_path
model_config.model_version_policy.CopyFrom(
ServableVersionPolicy(specific=Specific(versions=versions))
)
model_config.model_platform = "tensorflow"
model_server_config.model_config_list.CopyFrom(config_list)
request.config.CopyFrom(model_server_config)
while max_retries >= 0:
max_retries -= 1
try:
# to prevent HandleReloadConfigRequest from
# throwing an exception (TFS has some race-condition bug)
time.sleep(0.125)
response = self._service.HandleReloadConfigRequest(request, timeout)
break
except grpc.RpcError as err:
# to prevent HandleReloadConfigRequest from
# throwing another exception on the next run
time.sleep(0.125)
raise
if not (response and response.status.error_code == 0):
if response:
raise CortexException(
"couldn't load user-requested models {} - failed with error code {}: {}".format(
model_names, response.status.error_code, response.status.error_message
)
)
else:
raise CortexException("couldn't load user-requested models")
# get models metadata
for model_name, versions, signature_key in zip(model_names, model_versions, signature_keys):
for model_version in versions:
self._load_model_signatures(model_name, model_version, signature_key)
def add_models_config(self, names, base_paths, replace_models=False):
request = model_management_pb2.ReloadConfigRequest()
model_server_config = model_server_config_pb2.ModelServerConfig()
# create model(s) configuration
config_list = model_server_config_pb2.ModelConfigList()
for i, name in enumerate(names):
model_config = config_list.config.add()
model_config.name = name
model_config.base_path = base_paths[i]
model_config.model_platform = self.model_platform
if replace_models:
model_server_config.model_config_list.CopyFrom(config_list)
request.config.CopyFrom(model_server_config)
else:
model_server_config.model_config_list.MergeFrom(config_list)
request.config.MergeFrom(model_server_config)
loaded_models = threading.Event()
def log_loading_models():
while not loaded_models.is_set():
time.sleep(5)
cx_logger().warn("model(s) still loading ...")
log_thread = threading.Thread(target=log_loading_models, daemon=True)
log_thread.start()
# request TFS to load models
limit = 3
response = None
for i in range(limit):
try:
# this request doesn't return until all models have been successfully loaded
response = self.stub.HandleReloadConfigRequest(
request, self.timeout)
break
except Exception as e:
if not (isinstance(e, grpc.RpcError) and e.code() in [
grpc.StatusCode.UNAVAILABLE,
grpc.StatusCode.DEADLINE_EXCEEDED
]):
print(e) # unexpected error
time.sleep(1.0)
loaded_models.set()
log_thread.join()
# report error or success
if response and response.status.error_code == 0:
cx_logger().info(
"successfully loaded {} models into TF-Serving".format(names))
else:
if response:
raise CortexException(
"couldn't load user-requested models - failed with error code {}: {}"
.format(response.status.error_code,
response.status.error_message))
else:
raise CortexException("couldn't load user-requested models")
# datetime:1993/12/01
# filename:grpc_client_hot_deploy.py
# software: PyCharm
from google.protobuf import text_format
from tensorflow_serving.apis import model_management_pb2
from tensorflow_serving.apis import model_service_pb2_grpc
from tensorflow_serving.config import model_server_config_pb2
import grpc
channel = grpc.insecure_channel('ip')
config_file = "model.config"
stub = model_service_pb2_grpc.ModelServiceStub(channel)
request = model_management_pb2.ReloadConfigRequest()
# read config file
config_content = open(config_file, "r").read()
model_server_config = model_server_config_pb2.ModelServerConfig()
model_server_config = text_format.Parse(text=config_content,
message=model_server_config)
request.config.CopyFrom(model_server_config)
request_response = stub.HandleReloadConfigRequest(request, 10)
if request_response.status.error_code == 0:
open(config_file, "w").write(str(request.config))
print("TF Serving config file updated.")
else:
print("Failed to update config file.")
print(request_response.status.error_code)
print(request_response.status.error_message)
