def load(
cls,
config: Dict[Text, Any],
model_storage: ModelStorage,
resource: Resource,
execution_context: ExecutionContext,
**kwargs: Any,
) -> MitieIntentClassifier:
"""Loads component for inference see parent class for full docstring)."""
import mitie
text_categorizer = None
try:
with model_storage.read_from(resource) as directory:
text_categorizer = mitie.text_categorizer(
str(directory / "model.dat"))
except (
ValueError,
Exception,
): # the latter is thrown by the `mitie.text_categorizer`
logger.warning(
f"Failed to load {cls.__class__.__name__} from model storage. Resource "
f"'{resource.name}' doesn't exist.")
return cls(config, model_storage, resource, text_categorizer)
def load(cls, model_dir, intent_classifier_mitie):
# type: (Text, Text) -> MitieIntentClassifier
import mitie
if model_dir and intent_classifier_mitie:
classifier_file = os.path.join(model_dir, intent_classifier_mitie)
classifier = mitie.text_categorizer(classifier_file)
return MitieIntentClassifier(classifier)
else:
return MitieIntentClassifier()
def load(cls, model_dir=None, model_metadata=None, cached_component=None, **kwargs):
# type: (Text, Metadata, Optional[MitieIntentClassifier], **Any) -> MitieIntentClassifier
import mitie
if model_dir and model_metadata.get("intent_classifier_mitie"):
classifier_file = os.path.join(model_dir, model_metadata.get("intent_classifier_mitie"))
classifier = mitie.text_categorizer(classifier_file)
return MitieIntentClassifier(classifier)
else:
return MitieIntentClassifier()
def load(cls, model_dir, intent_classifier):
# type: (str, str) -> MitieIntentClassifier
from mitie import text_categorizer
if model_dir and intent_classifier:
classifier_file = os.path.join(model_dir, intent_classifier)
classifier = text_categorizer(classifier_file)
return MitieIntentClassifier(classifier)
else:
return MitieIntentClassifier()
def load(cls, model_dir, model_metadata, cached_component, **kwargs):
# type: (Text, Metadata, Optional[MitieIntentClassifier], **Any) -> MitieIntentClassifier
import mitie
if model_dir and model_metadata.get("intent_classifier_mitie"):
classifier_file = os.path.join(
model_dir, model_metadata.get("intent_classifier_mitie"))
classifier = mitie.text_categorizer(classifier_file)
return MitieIntentClassifier(classifier)
else:
return MitieIntentClassifier()
def load(cls,
model_dir: Optional[Text] = None,
model_metadata: Optional[Metadata] = None,
cached_component: Optional['MitieIntentClassifier'] = None,
**kwargs: Any) -> 'MitieIntentClassifier':
import mitie
meta = model_metadata.for_component(cls.name)
file_name = meta.get("classifier_file", MITIE_MODEL_FILE_NAME)
if not file_name:
return cls(meta)
classifier_file = os.path.join(model_dir, file_name)
if os.path.exists(classifier_file):
classifier = mitie.text_categorizer(classifier_file)
return cls(meta, classifier)
else:
return cls(meta)
def load(cls,
meta: Dict[Text, Any],
model_dir: Optional[Text] = None,
model_metadata: Optional[Metadata] = None,
cached_component: Optional["MitieIntentClassifier"] = None,
**kwargs: Any) -> "MitieIntentClassifier":
import mitie
file_name = meta.get("file")
if not file_name:
return cls(meta)
classifier_file = os.path.join(model_dir, file_name)
if os.path.exists(classifier_file):
classifier = mitie.text_categorizer(classifier_file)
return cls(meta, classifier)
else:
return cls(meta)
def load(cls,
meta: Dict[Text, Any],
model_dir: Optional[Text] = None,
model_metadata: Optional[Metadata] = None,
cached_component: Optional['MitieIntentClassifier'] = None,
**kwargs: Any
) -> 'MitieIntentClassifier':
import mitie
file_name = meta.get("file")
if not file_name:
return cls(meta)
classifier_file = os.path.join(model_dir, file_name)
if os.path.exists(classifier_file):
classifier = mitie.text_categorizer(classifier_file)
return cls(meta, classifier)
else:
return cls(meta)
def load(cls,
model_dir=None, # type: Optional[Text]
model_metadata=None, # type: Optional[Metadata]
cached_component=None, # type: Optional[MitieIntentClassifier]
**kwargs # type: **Any
):
# type: (...) -> MitieIntentClassifier
import mitie
meta = model_metadata.for_component(cls.name)
file_name = meta.get("classifier_file", MITIE_MODEL_FILE_NAME)
if not file_name:
return cls(meta)
classifier_file = os.path.join(model_dir, file_name)
if os.path.exists(classifier_file):
classifier = mitie.text_categorizer(classifier_file)
return cls(meta, classifier)
else:
return cls(meta)
def load(
cls,
meta: Dict[Text, Any],
model_dir: Text,
model_metadata: Optional[Metadata] = None,
cached_component: Optional["MitieIntentClassifier"] = None,
**kwargs: Any,
) -> "MitieIntentClassifier":
"""Loads trained component (see parent class for full docstring)."""
import mitie
file_name = meta.get("file")
if not file_name:
return cls(meta)
classifier_file = os.path.join(model_dir, file_name)
if os.path.exists(classifier_file):
classifier = mitie.text_categorizer(classifier_file)
return cls(meta, classifier)
else:
return cls(meta)
def __init__(self, metadata):
self.extractor = named_entity_extractor(
metadata["entity_extractor"]) # ,metadata["feature_extractor"])
self.classifier = text_categorizer(
metadata["intent_classifier"]) # ,metadata["feature_extractor"])
self.tokenizer = MITIETokenizer()
def load(self):
self.categorizer = mitie.text_categorizer(
"models/categorizer_model.dat")
