LTP4 文档

开始使用LTP

如果你是第一次使用LTP，不妨花一些时间了解LTP能帮你做什么。

LTP提供了一系列中文自然语言处理工具，用户可以使用这些工具对于中文文本进行分词、词性标注、句法分析等等工作。从应用角度来看，LTP为用户提供了下列组件：

  • 针对单一自然语言处理任务，生成统计机器学习模型的工具

  • 针对单一自然语言处理任务，调用模型进行分析的编程接口

  • 系统可调用的，用于中文语言处理的模型文件

  • 针对单一自然语言处理任务，基于云端的编程接口

如果你的公司需要一套高性能的中文语言分析工具以处理海量的文本，或者你的在研究工作建立在一系列底层中文自然语言处理任务之上，或者你想将自己的科研成果与前沿先进工作进行对比，LTP都可能是你的选择。

快速上手

快速安装

安装LTP是非常简单的，使用Pip安装只需要：

pip install ltp

用户自定义词典

```text # user_dict.txt

负重前行 长江大桥

``` .. code-block:: python

from ltp import LTP ltp = LTP() # user_dict.txt 是词典文件， max_window是最大前向分词窗口 ltp.init_dict(path=”user_dict.txt”, max_window=4) # 也可以在代码中添加自定义的词语 ltp.add_words(words=[“负重前行”, “长江大桥”], max_window=4)

分句

使用LTP分句只需要调用ltp.sent_split函数

from ltp import LTP
ltp = LTP()
sents = ltp.sent_split(["他叫汤姆去拿外衣。", "汤姆生病了。他去了医院。"])

# [
#   "他叫汤姆去拿外衣。",
#   "汤姆生病了。",
#   "他去了医院。"
# ]

分词

使用LTP分词非常简单，下面是一个简短的例子：

from ltp import LTP

ltp = LTP()

segment, _ = ltp.seg(["他叫汤姆去拿外衣。"])
# [['他', '叫', '汤姆', '去', '拿', '外衣', '。']]

词性标注

from ltp import LTP

ltp = LTP()

seg, hidden = ltp.seg(["他叫汤姆去拿外衣。"])
pos = ltp.pos(hidden)
# [['他', '叫', '汤姆', '去', '拿', '外衣', '。']]
# [['r', 'v', 'nh', 'v', 'v', 'n', 'wp']]

命名实体识别

from ltp import LTP

ltp = LTP()

seg, hidden = ltp.seg(["他叫汤姆去拿外衣。"])
ner = ltp.ner(hidden)
# [['他', '叫', '汤姆', '去', '拿', '外衣', '。']]
# [[('Nh', 2, 2)]]

tag, start, end = ner[0][0]
print(tag,":", "".join(seg[0][start:end + 1]))]
# Nh : 汤姆

语义角色标注

from ltp import LTP

ltp = LTP()

seg, hidden = ltp.seg(["他叫汤姆去拿外衣。"])
srl = ltp.srl(hidden)
# [['他', '叫', '汤姆', '去', '拿', '外衣', '。']]
# [
#     [
#         [],                                                # 他
#         [('ARG0', 0, 0), ('ARG1', 2, 2), ('ARG2', 3, 5)],  # 叫 -> [ARG0: 他, ARG1: 汤姆, ARG2: 拿外衣]
#         [],                                                # 汤姆
#         [],                                                # 去
#         [('ARG0', 2, 2), ('ARG1', 5, 5)],                  # 拿 -> [ARG0: 汤姆, ARG1: 外衣]
#         [],                                                # 外衣
#         []                                                 # 。
#     ]
# ]
srl = ltp.srl(hidden, keep_empty=False)
# [
#     [
#         (1, [('ARG0', 0, 0), ('ARG1', 2, 2), ('ARG2', 3, 5)]), # 叫 -> [ARG0: 他, ARG1: 汤姆, ARG2: 拿外衣]
#         (4, [('ARG0', 2, 2), ('ARG1', 5, 5)])                  # 拿 -> [ARG0: 汤姆, ARG1: 外衣]
#     ]
# ]

依存句法分析

需要注意的是，在依存句法当中，虚节点ROOT占据了0位置，因此节点的下标从1开始。

from ltp import LTP

ltp = LTP()

seg, hidden = ltp.seg(["他叫汤姆去拿外衣。"])
dep = ltp.dep(hidden)
# [['他', '叫', '汤姆', '去', '拿', '外衣', '。']]
# [
#     [
#         (1, 2, 'SBV'),
#         (2, 0, 'HED'),    # 叫 --|HED|--> ROOT
#         (3, 2, 'DBL'),
#         (4, 2, 'VOB'),
#         (5, 4, 'COO'),
#         (6, 5, 'VOB'),
#         (7, 2, 'WP')
#     ]
# ]

语义依存分析(树)

与依存句法类似的，这里的下标也是从1开始。

from ltp import LTP

ltp = LTP()

seg, hidden = ltp.seg(["他叫汤姆去拿外衣。"])
sdp = ltp.sdp(hidden, graph=False)
# [['他', '叫', '汤姆', '去', '拿', '外衣', '。']]
# [
#     [
#         (1, 2, 'Agt'),
#         (2, 0, 'Root'),   # 叫 --|Root|--> ROOT
#         (3, 2, 'Datv'),
#         (4, 2, 'eEfft'),
#         (5, 4, 'eEfft'),
#         (6, 5, 'Pat'),
#         (7, 2, 'mPunc')
#     ]
# ]

语义依存分析(图)

与依存句法类似的，这里的下标也是从1开始。

from ltp import LTP

ltp = LTP()

seg, hidden = ltp.seg(["他叫汤姆去拿外衣。"])
sdp = ltp.sdp(hidden, graph=True)
# [['他', '叫', '汤姆', '去', '拿', '外衣', '。']]
# [
#     [
#         (1, 2, 'Agt'),
#         (2, 0, 'Root'),   # 叫 --|Root|--> ROOT
#         (3, 2, 'Datv'),
#         (3, 4, 'Agt'),
#         (3, 5, 'Agt'),
#         (4, 2, 'eEfft'),
#         (5, 4, 'eEfft'),
#         (6, 5, 'Pat'),
#         (7, 2, 'mPunc')
#     ]
# ]

LTP Server

LTP Server 是对 LTP 的一个简单包装，依赖于 tornado，使用方式如下：

pip install ltp, tornado
python utils/server.py serve

性能

分词模块

基础模型在人民日报测试数据上的性能如下：

语料信息：人民日报1998年2月-6月(后10%数据作为开发集)作为训练数据，1月作为测试数据。

F1

开发集

98.4%

测试集

98.4%

词性标注模块

与分词模块相同，我们将词性标注任务建模为基于词的序列标注问题。对于输入句子的词序列，模型给句子中的每个词标注一个标识词边界的标记。在LTP中，我们采用的北大标注集。关于北大标注集信息，请参考：

基础模型在人民日报数据集上的性能如下：

语料信息：人民日报1998年2月-6月(后10%数据作为开发集)作为训练数据，1月作为测试数据。

ACC

开发集

98.2%

测试集

98.2%

命名实体识别模块

与分词模块相同，我们将命名实体识别建模为基于词的序列标注问题。对于输入句子的词序列，模型给句子中的每个词标注一个标识命名实体边界和实体类别的标记。在LTP中，我们支持人名、地名、机构名三类命名实体的识别。关于LTP使用的标记参考附录。

基础模型在人民日报数据集上的性能如下：

语料信息：人民日报1998年1月做训练（后10%数据作为开发集），6月前10000句做测试作为训练数据。

F1

开发集

95.1

测试集

94.3

依存句法分析模块

依存句法分析模块的主要算法依据神经网络依存句法分析算法，Chen and Manning (2014)。同时加入丰富的全局特征和聚类特征。在模型训练时，我们也参考了Yoav等人关于dynamic oracle的工作。 在 Chinese Dependency Treebank(CDT) 数据集上，其中运行速度和内存开销从CDT测试集上结果中获得。

LAS

开发集

88.8

测试集

88.0

语义角色标注模块

在LTP中，我们实现一种端到端的SRL模型。

在CTB数据集上，利用LTP的自动词性及句法信息，SRL性能如下所示：

F1

开发集

77.0%

测试集

77.2%

API文档

开始使用LTP

如果你是第一次使用LTP，不妨花一些时间了解LTP能帮你做什么。

