def replace_with_context(self, sessionid_in): self._deal_last_question(sessionid_in) # todo 添加分类 user_cur = usermanager.get_user(sessionid_in) # todo 添加当前槽位切换 domain_classification = self._domain_classification_class.classify(user_cur['str_synonym']) mylog.info('domain_classification:\t\t{}'.format(domain_classification)) usermanager.update(sessionid_in, domain_classification=domain_classification) # usermanager.get_user(sessionid_in).update_slots(index=-1,sentence_pattern_classification=sentence_pattern_classification_from_kg) # self._usermanager_class.update(sessionid_in,{'str_raw':str_in,'str_synonym':str_synonym, # 'domain_classification':domain_classification,'str_synonym_cut':str_synonym_cut}) words_list_out, dst_word_to_fufill, label2entities_cur_dict = self.replace_with_context_only_question( sessionid_in) # print('words_list_out, dst_word_to_fufill, label2entities_cur_dict==>',words_list_out, dst_word_to_fufill, label2entities_cur_dict) flag_inter, abbrev_str, abbrev2std_list = self._fuzzy_interaction_class.deal_fuzzy_interaction(sessionid_in, label2entities_cur_dict, user_cur[ 'str_raw'], words_list_out) usermanager.get_user(sessionid_in).insert_slots( **{'question': user_cur['str_synonym'], 'slots_question': label2entities_cur_dict, 'domain_classification': user_cur['domain_classification'], 'sentence_pattern_classification': user_cur['sentence_pattern_classification']}) rds.set(user_cur['jdpin_id'] + _flag_recomm_sent_pattern, 0) return words_list_out, dst_word_to_fufill, label2entities_cur_dict, flag_inter, abbrev_str, abbrev2std_list
def judge_interaction(self, sessionid_in, label2entities_cur_dict_in, str_in): #todo 添加 领域判断 jdpin_id = usermanager.get_user(sessionid_in)['jdpin_id'] sentence_classification = usermanager.get_user( sessionid_in)['sentence_pattern_classification'] key_name = jdpin_id + _flag_recomm_sent_pattern # print('key_name==>',key_name) # last_question, last_answer,last_sentence_pattern_classification = _get_last_question(sessionid_in) last_question, last_answer, last_sentence_pattern_classification = _get_last_question_info( sessionid_in, 'none') # sc_cur=self._sentence_classification_class.classification_accurate(last_question) # print('rds.get(key_name)',) # print(rds.keys()) # val_raw=rds.get(key_name) # if val_raw: # print(eval(val_raw)) # val_flag=bytes(val_raw,encoding='utf-8') # if eval(val_raw) not in [0,'0']: # print('val_flag==>',val_raw) if last_sentence_pattern_classification == pcname.query_product.value and sentence_classification in self._included_classification: mylog.info('RecomLastQuestionMultiProductInteraction return True') return True else: pass #todo 后续再打开 # val_raw=rds.get(key_name) # if val_raw: # flag_raw=eval(val_raw) # if flag_raw and flag_raw==1 : # print('测试检测到 redis 中上一句 是 推荐句式') # mylog.info('测试检测到 redis 中上一句 是 推荐句式\t keyname={}'.format(str(key_name))) # return True return False
def _deal_last_question(self, session_id_in): last_question, last_answer, last_sentence_pattern_classification = _get_last_question(session_id_in) classification = self._pattern_classification(last_question) if classification == classification_name.query_product.value: label2entities_cur_dict, words_timestap = self._get_entity_from_last_answer(last_answer) # self._slots_maintain_class.update_slots(label2entities_cur_dict, session_id_in) usermanager.get_user(session_id_in).update_slots(-1, **{usname.slots_answer.value: label2entities_cur_dict}) else: pass
def action(self, sessionid_in): str_in = self._usermanager.get_user( sessionid_in).__dict__['str_synonym'] slots_instance = usermanager.get_user( sessionid_in).get_instance_by_index(-1) # chatRecordList = getQAPairs(sessionid_in + _key_only_question_jdpin_with, _answer_type) last_question = slots_instance['question'] if last_question: label2entities_cur_dict, words_timestap = self._pronoun_deal_class.get_entity_from_strs( [str_in], dcname.alldomain.value) label2entities_history_dict = self._pronoun_deal_class.get_label2entity_from_history( sessionid_in, dcname.alldomain.value) src_list = label2entities_history_dict.get(cname.domain.value) dst_list = label2entities_cur_dict.get(cname.domain.value) if src_list and dst_list: # cur_question_rewrite = last_question.replace(src_list[-1], dst_list[-1]) self._usermanager.update(sessionid_in, str_synonym=last_question) return [src_list[-1]] if src_list else [], { cname.domain.value: [dst_list[-1]] if dst_list else [] } else: pass else: print('inherit_from_last_sentence 上文中沒有繼承到任何句子') last_question = '' return [], {}
def judge_interaction(self, sessionid_in, label2entities_cur_dict_in, str_in): #todo 添加 领域判断 user_cur = usermanager.get_user(sessionid_in) # last_question, last_answer,last_sentence_pattern_classification = _get_last_question(sessionid_in) last_question, last_answer, last_sentence_pattern_classification = _get_last_question_info( sessionid_in, flag_preprocess='question') last_label2entities_cur_dict, last_words_timestap = self._get_entity_from_strs( [last_question], user_cur['domain_classification']) mylog.info('last_question\t{}'.format(str(last_question))) mylog.info( 'last_label2entities_cur_dict[cname.domain.value\t{}'.format( str(last_label2entities_cur_dict[cname.domain.value]))) mylog.info('label2entities_cur_dict_in[cname.domain.value\t{}'.format( str(label2entities_cur_dict_in[cname.domain.value]))) mylog.info('sentence_pattern_classification\t{}'.format( str(user_cur['sentence_pattern_classification']))) if len(last_label2entities_cur_dict[cname.domain.value]) > 1 and not label2entities_cur_dict_in['domain'] and \ user_cur['sentence_pattern_classification'] in self._sentence_classifications_needed: mylog.info('LastQuestionMultiProductInteracton return True') return True else: return False
def deal_interaction(self, sessionid_in, label2entities_cur_dict_in, str_in): user_cur = usermanager.get_user(sessionid_in) domain_classification = user_cur['domain_classification'] product_names = self._entity_class.get_domain2intent2std2sim_dict[ domain_classification][cname.domain.value] product2str_dict = [{ _tmp_for_show_str.get(product_iter, product_iter): product_iter + str_in } for product_iter in product_names] return 1, _default_name_abbrev, product2str_dict
def action(self, sessionid_in): str_in = usermanager.get_user(sessionid_in).__dict__['str_synonym'] domain_classification = usermanager.get_user( sessionid_in).__dict__['domain_classification'] slots_dict = collections.defaultdict(list) for index_iter in self._indexes: slots_instance = usermanager.get_user( sessionid_in).get_slots_by_index(domain_classification, index_iter) for k, v in slots_instance.items(): if v: slots_dict[k].append(v) if cname.domain.value in slots_dict: slots_dict.pop(cname.domain.value) slots_dict_only_one = collections.defaultdict(list) for k, v in slots_dict.items(): if v: slots_dict_only_one[k] = v[0] else: slots_dict_only_one[k] = [] return [], slots_dict_only_one
def _deal_interaction(sessionid_in, strs_get_entity_from, str_cur): user_cur = usermanager.get_user(sessionid_in) last_label2entities_cur_dict, last_words_timestap = _get_entity_from_strs( strs_get_entity_from, user_cur['domain_classification']) abbrev2std_list = list() for entity_iter in last_label2entities_cur_dict[cname.domain.value]: str_iter = entity_iter + str_cur # todo 暂时,为了显示 # abbrev2std_list.append({entity_iter: str_iter}) abbrev2std_list.append( {_tmp_for_show_str.get(entity_iter, entity_iter): str_iter}) # mylog.info('获取到的abbrev2std_list\t{}'.format(str(abbrev2std_list))) return abbrev2std_list
def _get_last_question(sessionid_in): jdpin_id = usermanager.get_user(sessionid_in)['jdpin_id'] instance = usermanager.get_user(sessionid_in).get_instance_by_index(-1) last_sentence_pattern_classification = '' if instance: last_question = instance.question last_sentence_pattern_classification = instance.sentence_pattern_classification # print('last_question==>',last_question) chatRecordList = getQAPairs(jdpin_id) if chatRecordList: last_answer = chatRecordList[-1].answer last_question = chatRecordList[-1].question usermanager.get_user(sessionid_in).update_slots( -1, **{'answer': last_answer}) # mylog.info('获取 上一轮 question\t{}\n,answer\t{}\n 从 redis'.format(str(last_question),str(last_answer))) # mylog.info('redis中5轮问题 开始') # for chatrecord_iter in chatRecordList: # question_iter=chatrecord_iter.question # answer_iter=chatrecord_iter.answer # mylog.info('redis 迭代 question\t{}\t\tanswer\t{}'.format(question_iter,answer_iter)) # mylog.info('redis中5轮问题 开始') else: mylog.info( '_get_last_question 获取到instance,但是没有chatRecordList,last_question={}' .format(last_question)) last_answer = '' else: mylog.info('_get_last_question 没有获取到instance') last_question, last_answer = '', '' mylog.info( '从redis获取到的last_question\t{},\n last_answer\t{},\nlast_sentence_pattern_classification\t{}' .format(last_question, last_answer, last_sentence_pattern_classification)) return last_question, last_answer, last_sentence_pattern_classification
def _classification_sentence_pattern(self, sessionid_in,str_in): user_cur=usermanager.get_user(sessionid_in) classification = self._pattern_classification(str_in) if classification == classification_name.bottom_no_inherit.value: str_synonym, _ = self._preprocess_class.process(str_in) classification = self._pattern_classification(str_synonym) if _environ=='online': sentence_pattern_classification_from_kg = _get_sentence_pattern_from_kg(sessionid_in, user_cur['str_raw']) if sentence_pattern_classification_from_kg: # user_cur['sentence_pattern_classification'] = sentence_pattern_classification_from_kg classification=sentence_pattern_classification_from_kg else: pass return classification
def _get_sentence_pattern_from_kg(sessionid_in, str_in): jdpin = usermanager.get_user(sessionid_in)['jdpin_id'] status, result = request_post_kg(str_in, jdpin) sentence_pattern_classification_recommend = '' if status == 1: if _key_kg_sentence_classificiation in result: sentence_pattern_classification = result[_key_kg_sentence_classificiation] if sentence_pattern_classification == _value_kg_sentence_classificiation_recommendation: mylog.info('从图谱中获取句式\t{}'.format(sentence_pattern_classification)) sentence_pattern_classification_recommend = pcname.query_product.value else: pass else: pass return sentence_pattern_classification_recommend
def deal_interaction(self, sessionid_in, label2entities_cur_dict_in, str_in): user_cur = usermanager.get_user(sessionid_in) last_question, last_answer, last_sentence_pattern_classification = _get_last_question( sessionid_in) jdpin_id = user_cur['jdpin_id'] last_answer_rewrite, _ = self._preprocess_class.process(last_answer) mylog.info( 'jdpin\t{}\t获取到的last_question\t{},\n last_answer{}\t'.format( str(jdpin_id), str(last_question), str(last_answer_rewrite))) abbrev2std_list = _deal_interaction(sessionid_in, [last_answer_rewrite], str_in) if abbrev2std_list: mylog.info('deal_interaction:\t{}'.format( str(last_answer_rewrite))) return 1, _default_name_abbrev, abbrev2std_list else: return 0, '', []
def judge_interaction(self, sessionid_in, label2entities_cur_dict_in, str_in): user_cur = usermanager.get_user(sessionid_in) #{'dst_word_to_fufill':dst_word_to_fufill,'label2entities_cur_dict':label2entities_cur_dict}) dst_word_to_fufill = user_cur['dst_word_to_fufill'] label2entities_cur_dict = user_cur['label2entities_cur_dict'] str_synonym_cut = user_cur['str_synonym_cut'] str_raw_cut = user_cur['str_raw_cut'] domain_classification = user_cur['domain_classification'] intent_num = 0 if cname.property.value in dst_word_to_fufill: intent_num += len(dst_word_to_fufill[cname.property.value]) if cname.domain.value in dst_word_to_fufill: intent_num += len(dst_word_to_fufill[cname.domain.value]) if cname.property.value in label2entities_cur_dict: intent_num += len(label2entities_cur_dict[cname.property.value]) if cname.domain.value in label2entities_cur_dict: intent_num += len(label2entities_cur_dict[cname.domain.value]) if intent_num == 1 and len( str_raw_cut ) == 1 and domain_classification in self._domain_areas: return True else: return False
def get_label2entity_from_history(self, sessionid_in, domain_classification_in): """从历史数据中获取 label 对应的 实体词""" return usermanager.get_user(sessionid_in).get_slots_by_field(domain_classification_in)