def create(model_metadata: Metadata, component_builder: Optional[ComponentBuilder] = None, skip_validation: bool = False) -> 'Interpreter': """Load stored model and components defined by the provided metadata.""" context = {} if component_builder is None: # If no builder is passed, every interpreter creation will result # in a new builder. hence, no components are reused. component_builder = components.ComponentBuilder() pipeline = [] # Before instantiating the component classes, # lets check if all required packages are available if not skip_validation: components.validate_requirements(model_metadata.component_classes) for i in range(model_metadata.number_of_components): component_meta = model_metadata.for_component(i) component = component_builder.load_component( component_meta, model_metadata.model_dir, model_metadata, **context) try: updates = component.provide_context() if updates: context.update(updates) pipeline.append(component) except components.MissingArgumentError as e: raise Exception("Failed to initialize component '{}'. " "{}".format(component.name, e)) return Interpreter(pipeline, context, model_metadata)
def __init__( self, cfg: RasaNLUModelConfig, component_builder: Optional[ComponentBuilder] = None, skip_validation: bool = False, model_to_finetune: Optional["Interpreter"] = None, ) -> None: self.config = cfg self.skip_validation = skip_validation self.training_data = None # type: Optional[TrainingData] if component_builder is None: # If no builder is passed, every interpreter creation will result in # a new builder. hence, no components are reused. component_builder = components.ComponentBuilder() # Before instantiating the component classes, lets check if all # required packages are available if not self.skip_validation: components.validate_requirements(cfg.component_names) if model_to_finetune: self.pipeline = model_to_finetune.pipeline else: self.pipeline = self._build_pipeline(cfg, component_builder)
def get(self, repository_version, repository_authorization, rasa_version, use_cache=True): update_request = backend().request_backend_parse_nlu( repository_version, repository_authorization) repository_name = (f"{update_request.get('version_id')}_" f"{update_request.get('total_training_end')}_" f"{update_request.get('language')}") interpreter = self.interpreters.get(repository_name) if interpreter and use_cache: return interpreter persistor = BothubPersistor(repository_version, repository_authorization, rasa_version) model_directory = mkdtemp() persistor.retrieve(str(update_request.get("repository_uuid")), model_directory) self.interpreters[repository_name] = Interpreter( None, { "language": update_request.get("language") }).load(model_directory, components.ComponentBuilder(use_cache=False)) return self.get(repository_version, repository_authorization, rasa_version)
def load_entity_extractor(data_file, config_file): training_data = load_data(data_file) configuration = config.load(config_file) comp_builder = components.ComponentBuilder() #component = comp_builder.create_component("ner_crf",configuration) #ee = EntityExtractor(components.Component(configuration)) crf = CRFEntityExtractor() crf.train(training_data, configuration) model_directory = crf.persist('./models/default/') return model_directory
def create( model_dir: Text, model_metadata: Metadata, component_builder: Optional[ComponentBuilder] = None, skip_validation: bool = False, should_finetune: bool = False, ) -> "Interpreter": """Create model and components defined by the provided metadata. Args: model_dir: The directory containing the model. model_metadata: The metadata describing each component. component_builder: The :class:`rasa.nlu.components.ComponentBuilder` to use. skip_validation: If set to `True`, does not check that all required packages for the components are installed before loading them. should_finetune: Indicates if the model components will be fine-tuned. Returns: An interpreter that uses the created model. """ context: Dict[Text, Any] = {"should_finetune": should_finetune} if component_builder is None: # If no builder is passed, every interpreter creation will result # in a new builder. hence, no components are reused. component_builder = components.ComponentBuilder() pipeline = [] # Before instantiating the component classes, # lets check if all required packages are available if not skip_validation: components.validate_requirements(model_metadata.component_classes) for i in range(model_metadata.number_of_components): component_meta = model_metadata.for_component(i) component = component_builder.load_component( component_meta, model_dir, model_metadata, **context ) try: updates = component.provide_context() if updates: context.update(updates) pipeline.append(component) except components.MissingArgumentError as e: raise Exception( "Failed to initialize component '{}'. " "{}".format(component.name, e) ) return Interpreter(pipeline, context, model_metadata)
def get(self, update, use_cache=True): interpreter = self.interpreters.get('teste') if interpreter and use_cache: return interpreter persistor = BothubPersistor(update) model_directory = mkdtemp() # persistor.retrieve( # str(update.repository.uuid), # str(update.id), # model_directory) persistor.retrieve(str('teste'), model_directory) self.interpreters['teste'] = BothubInterpreter.load( model_directory, components.ComponentBuilder(use_cache=False)) return self.get(update)
def get(self, update, repository_authorization, use_cache=True): update_request = backend().request_backend_parse_nlu( update, repository_authorization ) interpreter = self.interpreters.get(update_request.get("update_id")) if interpreter and use_cache: return interpreter persistor = BothubPersistor(update, repository_authorization) model_directory = mkdtemp() persistor.retrieve(str(update_request.get("repository_uuid")), model_directory) self.interpreters[update_request.get("update_id")] = BothubInterpreter.load( model_directory, components.ComponentBuilder(use_cache=False) ) return self.get(update, repository_authorization)
def get_interpreter(self, repository_version, repository_authorization, rasa_version, use_cache=True) -> BothubInterpreter: update_request = backend().request_backend_parse_nlu_persistor( repository_version, repository_authorization, rasa_version, no_bot_data=True) repository_name = ( f"{update_request.get('version_id')}_{update_request.get('language')}" ) last_training = f"{update_request.get('total_training_end')}" # tries to fetch cache retrieved_cache = self.cached_interpreters.get(repository_name) if retrieved_cache and use_cache: # retrieve cache only if it's the same training if retrieved_cache["last_training"] == last_training: retrieved_cache["last_request"] = datetime.now() return retrieved_cache["interpreter_data"] persistor = BothubPersistor(repository_version, repository_authorization, rasa_version) model_directory = mkdtemp() persistor.retrieve(str(update_request.get("repository_uuid")), model_directory) interpreter = BothubInterpreter( None, {"language": update_request.get("language")}) interpreter = interpreter.load( model_directory, components.ComponentBuilder(use_cache=False)) if use_cache: # update/creates cache self.cached_interpreters[repository_name] = { "last_training": last_training, "interpreter_data": interpreter, "last_request": datetime.now() } return interpreter
model_path = get_model(model) if not model_path: print_error("No model found. Train a model before running the " "server using `rasa train nlu`.") exit(1) _, nlu_model = get_model_subdirectories(model_path) if not os.path.exists(nlu_model): print_error("No NLU model found. Train a model before running the " "server using `rasa train nlu`.") exit(1) # input shell # rasa.nlu.run.run_cmdline(nlu_model) print("model_path is {},nlu_model is {}".format(model_path, nlu_model)) print("please input your text to parse") # message = input().strip() # message = "这款衣服有货吗" message = "身高170体重140" interpreter = Interpreter.load(nlu_model, component_builder) result = interpreter.parse(message) print(json.dumps(result, indent=2)) if __name__ == "__main__": component_builder = components.ComponentBuilder() test_train_nlu_core() test_parse()