LTP提供了一系列中文自然语言处理工具，用户可以使用这些工具对于中文文本进行分词、词性标注、句法分析等等工作。从应用角度来看，LTP为用户提供了下列组件：

  • 针对单一自然语言处理任务，生成统计机器学习模型的工具

  • 针对单一自然语言处理任务，调用模型进行分析的编程接口

  • 系统可调用的，用于中文语言处理的模型文件

  • 针对单一自然语言处理任务，基于云端的编程接口

如果你的公司需要一套高性能的中文语言分析工具以处理海量的文本，或者你的在研究工作建立在一系列底层中文自然语言处理任务之上，或者你想将自己的科研成果与前沿先进工作进行对比，LTP都可能是你的选择。

快速上手

快速安装

安装LTP是非常简单的，使用Pip安装只需要：

pip install ltp

用户自定义词典

```text # user_dict.txt

负重前行 长江大桥

``` .. code-block:: python

from ltp import LTP ltp = LTP() # user_dict.txt 是词典文件， max_window是最大前向分词窗口 ltp.init_dict(path=”user_dict.txt”, max_window=4) # 也可以在代码中添加自定义的词语 ltp.add_words(words=[“负重前行”, “长江大桥”], max_window=4)

分句

使用LTP分句只需要调用ltp.sent_split函数

from ltp import LTP
ltp = LTP()
sents = ltp.sent_split(["他叫汤姆去拿外衣。", "汤姆生病了。他去了医院。"])

# [
#   "他叫汤姆去拿外衣。",
#   "汤姆生病了。",
#   "他去了医院。"
# ]

分词

使用LTP分词非常简单，下面是一个简短的例子：

from ltp import LTP

ltp = LTP()

segment, _ = ltp.seg(["他叫汤姆去拿外衣。"])
# [['他', '叫', '汤姆', '去', '拿', '外衣', '。']]

词性标注

from ltp import LTP

ltp = LTP()

seg, hidden = ltp.seg(["他叫汤姆去拿外衣。"])
pos = ltp.pos(hidden)
# [['他', '叫', '汤姆', '去', '拿', '外衣', '。']]
# [['r', 'v', 'nh', 'v', 'v', 'n', 'wp']]

命名实体识别

from ltp import LTP

ltp = LTP()

seg, hidden = ltp.seg(["他叫汤姆去拿外衣。"])
ner = ltp.ner(hidden)
# [['他', '叫', '汤姆', '去', '拿', '外衣', '。']]
# [[('Nh', 2, 2)]]

tag, start, end = ner[0][0]
print(tag,":", "".join(seg[0][start:end + 1]))]
# Nh : 汤姆

语义角色标注

from ltp import LTP

ltp = LTP()

seg, hidden = ltp.seg(["他叫汤姆去拿外衣。"])
srl = ltp.srl(hidden)
# [['他', '叫', '汤姆', '去', '拿', '外衣', '。']]
# [
#     [
#         [],                                                # 他
#         [('ARG0', 0, 0), ('ARG1', 2, 2), ('ARG2', 3, 5)],  # 叫 -> [ARG0: 他, ARG1: 汤姆, ARG2: 拿外衣]
#         [],                                                # 汤姆
#         [],                                                # 去
#         [('ARG0', 2, 2), ('ARG1', 5, 5)],                  # 拿 -> [ARG0: 汤姆, ARG1: 外衣]
#         [],                                                # 外衣
#         []                                                 # 。
#     ]
# ]
srl = ltp.srl(hidden, keep_empty=False)
# [
#     [
#         (1, [('ARG0', 0, 0), ('ARG1', 2, 2), ('ARG2', 3, 5)]), # 叫 -> [ARG0: 他, ARG1: 汤姆, ARG2: 拿外衣]
#         (4, [('ARG0', 2, 2), ('ARG1', 5, 5)])                  # 拿 -> [ARG0: 汤姆, ARG1: 外衣]
#     ]
# ]

依存句法分析

需要注意的是，在依存句法当中，虚节点ROOT占据了0位置，因此节点的下标从1开始。

from ltp import LTP

ltp = LTP()

seg, hidden = ltp.seg(["他叫汤姆去拿外衣。"])
dep = ltp.dep(hidden)
# [['他', '叫', '汤姆', '去', '拿', '外衣', '。']]
# [
#     [
#         (1, 2, 'SBV'),
#         (2, 0, 'HED'),    # 叫 --|HED|--> ROOT
#         (3, 2, 'DBL'),
#         (4, 2, 'VOB'),
#         (5, 4, 'COO'),
#         (6, 5, 'VOB'),
#         (7, 2, 'WP')
#     ]
# ]

语义依存分析(树)

与依存句法类似的，这里的下标也是从1开始。

from ltp import LTP

ltp = LTP()

seg, hidden = ltp.seg(["他叫汤姆去拿外衣。"])
sdp = ltp.sdp(hidden, graph=False)
# [['他', '叫', '汤姆', '去', '拿', '外衣', '。']]
# [
#     [
#         (1, 2, 'Agt'),
#         (2, 0, 'Root'),   # 叫 --|Root|--> ROOT
#         (3, 2, 'Datv'),
#         (4, 2, 'eEfft'),
#         (5, 4, 'eEfft'),
#         (6, 5, 'Pat'),
#         (7, 2, 'mPunc')
#     ]
# ]

语义依存分析(图)

与依存句法类似的，这里的下标也是从1开始。

from ltp import LTP

ltp = LTP()

seg, hidden = ltp.seg(["他叫汤姆去拿外衣。"])
sdp = ltp.sdp(hidden, graph=True)
# [['他', '叫', '汤姆', '去', '拿', '外衣', '。']]
# [
#     [
#         (1, 2, 'Agt'),
#         (2, 0, 'Root'),   # 叫 --|Root|--> ROOT
#         (3, 2, 'Datv'),
#         (3, 4, 'Agt'),
#         (3, 5, 'Agt'),
#         (4, 2, 'eEfft'),
#         (5, 4, 'eEfft'),
#         (6, 5, 'Pat'),
#         (7, 2, 'mPunc')
#     ]
# ]

LTP Server

LTP Server 是对 LTP 的一个简单包装，依赖于 tornado，使用方式如下：

pip install ltp, tornado
python utils/server.py serve

性能

分词模块

基础模型在人民日报测试数据上的性能如下：

语料信息：人民日报1998年2月-6月(后10%数据作为开发集)作为训练数据，1月作为测试数据。

F1

开发集

98.4%

测试集

98.4%

词性标注模块

与分词模块相同，我们将词性标注任务建模为基于词的序列标注问题。对于输入句子的词序列，模型给句子中的每个词标注一个标识词边界的标记。在LTP中，我们采用的北大标注集。关于北大标注集信息，请参考：

基础模型在人民日报数据集上的性能如下：

语料信息：人民日报1998年2月-6月(后10%数据作为开发集)作为训练数据，1月作为测试数据。

ACC

开发集

98.2%

测试集

98.2%

命名实体识别模块

与分词模块相同，我们将命名实体识别建模为基于词的序列标注问题。对于输入句子的词序列，模型给句子中的每个词标注一个标识命名实体边界和实体类别的标记。在LTP中，我们支持人名、地名、机构名三类命名实体的识别。关于LTP使用的标记参考附录。

基础模型在人民日报数据集上的性能如下：

语料信息：人民日报1998年1月做训练（后10%数据作为开发集），6月前10000句做测试作为训练数据。

F1

开发集

95.1

测试集

94.3

依存句法分析模块

依存句法分析模块的主要算法依据神经网络依存句法分析算法，Chen and Manning (2014)。同时加入丰富的全局特征和聚类特征。在模型训练时，我们也参考了Yoav等人关于dynamic oracle的工作。 在 Chinese Dependency Treebank(CDT) 数据集上，其中运行速度和内存开销从CDT测试集上结果中获得。

LAS

开发集

88.8

测试集

88.0

语义角色标注模块

在LTP中，我们实现一种端到端的SRL模型。

在CTB数据集上，利用LTP的自动词性及句法信息，SRL性能如下所示：

F1

开发集

77.0%

测试集

77.2%

核心

可注册元类

class Registrable(name, bases, ns, *, alias=False)[源代码]

基类：type

可注册元类

给基类提供以下功能

  1. 通过名字访问子类

  2. 列出子类的类型

  3. 构造生成子类对象

register(cls, name, override=False, hooks=None)[源代码]

装饰器 Class decorator for registering a subclass.

参数

  • name – 注册名

  • override (bool) – 当name已经注册时，是否进行覆盖

  • hooks (List[HookType]) – 在注册时会被执行的Hook函数

引发

RegistrationError – 如果 override 为 false 并且 name 已经被注册

weak_register(cls, name, subclass, override=False, hooks=None)[源代码]

