def __init__(self):
self.__segmentor = Segmentor()
self.__postagger = Postagger()
self.__parser = Parser() # 初始化实例
self.__labeller = SementicRoleLabeller() # 初始化实例
self.__segmentor.load_with_lexicon(
os.path.join(LTP_MODEL_DIR, "cws.model"),
os.path.join(DICTIONARY_DIR, "custom_lexicon.model"))
self.__postagger.load(os.path.join(LTP_MODEL_DIR, "pos.model"))
self.__parser.load(os.path.join(LTP_MODEL_DIR, "parser.model")) # 加载模型
self.__labeller.load(os.path.join(LTP_MODEL_DIR,
"pisrl.model")) # 加载模型
self.__adv_dict_list = self.__load_adverb_dictionary()
self.__adv_list = self.__adv_dict_list.get("范围副词") + self.__adv_dict_list.get("频率副词") \
+ self.__adv_dict_list.get("程度副词") + self.__adv_dict_list.get("时间副词") \
+ self.__adv_dict_list.get("肯否副词") + self.__adv_dict_list.get("语气副词") \
+ self.__adv_dict_list.get("情态副词")
self.__pronoun_list = self.__load_pronoun_words()
self.__vi_list = self.__load_intransitive_verb()
self.__auxiliary_dict_list = self.__load_auxiliary_dictionary()
self.__auxiliary_list = self.__auxiliary_dict_list.get(
"语气助词") + self.__auxiliary_dict_list.get(
"结构助词") + self.__auxiliary_dict_list.get("时态助词")
self.__special_prefix_list = self.__load_special_prefix_words()
self.__stopwords_list = self.__load_stopwords("之前", "是因为", "已经")
def __init__(self):
#initialize every ltp tool
LTP_DIR = "/home/demo1/support_ltp"
#分词器
self.segmentor = Segmentor()
self.segmentor.load(os.path.join(LTP_DIR, "cws.model"))
#词性标注
self.postagger = Postagger()
self.postagger.load(os.path.join(LTP_DIR, "pos.model"))
#依存句法分析
self.parser = Parser()
self.parser.load(os.path.join(LTP_DIR, "parser.model"))
#命名实体识别
#self.recognizer = NamedEntityRecognizer()
#self.recognizer.load(os.path.join(LTP_DIR, "ner.model"))
#语义角色标注模块
self.labeller = SementicRoleLabeller()
self.labeller.load(os.path.join(LTP_DIR, 'pisrl.model'))
print('模型已全部加载')
def __init__(self):
LTP_DIR = "D:\python\ltp_data_v3.4.0"
Segmentor_lexicon = 'D:\python\ltp_data_v3.4.0\lexicon'
Segmentor_label_lexicon = 'D:\python\ltp_data_v3.4.0\lexicon_label'
Postagger_lexicon = 'D:\python\ltp_data_v3.4.0\lexicon_1'
Postagger_label_lexicon = 'D:\python\ltp_data_v3.4.0\lexicon_label_1'
self.segmentor = Segmentor()
self.segmentor_label = Segmentor()
cws_model_path = os.path.join(LTP_DIR, "cws.model")
self.segmentor.load_with_lexicon(
cws_model_path, Segmentor_lexicon) # 加载模型，第二个参数是您的外部词典文件路径
self.segmentor_label.load_with_lexicon(
cws_model_path, Segmentor_label_lexicon) # 加载模型，第二个参数是您的外部词典文件路径
self.postagger = Postagger()
self.postagger_label = Postagger()
pos_model_path = os.path.join(LTP_DIR, "pos.model")
self.postagger.load_with_lexicon(pos_model_path, Postagger_lexicon)
self.postagger_label.load_with_lexicon(pos_model_path,
Postagger_label_lexicon)
self.parser = Parser()
self.parser.load(os.path.join(LTP_DIR, "parser.model"))
self.recognizer = NamedEntityRecognizer()
self.recognizer.load(os.path.join(LTP_DIR, "ner.model"))
self.labeller = SementicRoleLabeller()
self.labeller.load(os.path.join(LTP_DIR, 'pisrl_win.model'))
def __init__(self, MODELDIR, exword_path=None):
self.MODELDIR = MODELDIR
self.output = {}
self.words = None
self.postags = None
self.netags = None
self.arcs = None
self.exword_path = exword_path # e.x: '/data1/research/matt/ltp/exwords.txt'
# 分词
self.segmentor = Segmentor()
if not self.exword_path:
# 是否加载额外词典
self.segmentor.load(os.path.join(self.MODELDIR, "cws.model"))
else:
self.segmentor.load_with_lexicon(
os.path.join(self.MODELDIR, "cws.model"), self.exword_path)
# 词性标注
self.postagger = Postagger()
self.postagger.load(os.path.join(self.MODELDIR, "pos.model"))
# 依存句法
self.parser = Parser()
self.parser.load(os.path.join(self.MODELDIR, "parser.model"))
# 命名实体识别
self.recognizer = NamedEntityRecognizer()
self.recognizer.load(os.path.join(self.MODELDIR, "ner.model"))
# 语义角色
self.labeller = SementicRoleLabeller()
self.labeller.load(os.path.join(MODELDIR, "pisrl.model"))
def load(self, index=[1, 1, 1, 1, 1]):
"""分词 词性标注 命名实体识别 句法分析 语义角色分析"""
if index[0]:
cws_model_path = os.path.join(self.LTP_DATA_DIR, 'cws.model')
self.segmentor = Segmentor()
self.segmentor.load(cws_model_path)
if index[1]:
pos_model_path = os.path.join(self.LTP_DATA_DIR, 'pos.model')
self.postagger = Postagger()
self.postagger.load(pos_model_path)
if index[2]:
ner_model_path = os.path.join(self.LTP_DATA_DIR, 'ner.model')
self.recognizer = NamedEntityRecognizer()
self.recognizer.load(ner_model_path)
if index[3]:
par_model_path = os.path.join(self.LTP_DATA_DIR, 'parser.model')
self.parser = Parser()
self.parser.load(par_model_path)
if index[4]:
srl_model_path = os.path.join(self.LTP_DATA_DIR, 'pisrl_win.model')
self.labeller = SementicRoleLabeller()
self.labeller.load(srl_model_path)
class ModelLoader:
__instance = None
def __new__(cls):
if cls.__instance is None:
cls.__instance = super(ModelLoader, cls).__new__(cls)
cls.__instance.__initialized = False
return cls.__instance
def __init__(self):
if (self.__initialized): return
self.__initialized = True
LTP_DIR = "./ltp_data"
#客製化分詞，並且後處理更改詞性
self.segmentor = Segmentor()
self.segmentor.load_with_lexicon(
os.path.join(LTP_DIR, "cws.model"),
os.path.join(LTP_DIR, 'customized.txt'))
self.postagger = Postagger()
self.postagger.load(os.path.join(LTP_DIR, "pos.model"))
self.parser = Parser()
self.parser.load(os.path.join(LTP_DIR, "parser.model"))
self.recognizer = NamedEntityRecognizer()
self.recognizer.load(os.path.join(LTP_DIR, "ner.model"))
self.labeller = SementicRoleLabeller()
self.labeller.load(os.path.join(LTP_DIR, 'pisrl.model'))
self.sentenceSplitter = SentenceSplitter()
def __init__(self, ):
LTP_DATA_DIR = SETTINGS.LTP_DATA_DIR # ltp模型目录的路径
cws_model_path = os.path.join(LTP_DATA_DIR,
'cws.model') # 分词模型路径，模型名称为`cws.model`
pos_model_path = os.path.join(LTP_DATA_DIR,
'pos.model') # 词性标注模型路径，模型名称为`pos.model`
par_model_path = os.path.join(
LTP_DATA_DIR, 'parser.model') # 依存句法分析模型路径，模型名称为`parser.model`
srl_model_path = os.path.join(
LTP_DATA_DIR,
'srl') # 语义角色标注模型目录路径，模型目录为`srl`。注意该模型路径是一个目录，而不是一个文件。
ner_model_path = os.path.join(
LTP_DATA_DIR, 'ner.model') # 命名实体识别模型路径，模型名称为`pos.model`
self.segmentor = Segmentor() # 初始化实例
self.segmentor.load_with_lexicon(cws_model_path, './segName') # 加载模型
self.postagger = Postagger() # 初始化实例
self.postagger.load_with_lexicon(pos_model_path,
'./postagName') # 加载模型
self.parser = Parser() # 初始化实例
self.parser.load(par_model_path) # 加载模型
self.labeller = SementicRoleLabeller() # 初始化实例
self.labeller.load(srl_model_path) # 加载模型
self.recognizer = NamedEntityRecognizer() # 初始化实例
self.recognizer.load(ner_model_path) # 加载模型
class LTP_word():
"""docstring for parser_word
deal处理文本，返回词表、词性及依存关系,语义，命名实体五个值
release释放缓存"""
def __init__(self, model_path):
self.model_path = model_path
self.segmentor = Segmentor() # 分词初始化实例
self.segmentor.load_with_lexicon(path.join(self.model_path, 'cws.model'), path.join(self.model_path, 'dictionary_kfc.txt'))
self.postagger = Postagger() # 词性标注初始化实例
self.postagger.load(path.join(self.model_path, 'pos.model') ) # 加载模型
self.recognizer = NamedEntityRecognizer() # 命名实体识别初始化实例
self.recognizer.load(path.join(self.model_path, 'ner.model'))
self.parser = Parser() # 依存句法初始化实例 s
self.parser.load(path.join(self.model_path, 'parser.model')) # 加载模型
self.labeller = SementicRoleLabeller() # 语义角色标注初始化实例
self.labeller.load(path.join(self.model_path, 'srl'))
def deal (self, text): #把所有该要使用的东西都提取出来
words =self.segmentor.segment(text) # 分词
postags = self.postagger.postag(words) # 词性标注
netags = self.recognizer.recognize(words, postags) #命名实体
arcs = self.parser.parse(words, postags) # 句法分析
roles = self.labeller.label(words, postags, netags, arcs) # 语义角色标注
return words,postags,arcs,roles,netags
def release(self):
self.segmentor.release()
self.postagger.release()
self.recognizer.release()
self.parser.release()
self.labeller.release()
def __init__(self):
# ltp 模型路径
LTP_DATA_DIR = './ltp_data'
# 分词模型
self.segmentor = Segmentor()
self.segmentor.load_with_lexicon(
os.path.join(LTP_DATA_DIR, 'cws.model'), 'ltp_data/lexicon.txt')
# self.segmentor.load(os.path.join(LTP_DATA_DIR,'cws.model'))
# 词性标注模型
self.postagger = Postagger()
self.postagger.load(os.path.join(LTP_DATA_DIR, 'pos.model'))
# 依存句法分析
self.parser = Parser()
self.parser.load(os.path.join(LTP_DATA_DIR, 'parser.model'))
# 命名实体识别
self.recognizer = NamedEntityRecognizer()
self.recognizer.load(os.path.join(LTP_DATA_DIR, 'ner.model'))
# 语义角色标注
self.labeller = SementicRoleLabeller()
self.labeller.load(os.path.join(LTP_DATA_DIR, 'pisrl_win.model'))
class LTP:
def __init__(self):
self.segmentor = Segmentor() # 分词器
self.segmentor.load_with_lexicon(
Config.SEGMENTOR_PATH, Config.PERSONAL_SEGMENTOR_PATH) # 加载模型
self.postagger = Postagger() # 词性分析器
self.postagger.load(Config.POSTAGGER_PATH) # 加载模型
self.parser = Parser() # 句法分析器
self.recognizer = NamedEntityRecognizer()
self.recognizer.load(Config.NAMED_ENTITY_RECONGNTION_PATH)
self.parser.load(Config.PARSER_PATH) # 加载模型
self.labeller = SementicRoleLabeller() # 语义角色分析器
self.labeller.load(Config.LABELLER_PATH) # 加载模型
self.negative_list = get_negative_list()
self.no_list = get_no_list()
self.limit_list = get_limit_list()
self.special_list = get_special_list()
self.key_sentences = []
def __del__(self):
"""
资源释放
"""
self.segmentor.release()
self.postagger.release()
self.parser.release()
self.labeller.release()
class LtpParser:
def __init__(self):
LTP_DIR = "./ltp_data_v3.4.0"
self.segmentor = Segmentor()
self.segmentor.load(os.path.join(LTP_DIR, "cws.model"))
self.postagger = Postagger()
self.postagger.load(os.path.join(LTP_DIR, "pos.model"))
self.parser = Parser()
self.parser.load(os.path.join(LTP_DIR, "parser.model"))
self.recognizer = NamedEntityRecognizer()
self.recognizer.load(os.path.join(LTP_DIR, "ner.model"))
self.labeller = SementicRoleLabeller()
self.labeller.load(os.path.join(LTP_DIR, 'pisrl.model'))
'''语义角色标注'''
def format_labelrole(self, words, postags):
arcs = self.parser.parse(words, postags)
roles = self.labeller.label(words, postags, arcs)
roles_dict = {}
for role in roles:
roles_dict[role.index] = {arg.name:[arg.name,arg.range.start, arg.range.end] for arg in role.arguments}
return roles_dict
'''句法分析---为句子中的每个词语维护一个保存句法依存儿子节点的字典'''
def build_parse_child_dict(self, words, postags, arcs):
child_dict_list = []
format_parse_list = []
for index in range(len(words)):
child_dict = dict()
for arc_index in range(len(arcs)):
if arcs[arc_index].head == index+1: #arcs的索引从1开始
if arcs[arc_index].relation in child_dict:
child_dict[arcs[arc_index].relation].append(arc_index)
else:
child_dict[arcs[arc_index].relation] = []
child_dict[arcs[arc_index].relation].append(arc_index)
child_dict_list.append(child_dict)
rely_id = [arc.head for arc in arcs] # 提取依存父节点id
relation = [arc.relation for arc in arcs] # 提取依存关系
heads = ['Root' if id == 0 else words[id - 1] for id in rely_id] # 匹配依存父节点词语
for i in range(len(words)):
# ['ATT', '李克强', 0, 'nh', '总理', 1, 'n']
a = [relation[i], words[i], i, postags[i], heads[i], rely_id[i]-1, postags[rely_id[i]-1]]
format_parse_list.append(a)
return child_dict_list, format_parse_list
'''parser主函数'''
def parser_main(self, sentence):
words = list(self.segmentor.segment(sentence))
postags = list(self.postagger.postag(words))
arcs = self.parser.parse(words, postags)
child_dict_list, format_parse_list = self.build_parse_child_dict(words, postags, arcs)
roles_dict = self.format_labelrole(words, postags)
return words, postags, child_dict_list, roles_dict, format_parse_list
def yuyijuese(words, postags, netags, arcs):
"""语义角色标注 """
labeller = SementicRoleLabeller()
labeller.load(os.path.join(MODELDIR, "srl/"))
roles = labeller.label(words, postags, netags, arcs)
for role in roles:
print (role.index, "".join(
["%s:(%d,%d)" % (arg.name, arg.range.start, arg.range.end) for arg in role.arguments]))
def __init__(self):
self.postagger = Postagger()
self.parser = Parser()
self.parser.load(par_model_path)
self.recognizer = NamedEntityRecognizer()
self.recognizer.load(ner_model_path)
self.labeller = SementicRoleLabeller()
self.labeller.load(srl_model_path)
self.postagger.load_with_lexicon(pos_model_path,
'/home/wangwei/conf/posttags.txt')
def __init__(self, data_dir: str):
self.segmentor = Segmentor()
self.segmentor.load(os.path.join(data_dir, "cws.model"))
self.postagger = Postagger()
self.postagger.load(os.path.join(data_dir, "pos.model"))
self.recognizer = NamedEntityRecognizer()
self.recognizer.load(os.path.join(data_dir, "ner.model"))
self.parser = Parser()
self.parser.load(os.path.join(data_dir, "parser.model"))
self.labeller = SementicRoleLabeller()
self.labeller.load(os.path.join(data_dir, "pisrl.model"))
def __init__(self):
self.__clause_list = []
self.__subclause_dict = {}
self.__triple_list = []
self.__segmentor = Segmentor()
self.__postagger = Postagger()
self.__recognizer = NamedEntityRecognizer()
self.__parser = Parser()
self.__labeller = SementicRoleLabeller()
self.__words_full_list = []
self.__netags_full_list = []
def ltp_labeller(self, sentence):
if self._labeller is None:
self._labeller = SementicRoleLabeller()
self._labeller.load(os.path.join(self._MODELDIR, "pisrl.model"))
arcs, words, postags = self.ltp_parser(sentence)
output = []
roles = self._labeller.label(words, postags, arcs)
for role in roles:
output.append([(role.index, arg.name, arg.range.start,
arg.range.end) for arg in role.arguments])
return output
def __init__(self):
self.segmentor = Segmentor()
self.segmentor.load('/home/student/project/project-01/Four-Little-Frogs/ltp_data_v3.4.0/cws.model')
self.postagger = Postagger()
self.postagger.load('/home/student/project/project-01/Four-Little-Frogs/ltp_data_v3.4.0/pos.model')
self.parser = Parser()
self.parser.load('/home/student/project/project-01/Four-Little-Frogs/ltp_data_v3.4.0/parser.model')
self.recognizer = NamedEntityRecognizer()
self.recognizer.load('/home/student/project/project-01/Four-Little-Frogs/ltp_data_v3.4.0/ner.model')
self.labeller = SementicRoleLabeller()
self.labeller.load('/home/student/project/project-01/Four-Little-Frogs/ltp_data_v3.4.0/pisrl.model')
def __init__(self, model_path):
self.model_path = model_path
self.segmentor = Segmentor() # 分词初始化实例
self.segmentor.load_with_lexicon(path.join(self.model_path, 'cws.model'), path.join(self.model_path, 'dictionary_kfc.txt'))
self.postagger = Postagger() # 词性标注初始化实例
self.postagger.load(path.join(self.model_path, 'pos.model') ) # 加载模型
self.recognizer = NamedEntityRecognizer() # 命名实体识别初始化实例
self.recognizer.load(path.join(self.model_path, 'ner.model'))
self.parser = Parser() # 依存句法初始化实例 s
self.parser.load(path.join(self.model_path, 'parser.model')) # 加载模型
self.labeller = SementicRoleLabeller() # 语义角色标注初始化实例
self.labeller.load(path.join(self.model_path, 'srl'))
def __init__(self):
LTP_DIR = "/home/lxl/Downloads/ltp_data"
self.postagger = Postagger()
self.postagger.load(os.path.join(LTP_DIR, "pos.model"))
self.parser = Parser()
self.parser.load(os.path.join(LTP_DIR, "parser.model"))
self.recognizer = NamedEntityRecognizer()
self.recognizer.load(os.path.join(LTP_DIR, "ner.model"))
self.labeller = SementicRoleLabeller()
self.labeller.load(os.path.join(LTP_DIR, 'pisrl.model'))
def __init__(self):
self.segmentor = Segmentor()
# self.segmentor.load_with_lexicon(seg_model_path, LTP_DICT_DIR)
self.segmentor.load(seg_model_path)
self.postagger = Postagger()
# self.postagger.load_with_lexicon(pos_model_path, LTP_POS_DICT_DIR)
self.postagger.load(pos_model_path)
self.parser = Parser()
self.parser.load(par_model_path)
self.labeller = SementicRoleLabeller()
self.labeller.load(pisrl_model_path)
def __init__(self, cws_model_path, pos_model_path, ner_model_path,
parser_model_path, srl_model_path):
# 加载ltp模型
self.segmentor = Segmentor() # 分词
self.segmentor.load(cws_model_path)
self.postagger = Postagger() # 词性标注
self.postagger.load(pos_model_path)
self.recognizer = NamedEntityRecognizer() # 命名实体识别
self.recognizer.load(ner_model_path)
self.parser = Parser() # 依存句法分析
self.parser.load(parser_model_path)
self.labeller = SementicRoleLabeller() # 语义角色标注
self.labeller.load(srl_model_path)
def load(self):
self.segmentor = Segmentor()
self.segmentor.load(self.cws_model_path)
self.postagger = Postagger()
self.postagger.load(self.pos_model_path)
self.parser = Parser()
self.parser.load(self.parser_model_path)
self.recognizer = NamedEntityRecognizer()
self.recognizer.load(self.ner_model_path)
self.labeller = SementicRoleLabeller()
self.labeller.load(self.srl_model_path)
def __init__(self):
LTP_DIR = "/Users/benkangchen/pyltp/model"
self.segmentor = Segmentor()
self.segmentor.load(os.path.join(LTP_DIR, "cws.model"))
self.postagger = Postagger()
self.postagger.load(os.path.join(LTP_DIR, "pos.model"))
self.parser = Parser()
self.parser.load(os.path.join(LTP_DIR, "parser.model"))
self.recognizer = NamedEntityRecognizer()
self.recognizer.load(os.path.join(LTP_DIR, "ner.model"))
self.labeller = SementicRoleLabeller()
self.labeller.load(os.path.join(LTP_DIR, 'pisrl.model'))
def __init__(self):
LTP_DIR = "/Users/rilzob/PycharmProjects/SubjectKG/ltp_data_v3.4.0"
self.segmentor = Segmentor()
self.segmentor.load(os.path.join(LTP_DIR, "cws.model"))
self.postagger = Postagger()
self.postagger.load(os.path.join(LTP_DIR, "pos.model"))
self.parser = Parser()
self.parser.load(os.path.join(LTP_DIR, "parser.model"))
self.recognizer = NamedEntityRecognizer()
self.recognizer.load(os.path.join(LTP_DIR, "ner.model"))
self.labeller = SementicRoleLabeller()
self.labeller.load(os.path.join(LTP_DIR, 'pisrl.model'))
def __init__(self):
ROOTDIR = os.path.join(os.path.dirname(__file__), os.pardir)
# sys.path = [os.path.join(ROOTDIR, "lib")] + sys.path
# Set your own model path
self.MODELDIR = os.path.join(ROOTDIR, "./ltp_data")
# Init LTP Model
self.segmentor = Segmentor()
self.postagger = Postagger()
self.parser = Parser()
self.recognizer = NamedEntityRecognizer()
self.labeller = SementicRoleLabeller()
self.segmentor.load(os.path.join(self.MODELDIR, "cws.model"))
self.postagger.load(os.path.join(self.MODELDIR, "pos.model"))
self.parser.load(os.path.join(self.MODELDIR, "parser.model"))
self.recognizer.load(os.path.join(self.MODELDIR, "ner.model"))
self.labeller.load(os.path.join(self.MODELDIR, "pisrl.model"))
def __init__(self):
LTP_DIR = "F:\\LTP\\ltp_data_v3.4.0\\"
self.segmentor = Segmentor()
self.segmentor.load(os.path.join(LTP_DIR, "cws.model"))
self.postagger = Postagger()
self.postagger.load(os.path.join(LTP_DIR, "pos.model"))
self.parser = Parser()
self.parser.load(os.path.join(LTP_DIR, "parser.model"))
self.recognizer = NamedEntityRecognizer()
self.recognizer.load(os.path.join(LTP_DIR, "ner.model"))
self.labeller = SementicRoleLabeller()
self.labeller.load(os.path.join(LTP_DIR, 'pisrl_win.model'))
def __init__(self):
LTP_DIR = "../../ltp_data_v3.4.0"
self.segmentor = Segmentor()
self.segmentor.load(os.path.join(LTP_DIR, "cws.model")) #分词
self.postagger = Postagger()
self.postagger.load(os.path.join(LTP_DIR, "pos.model")) #词性标注
self.parser = Parser()
self.parser.load(os.path.join(LTP_DIR, "parser.model")) #依存句法
self.recognizer = NamedEntityRecognizer()
self.recognizer.load(os.path.join(LTP_DIR, "ner.model")) #实体命名
self.labeller = SementicRoleLabeller()
self.labeller.load(os.path.join(LTP_DIR, 'pisrl.model')) #语义角色标注
def __init__(self):
LTP_DIR = 'D:\LTP\MODEL\ltp_data' # ltp模型目录的路径
self.segmentor = Segmentor()
self.segmentor.load(os.path.join(LTP_DIR, "cws.model"))# 分词模型路径，模型名称为`cws.model`
self.postagger = Postagger()
self.postagger.load(os.path.join(LTP_DIR, "pos.model"))# 词性标注模型路径，模型名称为`pos.model`
self.parser = Parser()
self.parser.load(os.path.join(LTP_DIR, "parser.model"))# 依存句法分析模型路径，模型名称为`parser.model
self.recognizer = NamedEntityRecognizer()
self.recognizer.load(os.path.join(LTP_DIR, "ner.model"))# 命名实体识别模型路径，模型名称为`ner.model`
self.labeller = SementicRoleLabeller()
self.labeller.load(os.path.join(LTP_DIR, 'pisrl_win.model'))# 语义角色标注模型目录路径，模型目录为`srl`。注意该模型路径是一个目录，而不是一个文件。
def __init__(self):
path = 'ltp_data_v3.4.0'
self.par_model_path = os.path.join(path, 'parser.model')
self.cws_model_path = os.path.join(path, 'cws.model')
self.pos_model_path = os.path.join(path, 'pos.model') # 词性标注模型路径，模型名称为`pos.model`
self.ner_model_path = os.path.join(path, 'ner.model')
self.srl_model_path = os.path.join(path, 'pisrl_win.model')
self.recognizer = NamedEntityRecognizer() # 初始化实例
self.postagger = Postagger() # 初始化实例
self.segmentor = Segmentor() # 初始化实例
self.labeller = SementicRoleLabeller() # 初始化实例
self.parser = Parser() # 初始化实例
self.parser.load(self.par_model_path) # 加载模型
self.labeller.load(self.srl_model_path) # 加载模型
self.recognizer.load(self.ner_model_path) # 加载模型
self.postagger.load(self.pos_model_path) # 加载模型
self.segmentor.load(self.cws_model_path) # 加载模型
def srl(words, postags, arcs):
global labeller
if labeller is None:
srl_model_path = os.path.join(LTP_DATA_DIR, 'srl') # 语义角色标注模型目录路径，模型目录为`srl`。注意该模型路径是一个目录，而不是一个文件。
labeller = SementicRoleLabeller() # 初始化实例
labeller.load(srl_model_path) # 加载模型
# arcs 使用依存句法分析的结果
roles = labeller.label(words, postags, arcs) # 语义角色标注
# 打印结果
role_list = []
for role in roles:
for arg in role.arguments:
args = (role.index, arg.name, arg.range.start, arg.range.end)
role_list.append(args)
return role_list
postagger.load(os.path.join(MODELDIR, "pos.model"))
postags = postagger.postag(words)
# list-of-string parameter is support in 0.1.5
# postags = postagger.postag(["中国","进出口","银行","与","中国银行","加强","合作"])
print "\t".join(postags)
parser = Parser()
parser.load(os.path.join(MODELDIR, "parser.model"))
arcs = parser.parse(words, postags)
print "\t".join("%d:%s" % (arc.head, arc.relation) for arc in arcs)
recognizer = NamedEntityRecognizer()
recognizer.load(os.path.join(MODELDIR, "ner.model"))
netags = recognizer.recognize(words, postags)
print "\t".join(netags)
labeller = SementicRoleLabeller()
labeller.load(os.path.join(MODELDIR, "srl/"))
roles = labeller.label(words, postags, netags, arcs)
for role in roles:
print role.index, "".join(
["%s:(%d,%d)" % (arg.name, arg.range.start, arg.range.end) for arg in role.arguments])
segmentor.release()
postagger.release()
parser.release()
recognizer.release()
labeller.release()
postagger.load(os.path.join(MODELDIR, "pos.model"))
postags = postagger.postag(words)
# list-of-string parameter is support in 0.1.5
# postags = postagger.postag(["中国","进出口","银行","与","中国银行","加强","合作"])
print("\t".join(postags))
parser = Parser()
parser.load(os.path.join(MODELDIR, "parser.model"))
arcs = parser.parse(words, postags)
print("\t".join("%d:%s" % (arc.head, arc.relation) for arc in arcs))
recognizer = NamedEntityRecognizer()
recognizer.load(os.path.join(MODELDIR, "ner.model"))
netags = recognizer.recognize(words, postags)
print("\t".join(netags))
labeller = SementicRoleLabeller()
labeller.load(os.path.join(MODELDIR, "pisrl.model"))
roles = labeller.label(words, postags, arcs)
for role in roles:
print(role.index, "".join(
["%s:(%d,%d)" % (arg.name, arg.range.start, arg.range.end) for arg in role.arguments]))
segmentor.release()
postagger.release()
parser.release()
recognizer.release()
labeller.release()
