def parse(self, text, intents=None): """Performs intent parsing on the provided *text* by calling its intent parsers successively Args: text (str): Input intents (str or list of str): If provided, reduces the scope of intent parsing to the provided list of intents Returns: dict: The most likely intent along with the extracted slots. See :func:`.parsing_result` for the output format. Raises: NotTrained: When the nlu engine is not fitted TypeError: When input type is not unicode """ logging.info("NLU engine parsing: '%s'...", text) if not isinstance(text, str): raise TypeError("Expected unicode but received: %s" % type(text)) if isinstance(intents, str): intents = [intents] for parser in self.intent_parsers: res = parser.parse(text, intents) if is_empty(res): continue resolved_slots = self.resolve_slots(text, res[RES_SLOTS]) return parsing_result(text, intent=res[RES_INTENT], slots=resolved_slots) return empty_result(text)
def parse(self, text, intents=None, top_n=None): """Performs intent parsing on the provided *text* by calling its intent parsers successively Args: text (str): Input intents (str or list of str, optional): If provided, reduces the scope of intent parsing to the provided list of intents top_n (int, optional): when provided, this method will return a list of at most top_n most likely intents, instead of a single parsing result. Note that the returned list can contain less than ``top_n`` elements, for instance when the parameter ``intents`` is not None, or when ``top_n`` is greater than the total number of intents. Returns: dict or list: the most likely intent(s) along with the extracted slots. See :func:`.parsing_result` and :func:`.extraction_result` for the output format. Raises: NotTrained: When the nlu engine is not fitted InvalidInputError: When input type is not unicode """ if not isinstance(text, str): raise InvalidInputError("Expected unicode but received: %s" % type(text)) if isinstance(intents, str): intents = {intents} elif isinstance(intents, list): intents = set(intents) if top_n is None: none_proba = 0.0 for parser in self.intent_parsers: res = parser.parse(text, intents) if is_empty(res): none_proba = res[RES_INTENT][RES_PROBA] continue resolved_slots = self._resolve_slots(text, res[RES_SLOTS]) return parsing_result(text, intent=res[RES_INTENT], slots=resolved_slots) return empty_result(text, none_proba) intents_results = self.get_intents(text) if intents is not None: intents_results = [ res for res in intents_results if res[RES_INTENT_NAME] in intents ] intents_results = intents_results[:top_n] results = [] for intent_res in intents_results: slots = self.get_slots(text, intent_res[RES_INTENT_NAME]) results.append(extraction_result(intent_res, slots)) return results
def parse(self, text, intents=None): """Performs intent parsing on the provided *text* by calling its intent parsers successively Args: text (str): Input intents (str or list of str): If provided, reduces the scope of intent parsing to the provided list of intents Returns: dict: The most likely intent along with the extracted slots. See :func:`.parsing_result` for the output format. Raises: NotTrained: When the nlu engine is not fitted TypeError: When input type is not unicode """ logging.info("NLU engine parsing: '%s'...", text) if not isinstance(text, str): raise TypeError("Expected unicode but received: %s" % type(text)) if not self.fitted: raise NotTrained("SnipsNLUEngine must be fitted") if isinstance(intents, str): intents = [intents] language = self._dataset_metadata["language_code"] entities = self._dataset_metadata["entities"] for parser in self.intent_parsers: res = parser.parse(text, intents) if is_empty(res): continue slots = res[RES_SLOTS] scope = [ s[RES_ENTITY] for s in slots if is_builtin_entity(s[RES_ENTITY]) ] resolved_slots = resolve_slots(text, slots, entities, language, scope) return parsing_result(text, intent=res[RES_INTENT], slots=resolved_slots) return empty_result(text)
def parse(self, text, intents=None): """Performs intent parsing on the provided *text* by calling its intent parsers successively Args: text (str): Input intents (str or list of str): If provided, reduces the scope of intent parsing to the provided list of intents Returns: dict: The most likely intent along with the extracted slots. See :func:`.parsing_result` for the output format. Raises: NotTrained: When the nlu engine is not fitted TypeError: When input type is not unicode """ if not isinstance(text, str): raise TypeError("Expected unicode but received: %s" % type(text)) if not self.fitted: raise NotTrained("SnipsNLUEngine must be fitted") if isinstance(intents, str): intents = [intents] language = self._dataset_metadata["language_code"] entities = self._dataset_metadata["entities"] for parser in self.intent_parsers: res = parser.parse(text, intents) if is_empty(res): continue slots = res[RES_SLOTS] scope = [s[RES_ENTITY] for s in slots if is_builtin_entity(s[RES_ENTITY])] resolved_slots = resolve_slots(text, slots, entities, language, scope) return parsing_result(text, intent=res[RES_INTENT], slots=resolved_slots) return empty_result(text)