用于手动对子类进行注册

参数

  • name (str) – 子类的引用名

  • subclass – 子类类型

  • override (bool) – 当name已经注册时，是否进行覆盖

  • hooks – 在注册时会被执行的Hook函数

引发

RegistrationError – 如果 override 为 false 并且 name 已经被注册

hook(cls, hook)[源代码]

函数装饰器，给某个类注册装饰器

by_name(cls, name)[源代码]

通过注册的名字取得实际的类型

参数

name – 注册的名字

返回

Type[T] 使用 name 注册的子类

返回类型

class

引发

RegistrationError – 如果 name 未被注册

list_available(cls)[源代码]

列出所有的注册子类

is_registered(cls, name)[源代码]

如果 name 在类中已经注册，则返回 True

iter_registered(cls)[源代码]

迭代已经注册的名字和对象

from_params(cls, __config, *args, extra=None, **kwargs)[源代码]

使用 config 生成对象

参数

  • cls – 类型

  • __config – 配置项，通常为字典，形如 {‘class’:’ClassName’, ‘init’:{ ‘arg’: arg } }

  • *args – 直接传入的arg

  • extra – 根据需要传入的数据

  • **kwargs – 其他参数

返回

根据参数生成的对象

异常

exception Error[源代码]

基类：Exception

exception RegistrationError[源代码]

基类：ltp.core.exceptions.Error

exception DataUnsupported[源代码]

基类：ltp.core.exceptions.Error

数据

子模块

数据集(Dataset)

class Example[源代码]

基类：object

class Dataset(examples, fields, filter_pred=None)[源代码]

基类：torch.utils.data.dataset.Dataset

数据集抽象类，在配置文件中的配置项通常为:

[Dataset]
class = "CTB"

[Dataset.init]
path="data/postag"
train="train.txt"
validation="dev.txt"
test="test.txt"

定义一个由 Examples 和 Fields 组合成的 Dataset

sort_key

用于在生成Batch的是时候进行排序的函数

Type

callable

examples

数据集的 Examples

Type

List[Example]

fields

Fields，同一个 Field Object 会共享它们的 Vocab

Type

dict[str, Field]

classmethod splits(path=None, root='.data', train=None, validation=None, test=None, **kwargs)[源代码]

一次创建多个数据集

参数

  • path – 数据集路径前缀

  • root – 根目录

  • train – 训练集文件名

  • validation – 验证集文件名

  • test – 测试集文件名

  • **kwargs – 其他传给Dataset的参数

返回

Tuple[Dataset] train, validation, test

split(split_ratio=0.7, stratified=False, strata_field='label', random_state=None)[源代码]

通过切分当前数据集的Examples以获得多个数据集

参数

  • split_ratio (float/list(float)) – 切分比例(默认为0.7)

  • stratified – 是否进行分层采样

  • strata_field – 分层采样的field

  • random_state – 用于Shuffle的随机种子`random.getstate()`的返回值

返回

Tuple[Dataset] train, validation, test Dataset

filter_examples(field_names)[源代码]

Remove unknown words from dataset examples with respect to given field.

参数

field_names (list(str)) – Within example only the parts with field names in field_names will have their unknown words deleted.

classmethod by_name(name)

通过注册的名字取得实际的类型

参数

name – 注册的名字

返回

Type[T] 使用 name 注册的子类

返回类型

class

引发

RegistrationError – 如果 name 未被注册

classmethod from_params(__config, *args, extra=None, **kwargs)

使用 config 生成对象

参数

  • cls – 类型

  • __config – 配置项，通常为字典，形如 {‘class’:’ClassName’, ‘init’:{ ‘arg’: arg } }

  • *args – 直接传入的arg

  • extra – 根据需要传入的数据

  • **kwargs – 其他参数

返回

根据参数生成的对象

classmethod hook(hook)

函数装饰器，给某个类注册装饰器

classmethod is_registered(name)

如果 name 在类中已经注册，则返回 True

classmethod iter_registered()

迭代已经注册的名字和对象

classmethod list_available()

列出所有的注册子类

classmethod register(name, override=False, hooks=None)

装饰器 Class decorator for registering a subclass.

参数

  • name – 注册名

  • override (bool) – 当name已经注册时，是否进行覆盖

  • hooks (List[HookType]) – 在注册时会被执行的Hook函数

引发

RegistrationError – 如果 override 为 false 并且 name 已经被注册

classmethod weak_register(name, subclass, override=False, hooks=None)

用于手动对子类进行注册

参数

  • name (str) – 子类的引用名

  • subclass – 子类类型

  • override (bool) – 当name已经注册时，是否进行覆盖

  • hooks – 在注册时会被执行的Hook函数

引发

RegistrationError – 如果 override 为 false 并且 name 已经被注册

class LineDataset(path, file, fields, split='\x00', maxsplit=0, silent=True, proxy_property=None, line_split=None, line_strip=None, **kwargs)[源代码]

基类：ltp.data.dataset.dataset.Dataset

Dataset 注册名: line 每一行一个句子，词语之间按空格分割，下划线分割词语与词性，例子如下:

上海_NR   浦东_NR   开发_NN   与_CC    法制_NN   建设_NN   同步_VV

或者使用其他字符分割(由split参数控制)

上海/NR 浦东/NR 开发/NN 与/CC 法制/NN 建设/NN 同步/VV

class CorpusDataset(path, file, fields, multi_field=None, split=None, strip=None, proxy_property=None, **kwargs)[源代码]

基类：ltp.data.dataset.dataset.Dataset

Dataset 注册名: Corpus Conll 文本标准，不同Field之间使用 Tab 分割，不同句子之间有一空行，例子如下:

科学      _       O       B-ARG0  B-ARG0  O
发展观     _       O       I-ARG0  I-ARG0  O
绝对      _       O       B-ARGM-ADV      B-ARGM-ADV      O
不       _       O       B-ARGM-ADV      B-ARGM-ADV      O
class MixedDataset(path, file, fields, text='text')[源代码]

基类：ltp.data.dataset.dataset.Dataset

数据域(Field)

class Field(name, preprocessing=None, postprocessing=None, is_target=False)[源代码]

基类：object

通用基础 Field 类型

每个数据集都会包含各种类型的数据，它们都可以被表示为Field，它描述了数据被处理的过程。

在配置文件中配置项为:

[[Fields]]
class = "BertField"
name = "text"
[Fields.init]
batch_first=true
pretrained="data/albert_g/vocab.txt"
config={"do_lower_case" = false}
include_lengths=false

[[Fields]]
class = "TagField"
name = "text_len"
[Fields.init]
is_target=false
use_vocab=false
属性:
is_target: 是否是目标域。

Default: False

classmethod by_name(name)

通过注册的名字取得实际的类型

参数

name – 注册的名字

返回

Type[T] 使用 name 注册的子类

返回类型

class

引发

RegistrationError – 如果 name 未被注册

classmethod from_params(__config, *args, extra=None, **kwargs)

使用 config 生成对象

参数

  • cls – 类型

  • __config – 配置项，通常为字典，形如 {‘class’:’ClassName’, ‘init’:{ ‘arg’: arg } }

  • *args – 直接传入的arg

  • extra – 根据需要传入的数据

  • **kwargs – 其他参数

返回

根据参数生成的对象

classmethod hook(hook)

函数装饰器，给某个类注册装饰器

classmethod is_registered(name)

如果 name 在类中已经注册，则返回 True

classmethod iter_registered()

迭代已经注册的名字和对象

classmethod list_available()

列出所有的注册子类

classmethod register(name, override=False, hooks=None)

装饰器 Class decorator for registering a subclass.

参数

  • name – 注册名

  • override (bool) – 当name已经注册时，是否进行覆盖

  • hooks (List[HookType]) – 在注册时会被执行的Hook函数

引发

RegistrationError – 如果 override 为 false 并且 name 已经被注册

classmethod weak_register(name, subclass, override=False, hooks=None)

用于手动对子类进行注册

参数

  • name (str) – 子类的引用名

  • subclass – 子类类型

  • override (bool) – 当name已经注册时，是否进行覆盖

  • hooks – 在注册时会被执行的Hook函数

引发

RegistrationError – 如果 override 为 false 并且 name 已经被注册

class TextField(tokenizer, name='text', return_tokens=False, return_word_idn=False, return_length=True, word_info=True, is_target=False)[源代码]

基类：ltp.data.fields.Field

文本域

参数

  • tokenizer – Tokenizer

  • name – Field Na,e

  • return_length – 是否同时返回 length

  • word_info – 是否返回 word index

  • is_target – 是否为目标域

