def __create_model_store(self):
# Fallback for users that specified the model path as a string and hence only want a single default model.
if type(self.config.server_model_dirs) is Text:
model_dict = {
self.DEFAULT_MODEL_NAME: self.config.server_model_dirs
}
elif self.config.server_model_dirs is None:
model_dict = self.__search_for_models()
else:
model_dict = self.config.server_model_dirs
model_store = {}
for alias, model_path in list(model_dict.items()):
try:
logger.info("Loading model '{}'...".format(model_path))
model_store[alias] = self.__interpreter_for_model(model_path)
except Exception as e:
logger.exception("Failed to load model '{}'. Error: {}".format(
model_path, e))
if not model_store:
meta = Metadata({"pipeline": ["intent_classifier_keyword"]}, "")
interpreter = Interpreter.create(meta, self.config,
self.component_builder)
model_store[self.DEFAULT_MODEL_NAME] = interpreter
return model_store
def _fallback_model(self):
meta = Metadata(
{
"pipeline": [{
"name":
"intent_classifier_keyword",
"class":
utils.module_path_from_object(KeywordIntentClassifier())
}]
}, "")
return Interpreter.create(meta, self._component_builder)
def _search_for_models(self):
prefix = 'model_'
if not self._path or not os.path.isdir(self._path):
meta = Metadata({"pipeline": ["intent_classifier_keyword"]}, "")
interpreter = Interpreter.create(meta, self._config, self._component_builder)
models = {'fallback': interpreter}
else:
models = {model: None for model in os.listdir(self._path) if model.startswith(prefix)}
models.update(self._models)
self._models = models
def load_interpreter_for_model(config, persisted_path, component_builder):
def read_model_metadata(model_dir, config):
if model_dir is None:
data = Project._default_model_metadata()
return Metadata(data, model_dir)
else:
if not os.path.isabs(model_dir):
model_dir = os.path.join(config['path'], model_dir)
# download model from S3 if needed
if not os.path.isdir(model_dir):
Project._load_model_from_cloud(model_dir, config)
return Metadata.load(model_dir)
metadata = read_model_metadata(persisted_path, config)
return Interpreter.create(metadata, config, component_builder)
def _interpreter_for_model(self, model_name):
metadata = self._read_model_metadata(model_name)
return Interpreter.create(metadata, self._config,
self._component_builder)
def _fallback_model(self):
meta = Metadata({"pipeline": ["intent_classifier_keyword"]}, "")
return Interpreter.create(meta, self._config, self._component_builder)
def _fallback_model(self):
meta = Metadata({"pipeline": [{
"name": "KeywordIntentClassifier",
"class": utils.module_path_from_object(KeywordIntentClassifier())
}]}, "")
return Interpreter.create(meta, self._component_builder)
def _interpreter_for_model(self, model_name, model_dir=None):
metadata = self._read_model_metadata(model_name, model_dir)
return Interpreter.create(metadata, self._component_builder)
def _interpreter_for_model(self, model):
metadata = self._read_model_metadata(model)
return Interpreter.create(metadata, self._config, self._component_builder)
def __interpreter_for_model(self, model_path):
metadata = DataRouter.read_model_metadata(model_path, self.config)
return Interpreter.create(metadata, self.config,
self.component_builder)
def _fallback_model(self):
meta = Metadata({"pipeline": ["intent_classifier_keyword"]}, "")
return Interpreter.create(meta, self._config, self._component_builder)
def load_interpreter_for_model(config, persisted_path, component_builder):
metadata = DataRouter.read_model_metadata(persisted_path, config)
return Interpreter.create(metadata, config, component_builder)