tokenizer_cls

transformers.tokenization_auto.AutoTokenizer 的别名

class MixedTextField(tokenizer, name='text', return_tokens=False, return_word_idn=False, return_length=True, word_info=True, is_target=False)[源代码]

基类：ltp.data.fields.text.TextField

class LabelField(name, unk='<unk>', preprocessing=None, postprocessing=None, use_vocab=True, dtype=torch.int64, is_target=False)[源代码]

基类：ltp.data.fields.Field

可以用于文本分类等领域

vocab_cls

torchtext.vocab.Vocab 的别名

class SequenceField(name, bos=None, eos=None, unk=None, pad=None, dtype=torch.int64, pad_bias=True, preprocessing=None, postprocessing=None, max_length=None, include_lengths=False, labels=None, use_vocab=True, is_target=True, **kwargs)[源代码]

基类：ltp.data.fields.Field

序列 Field，通常为target

参数

  • name – Field name

  • bos – Begin Of Sentence，默认为空

  • eos – End Of Sentence，默认为空

  • unk – Unknown Tag, 默认为空

  • pad – 默认为 [PAD] 或 -1

  • dtype – torch.dtype，可以使用字符串

  • pad_bias – 做值域变换，将pad的值变到1，默认开启

  • preprocessing – 预处理

  • postprocessing – 后处理

  • max_length – 是否padding到最大长度，None即为不做特殊处理，默认为None

  • include_lengths – 是否返回 length，默认为False

  • use_vocab – 是否使用词表，默认为True

  • is_target – 是否为target，默认为True

vocab_cls

torchtext.vocab.Vocab 的别名

class GraphField(name, edge_spliter, pad='<pad>', tag_spliter=None, use_vocab=True, **kwargs)[源代码]

基类：ltp.data.fields.Field

vocab_cls

torchtext.vocab.Vocab 的别名

class BiaffineField(name, use_vocab=True, pad='O', labels=None, **kwargs)[源代码]

基类：ltp.data.fields.Field

Biaffine 域

参数

  • name – label name

  • use_vocab – 是否使用词典

  • pad – 无 label 的 label 位置使用 pad 填充

  • labels – 可以给定 label 而不是通过统计数据得到

vocab_cls

torchtext.vocab.Vocab 的别名

数据预处理(Processing)

class Processing[源代码]

基类：object

预/后处理基类

class PreProcessing[源代码]

基类：ltp.data.processing.Processing

预处理基类

classmethod by_name(name)

通过注册的名字取得实际的类型

参数

name – 注册的名字

返回

Type[T] 使用 name 注册的子类

返回类型

class

引发

RegistrationError – 如果 name 未被注册

classmethod from_params(__config, *args, extra=None, **kwargs)

使用 config 生成对象

参数

  • cls – 类型

  • __config – 配置项，通常为字典，形如 {‘class’:’ClassName’, ‘init’:{ ‘arg’: arg } }

  • *args – 直接传入的arg

  • extra – 根据需要传入的数据

  • **kwargs – 其他参数

返回

根据参数生成的对象

classmethod hook(hook)

函数装饰器，给某个类注册装饰器

classmethod is_registered(name)

如果 name 在类中已经注册，则返回 True

classmethod iter_registered()

迭代已经注册的名字和对象

classmethod list_available()

列出所有的注册子类

classmethod register(name, override=False, hooks=None)

装饰器 Class decorator for registering a subclass.

参数

  • name – 注册名

  • override (bool) – 当name已经注册时，是否进行覆盖

  • hooks (List[HookType]) – 在注册时会被执行的Hook函数

引发

RegistrationError – 如果 override 为 false 并且 name 已经被注册

classmethod weak_register(name, subclass, override=False, hooks=None)

用于手动对子类进行注册

参数

  • name (str) – 子类的引用名

  • subclass – 子类类型

  • override (bool) – 当name已经注册时，是否进行覆盖

  • hooks – 在注册时会被执行的Hook函数

引发

RegistrationError – 如果 override 为 false 并且 name 已经被注册

class PostProcessing[源代码]

基类：ltp.data.processing.Processing

后处理基类

classmethod by_name(name)

通过注册的名字取得实际的类型

参数

name – 注册的名字

返回

Type[T] 使用 name 注册的子类

返回类型

class

引发

RegistrationError – 如果 name 未被注册

classmethod from_params(__config, *args, extra=None, **kwargs)

使用 config 生成对象

参数

  • cls – 类型

  • __config – 配置项，通常为字典，形如 {‘class’:’ClassName’, ‘init’:{ ‘arg’: arg } }

  • *args – 直接传入的arg

  • extra – 根据需要传入的数据

  • **kwargs – 其他参数

返回

根据参数生成的对象

classmethod hook(hook)

函数装饰器，给某个类注册装饰器

classmethod is_registered(name)

如果 name 在类中已经注册，则返回 True

classmethod iter_registered()

迭代已经注册的名字和对象

classmethod list_available()

列出所有的注册子类

classmethod register(name, override=False, hooks=None)

装饰器 Class decorator for registering a subclass.

参数

  • name – 注册名

  • override (bool) – 当name已经注册时，是否进行覆盖

  • hooks (List[HookType]) – 在注册时会被执行的Hook函数

引发

RegistrationError – 如果 override 为 false 并且 name 已经被注册

classmethod weak_register(name, subclass, override=False, hooks=None)

用于手动对子类进行注册

参数

  • name (str) – 子类的引用名

  • subclass – 子类类型

  • override (bool) – 当name已经注册时，是否进行覆盖

  • hooks – 在注册时会被执行的Hook函数

引发

RegistrationError – 如果 override 为 false 并且 name 已经被注册

class BioEncoder[源代码]

基类：ltp.data.processing.PreProcessing

将词序列转换成BIO编码

评估

指标

class Metric(**defaults)[源代码]

基类：object

Metric 基础类，在配置文件中的配置项为:

[[Metrics]]
class = "Accuracy"
[Metrics.init]
pad_value = -1
step(y_pred, y)[源代码]

步进一次 :param y_pred: 预测值 :param y: 真实值

compute()[源代码]

返回 metrics 结果 :return: Dict[str, float]

clear()[源代码]

把已经统计的Metrics结果清0

classmethod by_name(name)

通过注册的名字取得实际的类型

参数

name – 注册的名字

返回

Type[T] 使用 name 注册的子类

返回类型

class

引发

RegistrationError – 如果 name 未被注册

classmethod from_params(__config, *args, extra=None, **kwargs)

使用 config 生成对象

参数

  • cls – 类型

  • __config – 配置项，通常为字典，形如 {‘class’:’ClassName’, ‘init’:{ ‘arg’: arg } }

  • *args – 直接传入的arg

  • extra – 根据需要传入的数据

  • **kwargs – 其他参数

返回

根据参数生成的对象

classmethod hook(hook)

函数装饰器，给某个类注册装饰器

classmethod is_registered(name)

如果 name 在类中已经注册，则返回 True

classmethod iter_registered()

迭代已经注册的名字和对象

classmethod list_available()

列出所有的注册子类

classmethod register(name, override=False, hooks=None)

装饰器 Class decorator for registering a subclass.

参数

  • name – 注册名

  • override (bool) – 当name已经注册时，是否进行覆盖

  • hooks (List[HookType]) – 在注册时会被执行的Hook函数

引发

RegistrationError – 如果 override 为 false 并且 name 已经被注册

classmethod weak_register(name, subclass, override=False, hooks=None)

用于手动对子类进行注册

参数

  • name (str) – 子类的引用名

  • subclass – 子类类型

  • override (bool) – 当name已经注册时，是否进行覆盖

  • hooks – 在注册时会被执行的Hook函数

引发

RegistrationError – 如果 override 为 false 并且 name 已经被注册

class Accuracy(pad_value=None)[源代码]

基类：ltp.eval.metrics.Metric

step(y_pred, y)[源代码]

步进一次 :param y_pred: 预测值 :param y: 真实值

compute()[源代码]

返回 metrics 结果 :return: Dict[str, float]

clear()[源代码]

把已经统计的Metrics结果清0

class CommonLoss(loss_function, item=False, flat=False)[源代码]

基类：ltp.eval.metrics.Metric

Loss Metric: 用于计算LOSS

参数

  • loss_function – 损失函数

  • item – 返回标量，而不是Tensor

  • flat – 是否对预测结果进行平铺

step(y_pred, y)[源代码]

步进一次 :param y_pred: 预测值 :param y: 真实值

compute()[源代码]

返回 metrics 结果 :return: Dict[str, float]

clear()[源代码]

把已经统计的Metrics结果清0

class TreeMetrics(eisner=False)[源代码]

基类：ltp.eval.metrics.Metric

step(y_pred, y)[源代码]

步进一次 :param y_pred: 预测值 :param y: 真实值

clear()[源代码]

把已经统计的Metrics结果清0

compute()[源代码]

返回 metrics 结果 :return: Dict[str, float]

class GraphMetrics[源代码]

基类：ltp.eval.metrics.Metric

Graph Parser Metric(f1)

step(y_pred, y)[源代码]

步进一次 :param y_pred: 预测值 :param y: 真实值

compute()[源代码]

返回 metrics 结果 :return: Dict[str, float]

clear()[源代码]

把已经统计的Metrics结果清0

class Sequence(id2label, pad_value=- 1, suffix=False, no_suffix=False)[源代码]

基类：ltp.eval.metrics.Metric

用于命名实体识别或其他Span序列任务

step(y_pred, y)[源代码]

步进一次 :param y_pred: 预测值 :param y: 真实值

compute()[源代码]

返回 metrics 结果 :return: Dict[str, float]

clear()[源代码]

把已经统计的Metrics结果清0

class BiaffineCRFSpan(id2label)[源代码]

基类：ltp.eval.metrics.Metric

用于 语义角色标注

step(y_pred, y)[源代码]

步进一次 :param y_pred: 预测值 :param y: 真实值

compute()[源代码]

返回 metrics 结果 :return: Dict[str, float]

clear()[源代码]

把已经统计的Metrics结果清0

命令

Command

class Command(config, device=None)[源代码]

基类：object

命令行交互指令

train(epoch=None)[源代码]

进行训练操作

参数

epoch – 训练的轮数，默认10轮或者从配置文件中指定

eval(file=None, checkpoint=None, task=None)[源代码]

进行 Evaluation 操作

参数

  • task – 任务，默认为default

  • checkpoint – 使用的 checkpoint，默认是采用Best ckpt（需要启用Checkpoint Mannger best plugin）

  • file – 要进行 evaluation 的文件，默认是test数据集

predict(input, output, checkpoint=None, task='default')[源代码]

进行预测操作

参数

  • task – 任务，默认为default

  • input – 输入文件

  • output – 输出文件

  • checkpoint – 使用的 checkpoint，默认是采用Best ckpt（需要启用Checkpoint Mannger best plugin）

deploy(path='deploy.model', vocab=None)[源代码]

将模型中不需要的部分都清理掉，仅仅保留需要预测的部分 :param path: 最终保存的模型的路径 :param vocab: 词典名字，从 huggingface 加载

test()[源代码]

测试配置文件是否正确，目前只对Dataset进行验证。

Executer

class Executor(config)[源代码]

基类：object

实际训练器的一个简单包装

train_wrapper(dataloaders, epochs=30, tau=1.0)[源代码]

通过给定的 data loader 进行训练，训练会进行到epochs或者 stop condition = True

参数

  • tau – 放大指数

  • dataloaders – PyTorch DataLoader

  • epochs – 训练的最大轮数

evaluate_(data_loader, metrics, task)[源代码]

评估一个模型 :param task: 任务信息 :param data_loader: PyTorch DataLoader :param metrics: 进行评估的 Metrics :return: 计算得到的各项指标

predict_(dataloader, outputs, task)[源代码]

进行预测操作

参数

  • dataloader – PyTorch DataLoader

  • outputs – 输出的文件名

模型

模型

class Model[源代码]

基类：torch.nn.modules.module.Module

模型基础类，从本类继承的模型自动注册

create_decoder(input_size, label_num, dropout=0.1, **kwargs)[源代码]

封装了各种解码器

forward(*args, **kwargs)[源代码]

前向传播函数

classmethod by_name(name)

通过注册的名字取得实际的类型

参数

name – 注册的名字

返回

Type[T] 使用 name 注册的子类

返回类型

class

引发

RegistrationError – 如果 name 未被注册

classmethod from_params(__config, *args, extra=None, **kwargs)

使用 config 生成对象

参数

  • cls – 类型

  • __config – 配置项，通常为字典，形如 {‘class’:’ClassName’, ‘init’:{ ‘arg’: arg } }

  • *args – 直接传入的arg

  • extra – 根据需要传入的数据

  • **kwargs – 其他参数

返回

根据参数生成的对象

classmethod hook(hook)

函数装饰器，给某个类注册装饰器

classmethod is_registered(name)

如果 name 在类中已经注册，则返回 True

classmethod iter_registered()

迭代已经注册的名字和对象

classmethod list_available()

列出所有的注册子类

classmethod register(name, override=False, hooks=None)

装饰器 Class decorator for registering a subclass.

参数

  • name – 注册名

  • override (bool) – 当name已经注册时，是否进行覆盖

  • hooks (List[HookType]) – 在注册时会被执行的Hook函数

引发

RegistrationError – 如果 override 为 false 并且 name 已经被注册

classmethod weak_register(name, subclass, override=False, hooks=None)

用于手动对子类进行注册

参数

  • name (str) – 子类的引用名

  • subclass – 子类类型

  • override (bool) – 当name已经注册时，是否进行覆盖

  • hooks – 在注册时会被执行的Hook函数

引发

RegistrationError – 如果 override 为 false 并且 name 已经被注册

序列标注模型

class SequenceTaggingModel[源代码]

基类：ltp.models.model.Model

基本序列标注模型，封装了各种解码器，将来可能要进行解耦，如果使用crf解码器，需要换用支持 CRF 的 Trainer

使用 init_decoder 函数初始化解码器

参数

  • decoder – [None=Linear,lan=lan decoder] 默认是简单线性层分类，目前支持 lan decoder

  • hidden_size – decoder = lan 时必填, lan hidden size

  • num_heads – decoder = lan 时使用, lan 多头注意力模型 heads，默认为 5

  • num_layers – decoder = lan 时使用, lan decoder 层数，默认为 3

  • lan – decoder = lan 时使用，lan decoder 其他参数

  • arc_hidden_size – decoder = biaffine 时必填

  • rel_hidden_size – decoder = biaffine 时必填

  • rel_num – decoder = biaffine 时默认为label_num，rel 数目

  • bias – decoder = Linear 时，传入Linear层

init_decoder(input_size, label_num, dropout=0.1, **kwargs)[源代码]

基本序列标注模型，封装了各种解码器

forward(text, gold=None)[源代码]

前向传播函数

class SimpleTaggingModel(label_num, pretrained=None, config=None, dropout=0.1, word_base=False, use_cls=False, freeze=False, **kwargs)[源代码]

基类：ltp.models.seq_tag_model.SequenceTaggingModel

基本序列标注模型

参数

  • pretrained – 预训练模型路径或名称，参照 huggingface/transformers

  • config – 预训练模型路径或名称，参照 huggingface/transformers

  • label_num – 分类标签数目

  • dropout – pretrained Embedding dropout，默认0.1

  • word_base – 是否是以词为基础的模型，如果是，输入时需要传入 word index

  • decoder – [None=Linear,lan=lan decoder] 默认是简单线性层分类，目前支持 lan decoder

  • hidden_size – decoder = lan 时必填, lan hidden size

  • num_heads – decoder = lan 时使用, lan 多头注意力模型 heads，默认为 5

  • num_layers – decoder = lan 时使用, lan decoder 层数,，默认为 3

  • lan – decoder = lan 时使用，lan decoder 其他参数

  • arc_hidden_size – decoder = graph 时必填

  • rel_hidden_size – decoder = graph 时必填

  • rel_num – decoder = graph 时默认为label_num，rel 数目

  • bias – decoder = Linear 时，传入Linear层

多任务模型

class MultiTaskModel[源代码]

基类：ltp.models.model.Model

基本多任务序列标注模型

create_decoder(input_size, label_num, dropout=0.1, **kwargs)[源代码]

封装了各种解码器 :param decoder: [None=Linear,lan=lan decoder,crf] 默认是简单线性层分类，目前支持 lan decoder

参数

  • hidden_size – decoder = lan 时必填, lan hidden size

  • num_heads – decoder = lan 时使用, lan 多头注意力模型 heads，默认为 5

  • num_layers – decoder = lan 时使用, lan decoder 层数，默认为 3

  • lan – decoder = lan 时使用，lan decoder 其他参数

  • arc_hidden_size – decoder = biaffine 时必填

  • rel_hidden_size – decoder = biaffine 时必填

  • rel_num – decoder = biaffine 时必填，rel 数目

  • bias – decoder = Linear 时，传入Linear层

class SimpleMultiTaskModel(pretrained=None, config=None, dropout=0.1, freeze=False, **kwargs)[源代码]

基类：ltp.models.multi_task_model.MultiTaskModel

forward(text, *args, **kwargs)[源代码]

前向传播函数

模块

组合不同的模组，针对不同的任务进行处理。

Biaffine CRF

class BiaffineCRF(input_size, label_num, dropout=0.2, hidden_size=None, **kwargs)[源代码]

基类：ltp.modules.Module

forward(inputs, length, gold=None)[源代码]

Defines the computation performed at every call.

Should be overridden by all subclasses.

注解

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

Graph

class Graph(input_size, label_num, dropout, arc_hidden_size, rel_hidden_size, **kwargs)[源代码]

基类：ltp.modules.Module

forward(embedding, seq_lens=None, gold=None)[源代码]

Defines the computation performed at every call.

Should be overridden by all subclasses.

注解

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

模组

这里用于提供类似Pytorch原生的一些模块，之后使用Modules进行包装调用。

class Swish[源代码]

基类：torch.nn.modules.module.Module

Swish activation function:

\[\text{Swish}(x) = x * Sigmoid(x)\]
Shape:

  • Input: \((N, *)\) where * means, any number of additional dimensions

  • Output: \((N, *)\), same shape as the input

forward(input)[源代码]

Defines the computation performed at every call.

Should be overridden by all subclasses.

注解

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class HSwish[源代码]

基类：torch.nn.modules.module.Module

Hard Swish activation function:

\[\text{Swish}(x) = x * \frac{ReLU6(x+3)}{6}\]
Shape:

  • Input: \((N, *)\) where * means, any number of additional dimensions

  • Output: \((N, *)\), same shape as the input

forward(input)[源代码]

Defines the computation performed at every call.

Should be overridden by all subclasses.

注解

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class Mish[源代码]

基类：torch.nn.modules.module.Module

Mish activation function:

\[\text{Mish}(x) = x * tanh(\ln(1 + e^x))\]
Shape:

  • Input: \((N, *)\) where * means, any number of additional dimensions

  • Output: \((N, *)\), same shape as the input

forward(input)[源代码]

Defines the computation performed at every call.

Should be overridden by all subclasses.

注解

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class Bilinear(in1_features, in2_features, out_features, expand=False, bias_x=True, bias_y=True)[源代码]

基类：torch.nn.modules.module.Module

forward(x1, x2)[源代码]

Defines the computation performed at every call.

Should be overridden by all subclasses.

注解

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

extra_repr()[源代码]

Set the extra representation of the module

To print customized extra information, you should reimplement this method in your own modules. Both single-line and multi-line strings are acceptable.

class Biaffine(in1_features, in2_features, out_features, bias_x=True, bias_y=True, **kwargs)[源代码]

基类：torch.nn.modules.module.Module

forward(x1, x2)[源代码]

Defines the computation performed at every call.

Should be overridden by all subclasses.

注解

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

extra_repr()[源代码]

Set the extra representation of the module

To print customized extra information, you should reimplement this method in your own modules. Both single-line and multi-line strings are acceptable.

class RelativeTransformer(input_size, num_layers, hidden_size, num_heads, dropout, after_norm=True, max_length=1024)[源代码]

基类：torch.nn.modules.module.Module

forward(x, length, gold=None)[源代码]
参数

  • x – batch_size x max_len

  • length – sequence length, B

预测

模块

预测器，在配置文件中需配置此项:

[Predictor]
class = "simple"
class Simple(fields, text_field='text', target_filed=None)[源代码]

基类：ltp.predict.Predictor

简单预测器

参数

  • fields – Tuple(str, Field) 数据的 Field 对象，配置文件不需要填写

  • text_field – str 提供文本以及长度的 Field，默认是第一个 Filed

  • target_filed – str 提供解码词典的 Field, 默认是第一个 Target Field (提供他的词表)

predict(inputs, pred)[源代码]

对结果进行预测

class Segment(fields, text_field='text')[源代码]

基类：ltp.predict.Predictor

predict(inputs, pred)[源代码]

对结果进行预测

class Biaffine(fields, text_field='text', tag_field='tag')[源代码]

基类：ltp.predict.Predictor

predict(inputs, pred)[源代码]

对结果进行预测

训练

回调

class Callback(iteration, epoch)[源代码]

基类：object

回调函数基类

classmethod by_name(name)

通过注册的名字取得实际的类型

参数

name – 注册的名字

返回

Type[T] 使用 name 注册的子类

返回类型

class

引发

RegistrationError – 如果 name 未被注册

classmethod from_params(__config, *args, extra=None, **kwargs)

使用 config 生成对象

参数

  • cls – 类型

  • __config – 配置项，通常为字典，形如 {‘class’:’ClassName’, ‘init’:{ ‘arg’: arg } }

  • *args – 直接传入的arg

  • extra – 根据需要传入的数据

  • **kwargs – 其他参数

返回

根据参数生成的对象

classmethod hook(hook)

函数装饰器，给某个类注册装饰器

classmethod is_registered(name)

如果 name 在类中已经注册，则返回 True

classmethod iter_registered()

迭代已经注册的名字和对象

classmethod list_available()

列出所有的注册子类

classmethod register(name, override=False, hooks=None)

装饰器 Class decorator for registering a subclass.

参数

  • name – 注册名

  • override (bool) – 当name已经注册时，是否进行覆盖

  • hooks (List[HookType]) – 在注册时会被执行的Hook函数

引发

RegistrationError – 如果 override 为 false 并且 name 已经被注册

classmethod weak_register(name, subclass, override=False, hooks=None)

用于手动对子类进行注册

参数

  • name (str) – 子类的引用名

  • subclass – 子类类型

  • override (bool) – 当name已经注册时，是否进行覆盖

  • hooks – 在注册时会被执行的Hook函数

引发

RegistrationError – 如果 override 为 false 并且 name 已经被注册

class CsvWriter(iteration, epoch, save_directory='./log', filename='log.csv', delimiter=', ', extra_header=None, data_extractor=<function CsvWriter.<lambda>>)[源代码]

基类：ltp.train.callback.Callback

class TensorboardCallback(iteration, epoch, save_directory='./log', main_tag='tensorboard', data_extractor=<function TensorboardCallback.<lambda>>)[源代码]

基类：ltp.train.callback.Callback

损失

class Loss(*args, **kwargs)[源代码]

基类：torch.nn.modules.loss._Loss

forward(*input, **kwargs)[源代码]

Defines the computation performed at every call.

Should be overridden by all subclasses.

注解

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

classmethod by_name(name)

通过注册的名字取得实际的类型

参数

name – 注册的名字

返回

Type[T] 使用 name 注册的子类

返回类型

class

引发

RegistrationError – 如果 name 未被注册

classmethod from_params(__config, *args, extra=None, **kwargs)

使用 config 生成对象

参数

  • cls – 类型

  • __config – 配置项，通常为字典，形如 {‘class’:’ClassName’, ‘init’:{ ‘arg’: arg } }

  • *args – 直接传入的arg

  • extra – 根据需要传入的数据

  • **kwargs – 其他参数

返回

根据参数生成的对象

classmethod hook(hook)

函数装饰器，给某个类注册装饰器

classmethod is_registered(name)

如果 name 在类中已经注册，则返回 True

classmethod iter_registered()

迭代已经注册的名字和对象

classmethod list_available()

列出所有的注册子类

classmethod register(name, override=False, hooks=None)

装饰器 Class decorator for registering a subclass.

参数

  • name – 注册名

  • override (bool) – 当name已经注册时，是否进行覆盖

  • hooks (List[HookType]) – 在注册时会被执行的Hook函数

引发

RegistrationError – 如果 override 为 false 并且 name 已经被注册

classmethod weak_register(name, subclass, override=False, hooks=None)

用于手动对子类进行注册

参数

  • name (str) – 子类的引用名

  • subclass – 子类类型

  • override (bool) – 当name已经注册时，是否进行覆盖

  • hooks – 在注册时会被执行的Hook函数

引发

RegistrationError – 如果 override 为 false 并且 name 已经被注册

优化器

class Optimizer(params, defaults)[源代码]

基类：torch.optim.optimizer.Optimizer

classmethod by_name(name)

通过注册的名字取得实际的类型

参数

name – 注册的名字

返回

Type[T] 使用 name 注册的子类

返回类型

class

引发

RegistrationError – 如果 name 未被注册

classmethod from_params(__config, *args, extra=None, **kwargs)

使用 config 生成对象

参数

  • cls – 类型

  • __config – 配置项，通常为字典，形如 {‘class’:’ClassName’, ‘init’:{ ‘arg’: arg } }

  • *args – 直接传入的arg

  • extra – 根据需要传入的数据

  • **kwargs – 其他参数

返回

根据参数生成的对象

classmethod hook(hook)

函数装饰器，给某个类注册装饰器

classmethod is_registered(name)

如果 name 在类中已经注册，则返回 True

classmethod iter_registered()

迭代已经注册的名字和对象

classmethod list_available()

列出所有的注册子类

classmethod register(name, override=False, hooks=None)

装饰器 Class decorator for registering a subclass.

参数

  • name – 注册名

  • override (bool) – 当name已经注册时，是否进行覆盖

  • hooks (List[HookType]) – 在注册时会被执行的Hook函数

引发

RegistrationError – 如果 override 为 false 并且 name 已经被注册

classmethod weak_register(name, subclass, override=False, hooks=None)

用于手动对子类进行注册

参数

  • name (str) – 子类的引用名

  • subclass – 子类类型

  • override (bool) – 当name已经注册时，是否进行覆盖

  • hooks – 在注册时会被执行的Hook函数

引发

RegistrationError – 如果 override 为 false 并且 name 已经被注册

调度器

class Scheduler(optimizer, last_epoch=- 1)[源代码]

基类：torch.optim.lr_scheduler._LRScheduler

调度器

classmethod by_name(name)

通过注册的名字取得实际的类型

参数

name – 注册的名字

返回

Type[T] 使用 name 注册的子类

返回类型

class

引发

RegistrationError – 如果 name 未被注册

classmethod from_params(__config, *args, extra=None, **kwargs)

使用 config 生成对象

参数

  • cls – 类型

  • __config – 配置项，通常为字典，形如 {‘class’:’ClassName’, ‘init’:{ ‘arg’: arg } }

  • *args – 直接传入的arg

  • extra – 根据需要传入的数据

  • **kwargs – 其他参数

返回

根据参数生成的对象

classmethod hook(hook)

函数装饰器，给某个类注册装饰器

classmethod is_registered(name)

如果 name 在类中已经注册，则返回 True

classmethod iter_registered()

迭代已经注册的名字和对象

classmethod list_available()

列出所有的注册子类

classmethod register(name, override=False, hooks=None)

装饰器 Class decorator for registering a subclass.

参数

  • name – 注册名

  • override (bool) – 当name已经注册时，是否进行覆盖

  • hooks (List[HookType]) – 在注册时会被执行的Hook函数

引发

RegistrationError – 如果 override 为 false 并且 name 已经被注册

classmethod weak_register(name, subclass, override=False, hooks=None)

用于手动对子类进行注册

参数

  • name (str) – 子类的引用名

  • subclass – 子类类型

  • override (bool) – 当name已经注册时，是否进行覆盖

  • hooks – 在注册时会被执行的Hook函数

引发

RegistrationError – 如果 override 为 false 并且 name 已经被注册

class TemperatureScheduler[源代码]

基类：object

蒸馏温度调度器

classmethod by_name(name)

通过注册的名字取得实际的类型

参数

name – 注册的名字

返回

Type[T] 使用 name 注册的子类

返回类型

class

引发

RegistrationError – 如果 name 未被注册

classmethod from_params(__config, *args, extra=None, **kwargs)

使用 config 生成对象

参数

  • cls – 类型

  • __config – 配置项，通常为字典，形如 {‘class’:’ClassName’, ‘init’:{ ‘arg’: arg } }

  • *args – 直接传入的arg

  • extra – 根据需要传入的数据

  • **kwargs – 其他参数

返回

根据参数生成的对象

classmethod hook(hook)

函数装饰器，给某个类注册装饰器

classmethod is_registered(name)

如果 name 在类中已经注册，则返回 True

classmethod iter_registered()

迭代已经注册的名字和对象

classmethod list_available()

列出所有的注册子类

classmethod register(name, override=False, hooks=None)

装饰器 Class decorator for registering a subclass.

参数

  • name – 注册名

  • override (bool) – 当name已经注册时，是否进行覆盖

  • hooks (List[HookType]) – 在注册时会被执行的Hook函数

引发

RegistrationError – 如果 override 为 false 并且 name 已经被注册

classmethod weak_register(name, subclass, override=False, hooks=None)

用于手动对子类进行注册

参数

  • name (str) – 子类的引用名

  • subclass – 子类类型

  • override (bool) – 当name已经注册时，是否进行覆盖

  • hooks – 在注册时会被执行的Hook函数

引发

RegistrationError – 如果 override 为 false 并且 name 已经被注册

停止条件

class NoStopping[源代码]

基类：object

永不停止

class EarlyStopping(patience=None, metric=None, float_rounding=None)[源代码]

基类：object

早停止

检查点

class CheckpointPlugin(directory=None, filename=None)[源代码]

基类：object

Checkpoint

参数

  • directory – 存放目录

  • filename – 检查点文件名

classmethod by_name(name)

通过注册的名字取得实际的类型

参数

name – 注册的名字

返回

Type[T] 使用 name 注册的子类

返回类型

class

引发

RegistrationError – 如果 name 未被注册

classmethod from_params(__config, *args, extra=None, **kwargs)

使用 config 生成对象

参数

  • cls – 类型

  • __config – 配置项，通常为字典，形如 {‘class’:’ClassName’, ‘init’:{ ‘arg’: arg } }

  • *args – 直接传入的arg

  • extra – 根据需要传入的数据

  • **kwargs – 其他参数

返回

根据参数生成的对象

classmethod hook(hook)

函数装饰器，给某个类注册装饰器

classmethod is_registered(name)

如果 name 在类中已经注册，则返回 True

classmethod iter_registered()

迭代已经注册的名字和对象

classmethod list_available()

列出所有的注册子类

classmethod register(name, override=False, hooks=None)

装饰器 Class decorator for registering a subclass.

参数

  • name – 注册名

  • override (bool) – 当name已经注册时，是否进行覆盖

  • hooks (List[HookType]) – 在注册时会被执行的Hook函数

引发

RegistrationError – 如果 override 为 false 并且 name 已经被注册

classmethod weak_register(name, subclass, override=False, hooks=None)

用于手动对子类进行注册

参数

  • name (str) – 子类的引用名

  • subclass – 子类类型

  • override (bool) – 当name已经注册时，是否进行覆盖

  • hooks – 在注册时会被执行的Hook函数

引发

RegistrationError – 如果 override 为 false 并且 name 已经被注册

class LoadCheckpointPlugin(directory=None, filename=None)[源代码]

基类：ltp.train.checkpoint.CheckpointPlugin

class BestCheckpointPlugin(metric, directory=None, filename=None)[源代码]

基类：ltp.train.checkpoint.CheckpointPlugin

class RestoreCheckpointPlugin(*args, **kwargs)[源代码]

基类：ltp.train.checkpoint.CheckpointPlugin

工具

梯度裁剪

参数初始化

initial_parameter(net, initial_method=None)[源代码]

用于初始化 Pytorch 模型内部权重的函数

参数

  • net – Pytorch Module

  • initial_method (str) –

    取值如下

    • xavier_uniform

    • xavier_normal (default)

    • kaiming_normal, or msra

    • kaiming_uniform

    • orthogonal

    • sparse

    • normal

    • uniform

附录

词性标注集

LTP 使用的是863词性标注集，其各个词性含义如下表。

Tag

Description

Example

Tag

Description

Example

a

adjective

美丽

ni

organization name

保险公司

b

other noun-modifier

大型, 西式

nl

location noun

城郊

c

conjunction

和, 虽然

ns

geographical name

北京

d

adverb

很

nt

temporal noun

近日, 明代

e

exclamation

哎

nz

other proper noun

诺贝尔奖

g

morpheme

茨, 甥

o

onomatopoeia

哗啦

h

prefix

阿, 伪

p

preposition

在, 把

i

idiom

百花齐放

q

quantity

个

j

abbreviation

公检法

r

pronoun

我们

k

suffix

界, 率

u

auxiliary

的, 地

m

number

一, 第一

v

verb

跑, 学习

n

general noun

苹果

wp

punctuation

，。！

nd

direction noun

右侧

ws

foreign words

CPU

nh

person name

杜甫, 汤姆

x

non-lexeme

萄, 翱

命名实体识别标注集

LTP中的NE 模块识别三种NE，分别如下：

标记

含义

Nh

人名

Ni

机构名

Ns

地名

语义角色类型

关系类型

Tag

Description

Example

ARG0

causers or experiencers

施事者、主体、触发者

[政府 ARG0]鼓励个人投资服务业。

ARG1

patient

受事者

政府鼓励[个人 ARG1]投资服务业。

ARG2

range

语义角色2

政府鼓励个人[投资服务业 ARG2]。

ARG3

starting point

语义角色3

巴基斯坦[对谈判前景 ARG3]表示悲观。

ARG4

end point

语义角色4

产检部门将产检时间缩短到[一至三天 ARG4]。

ADV

adverbial

状语

我们[即将 ADV]迎来新年。

BNF

beneficiary

受益人

义务[为学童及老师 BNF]做超音波检查 。

CND

condition

条件

[如果早期发现 CND],便能提醒当事人注意血压的变化。

CRD

coordinated arguments

并列

跟南韩、[跟美国 CRD]谋求和平关系的举动也更加积极。

DGR

degree

程度

贫铀弹含有放射性比铀强[2０万倍 DGR]。

DIR

direction

方向

[从此处 DIR] 我们可以发现寇克斯报告的精髓。

DIS

discourse marker

会话标记

警方上午针对目击者做笔录，[而 DIS]李士东仍然不见踪影。

EXT

extent

范围

回归３年多[来 EXT] ，香港成为台商对大陆贸易的财务运作及资金调度中心。

FRQ

frequency

频率

这类听证会在赖昌兴拘押期间每３０天举行[一次 FRQ]。

LOC

locative

地点

请听美国之音特邀记者康妮[在加拿大温哥华 LOC]发来的报道。

MNR

manner

方式

以便他能继续[作为俄罗斯官员 MNR]从事他在一个特殊机构中的工作。

PRP

purpose or reason

目的

执政党和在野党[为了应付这场攻守战 PRP]都发出了紧急动员令。

QTY

quantity

数量

每年创汇[１００万 QTY]美元。

TMP

temporal

时间

[下星期 TMP]布什将提出一项周密计划。

TPC

topic

话题

[这么大的事情 TPC]，你怎么不和我说？

依存句法关系

关系类型

Tag

Description

Example

主谓关系

SBV

subject-verb

我送她一束花 (我 <– 送)

动宾关系

VOB

直接宾语，verb-object

我送她一束花 (送 –> 花)

间宾关系

IOB

间接宾语，indirect-object

我送她一束花 (送 –> 她)

前置宾语

FOB

前置宾语，fronting-object

他什么书都读 (书 <– 读)

兼语

DBL

double

他请我吃饭 (请 –> 我)

定中关系

ATT

attribute

红苹果 (红 <– 苹果)

状中结构

ADV

adverbial

非常美丽 (非常 <– 美丽)

动补结构

CMP

complement

做完了作业 (做 –> 完)

并列关系

COO

coordinate

大山和大海 (大山 –> 大海)

介宾关系

POB

preposition-object

在贸易区内 (在 –> 内)

左附加关系

LAD

left adjunct

大山和大海 (和 <– 大海)

右附加关系

RAD

right adjunct

孩子们 (孩子 –> 们)

独立结构

IS

independent structure

两个单句在结构上彼此独立

核心关系

HED

head

指整个句子的核心

语义依存关系

角色系统

标签表示

概念说明&举例

语 义 周 边 角 色

主体 角色

施事 AGT

指发出具体行为动作的主体或动作持续以及表现心理活动的有意识的主体，具有主观能动性。如：明天我将去看他。（看，我，施事AGT）

当事 EXP

指非行为动作的发出者，不具有主观能动性。包括无意识运动的主体、非可控运动的主体以及各种关系的主体。如：宝塔很高。（高，宝塔，当事EXP）

客体 角色

受事 PAT

指受主体的行为动作所改变的直接客体。一般与施事相对应，是受施事影响而导致位置、性质、结果等发生改变的对象，最明显的语义特征是具有被动性。如：从桌子上把书拿走。（拿走，书，受事PAT）

客事 CONT

指事件所涉及但是并未改变的客体以及动作行为产生的新事物或结果。如：我相信苏珊的话。（相信，话，客事CONT）

涉事 DATV

也称与事，是动作行为的非主动参与者，也可以说，涉事角色是语义事件的第三方参与者。从语义上说，是事件接受者、伴随者、来源者以及比较的基准等等；从句法上说，经常出现在双宾语句中的间接宾语位置。如：班长给他一套工具。（给，他，涉事DATV）

系事 LINK

是跟事件的参与者有关系的客体。一般由表示某种关联的动词连接主客体，表达主客体之间的某种具体的、或抽象的关系。如：弟弟是中学生。（是，中学生，系事LINK）

情境 角色

工具 TOOL

是事件中所使用的工具。典型的工具角色主要由介词“用”等引出，通常是由物体充当，但是一些有生命的、或者是抽象的事物也可以作为事件所凭借的工具。如：妈妈用砂锅熬稀饭。（熬，砂锅，工具TOOL）

材料 MATL

是事件中所使用的材料。如：学生们用纸折飞机。（折，纸，材料MATL）

方式 MANN

包括事件中出现的方式、方法以及事件所依照的根据、凭借。如：军士齐声高喊。（高喊，齐声，方式MANN）

范围 SCO

指事件中所关涉的方面、限定的界限、被审视的角度、发生作用的范围，通常都为抽象名词。一般由不同的介词引出，可以出现在“在……方面”、“在……角度上”、“在……中”等的结构中。如：数学方面他是专家。（是，方面，范围SCO）

缘由 REAS

包括引起事件发生或发展变化的原因以及事件所要达到的目的。如：他因为堵车迟到了。（迟到，堵车，缘由REAS）

时间 TIME

指事件发生所涉及到的各种时间因素。如：周一早上升旗。（升旗，早上，时间TIME）

空间 LOC

指事件所涉及到的各种空间因素。如：我明天去哈尔滨。（去，哈尔滨，空间LOC）

度量 MEAS

指事件中的数量，名量或动量。如：一年有365天。（天，365，度量MEAS）

状态 STAT

表示事件发生时的情形、状态等。如：人类是从类人猿进化来的吗？。（进化，类人猿，状态STAT）

修饰FEAT

包括描写主体属性、特征的标签以及、时间修饰语和名词修饰语的标签。如：她是个漂亮的女孩。（女孩，漂亮，修饰FEAT）

语 义 结 构 关 系

反关系

反关系指，当述谓概念转位修饰指称概念时，其述谓性质消失，增添了修饰性质，与中心语的关系相当于句法上的定中关系。需要注意的是，虽反关系的句法结构有变化，但是待标成分所充当的语义角色却是一样的。举例来说：①选手受伤了。（受伤，选手，当事EXP）②受伤的选手。（选手，受伤，反当事rEXP）反关系标签统一表示为r+语义周边角色标签，如rEXP，rLOC等等，此处不一一列举。

嵌套 关系

一个事件作为一个整体概念被嵌套进另一个主体事件内，被嵌套的事件称为“降级”事件。有两种情况：1. 被嵌套的事件相当于一个论元。爷爷看见小孙女在操作计算机。（看见，操作，嵌套客事dCONT）2. 被嵌套的事件相当于一个修饰成分。爷爷拍摄了小孙女在操作计算机的照片。（照片，操作，嵌套客事dCONT）嵌套关系标签统一表示为d+语义周边角色标签，如dCONT，dPAT等等，此处不一一列举。

事件 关系

并列关系eCOO

指两个或多个平行的语义事件，重在叙述和描写。如：兄弟俩边走边说。（走，说，并列eCOO）

先行关系ePREC

指在时间、空间上发生有序的事件或在逻辑、语义上关联性较强的先行发生的事件。如：要想成功，就要努力。（成功，努力，先行ePREC）

后继关系eSUCC

主要描述语义上更进一步的结果类事件，包括时间、空间或逻辑、语义上后续发生的事件。如：他穿好衣服，走出门去。（穿，走，后继eSUCC）

语 义 依 附 标 记

标点 标记

标点标记mPUNC

是对语义事件中的出现的标点符号的标注。如：他喜欢音乐。（喜欢，句号。，mPUNC）

依附 标记

否定标记mNEG

是对事件中否定关系的标记。如：她不像她母亲。（像，不，mNEG）

关系标记mRELA

是对句法事件中各种关系的标记，如一些连词、介词等。如：但是我没有放弃看书。（放弃，但是，mRELA）

依附标记mDEPD

是概念或事件的语义依附的形式标记，如一些助词。如：他在这里住了三十年。（住，了，mDEPD）