Transformers 4.37 中文文档（二十三）（1）-阿里云开发者社区

原文：huggingface.co/docs/transformers

BertGeneration

原文链接: huggingface.co/docs/transformers/v4.37.2/en/model_doc/bert-generation

概述

BertGeneration 模型是一个可以利用 EncoderDecoderModel 进行序列到序列任务的 BERT 模型，如 Sascha Rothe, Shashi Narayan, Aliaksei Severyn 在利用预训练检查点进行序列生成任务中提出的那样。

论文摘要如下:

最近，大型神经模型的无监督预训练已经彻底改变了自然语言处理。通过从公开发布的检查点开始热启动，NLP 从业者已经在多个基准测试中推动了最新技术，同时节省了大量的计算时间。到目前为止，重点主要集中在自然语言理解任务上。在本文中，我们展示了预训练检查点对序列生成的有效性。我们开发了一个基于 Transformer 的序列到序列模型，与公开可用的预训练 BERT、GPT-2 和 RoBERTa 检查点兼容，并对初始化我们的模型（编码器和解码器）使用这些检查点进行了广泛的实证研究。我们的模型在机器翻译、文本摘要、句子拆分和句子融合方面取得了新的最新技术成果。

该模型由 patrickvonplaten 贡献。原始代码可在此处找到。

用法示例和提示

该模型可以与 EncoderDecoderModel 结合使用，以利用两个预训练的 BERT 检查点进行后续微调:

>>> # leverage checkpoints for Bert2Bert model...
>>> # use BERT's cls token as BOS token and sep token as EOS token
>>> encoder = BertGenerationEncoder.from_pretrained("bert-large-uncased", bos_token_id=101, eos_token_id=102)
>>> # add cross attention layers and use BERT's cls token as BOS token and sep token as EOS token
>>> decoder = BertGenerationDecoder.from_pretrained(
...     "bert-large-uncased", add_cross_attention=True, is_decoder=True, bos_token_id=101, eos_token_id=102
... )
>>> bert2bert = EncoderDecoderModel(encoder=encoder, decoder=decoder)
>>> # create tokenizer...
>>> tokenizer = BertTokenizer.from_pretrained("bert-large-uncased")
>>> input_ids = tokenizer(
...     "This is a long article to summarize", add_special_tokens=False, return_tensors="pt"
... ).input_ids
>>> labels = tokenizer("This is a short summary", return_tensors="pt").input_ids
>>> # train...
>>> loss = bert2bert(input_ids=input_ids, decoder_input_ids=labels, labels=labels).loss
>>> loss.backward()

预训练的 EncoderDecoderModel 也可以直接在模型中心使用，例如:

>>> # instantiate sentence fusion model
>>> sentence_fuser = EncoderDecoderModel.from_pretrained("google/roberta2roberta_L-24_discofuse")
>>> tokenizer = AutoTokenizer.from_pretrained("google/roberta2roberta_L-24_discofuse")
>>> input_ids = tokenizer(
...     "This is the first sentence. This is the second sentence.", add_special_tokens=False, return_tensors="pt"
... ).input_ids
>>> outputs = sentence_fuser.generate(input_ids)
>>> print(tokenizer.decode(outputs[0]))

提示:

BertGenerationEncoder 和 BertGenerationDecoder 应与 EncoderDecoder 结合使用。
对于摘要、句子拆分、句子融合和翻译，输入不需要特殊标记。因此，输入末尾不应添加 EOS 标记。

BertGenerationConfig

`class transformers.BertGenerationConfig`

< source >

( vocab_size = 50358 hidden_size = 1024 num_hidden_layers = 24 num_attention_heads = 16 intermediate_size = 4096 hidden_act = 'gelu' hidden_dropout_prob = 0.1 attention_probs_dropout_prob = 0.1 max_position_embeddings = 512 initializer_range = 0.02 layer_norm_eps = 1e-12 pad_token_id = 0 bos_token_id = 2 eos_token_id = 1 position_embedding_type = 'absolute' use_cache = True **kwargs )

参数

vocab_size (int, 可选, 默认为 50358) — BERT 模型的词汇量。定义了在调用 BertGeneration 时传递的 inputs_ids 可以表示的不同标记数量。
hidden_size (int, 可选, 默认为 1024) — 编码器层和池化器层的维度。
num_hidden_layers (int, 可选, 默认为 24) — Transformer 编码器中的隐藏层数。
num_attention_heads (int, 可选, 默认为 16) — Transformer 编码器中每个注意力层的注意力头数。
intermediate_size (int, 可选, 默认为 4096) — Transformer 编码器中“中间”（通常称为前馈）层的维度。
hidden_act (str 或 function, 可选, 默认为 "gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持 "gelu", "relu", "silu" 和 "gelu_new"。
hidden_dropout_prob (float, 可选, 默认为 0.1) — 嵌入层、编码器和池化器中所有全连接层的丢弃概率。
attention_probs_dropout_prob (float, optional, defaults to 0.1) — 注意力概率的丢弃比率。
max_position_embeddings (int, optional, defaults to 512) — 此模型可能使用的最大序列长度。通常将其设置为较大的值以防万一（例如，512、1024 或 2048）。
initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
layer_norm_eps (float, optional, defaults to 1e-12) — 层归一化层使用的 epsilon。
pad_token_id (int, optional, defaults to 0) — 填充令牌 id。
bos_token_id (int, optional, defaults to 2) — 流开始令牌 id。
eos_token_id (int, optional, defaults to 1) — 流结束令牌 id。
position_embedding_type (str, optional, defaults to "absolute") — 位置嵌入的类型。选择 "absolute", "relative_key", "relative_key_query" 中的一个。对于位置嵌入使用 "absolute"。有关 "relative_key" 的更多信息，请参考 Self-Attention with Relative Position Representations (Shaw et al.)。有关 "relative_key_query" 的更多信息，请参考 Improve Transformer Models with Better Relative Position Embeddings (Huang et al.) 中的 Method 4。
use_cache (bool, optional, defaults to True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。仅在 config.is_decoder=True 时相关。

这是用于存储 BertGenerationPreTrainedModel 配置的类。它用于根据指定的参数实例化 BertGeneration 模型，定义模型架构。使用默认值实例化配置将产生类似于 BertGeneration google/bert_for_seq_generation_L-24_bbc_encoder 架构的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读来自 PretrainedConfig 的文档以获取更多信息。

示例：

>>> from transformers import BertGenerationConfig, BertGenerationEncoder
>>> # Initializing a BertGeneration config
>>> configuration = BertGenerationConfig()
>>> # Initializing a model (with random weights) from the config
>>> model = BertGenerationEncoder(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config

BertGenerationTokenizer

`class transformers.BertGenerationTokenizer`

< source >

( vocab_file bos_token = '<s>' eos_token = '</s>' unk_token = '<unk>' pad_token = '<pad>' sep_token = '<::::>' sp_model_kwargs: Optional = None **kwargs )

参数

vocab_file (str) — 包含实例化分词器所需词汇的 SentencePiece 文件（通常具有 .spm 扩展名）。
bos_token (str, optional, defaults to ""~~) — 序列开始令牌。~~
~~eos_token (str, optional, defaults to "~~") — 序列结束令牌。
unk_token (str, optional, defaults to "") — 未知令牌。词汇表中不存在的令牌无法转换为 ID，而是设置为此令牌。
pad_token (str, optional, defaults to "") — 用于填充的令牌，例如在批处理不同长度的序列时使用。
sep_token (str, optional, defaults to "< --:::>"): 分隔符令牌，用于从多个序列构建序列时使用，例如用于序列分类的两个序列，或用于问题回答的文本和问题。它还用作使用特殊令牌构建的序列的最后一个令牌。
sp_model_kwargs (dict, optional) — 将传递给 SentencePieceProcessor.__init__() 方法。SentencePiece 的 Python 包装器可以用于设置：

enable_sampling: 启用子词正则化。
nbest_size: unigram 的采样参数。对于 BPE-Dropout 无效。

nbest_size = {0,1}: 不执行采样。
nbest_size > 1: 从 nbest_size 结果中进行采样。
nbest_size < 0: 假设 nbest_size 是无限的，并使用前向过滤和后向采样算法从所有假设（格）中进行采样。

alpha: 用于 unigram 采样的平滑参数，以及用于 BPE-dropout 的合并操作的 dropout 概率。

构建一个 BertGeneration 分词器。基于SentencePiece。

该分词器继承自 PreTrainedTokenizer，其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。

`save_vocabulary`

<来源>

( save_directory: str filename_prefix: Optional = None )

BertGenerationEncoder

`class transformers.BertGenerationEncoder`

<来源>

( config )

参数

config (BertGenerationConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。

裸的 BertGeneration 模型变压器输出原始隐藏状态，没有特定的头部。

该模型继承自 PreTrainedModel。查看超类文档以获取库实现的所有模型的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

该模型还是一个 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

该模型可以作为编码器（仅具有自注意力）以及解码器行为，此时在自注意力层之间添加了一层交叉注意力，遵循Ashish Vaswani、Noam Shazeer、Niki Parmar、Jakob Uszkoreit、Llion Jones、Aidan N. Gomez、Lukasz Kaiser 和 Illia Polosukhin 在 Attention is all you need中描述的架构。

当利用 Bert 或 Roberta 检查点用于 EncoderDecoderModel 类时，应使用此模型，如 Sascha Rothe、Shashi Narayan 和 Aliaksei Severyn 在Leveraging Pre-trained Checkpoints for Sequence Generation Tasks中所述。

为了作为解码器行为，模型需要使用is_decoder参数初始化为True。要在 Seq2Seq 模型中使用，模型需要使用is_decoder参数和add_cross_attention参数都初始化为True；然后期望一个encoder_hidden_states作为前向传递的输入。

`forward`

<来源>

( input_ids: Optional = None attention_mask: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None encoder_hidden_states: Optional = None encoder_attention_mask: Optional = None past_key_values: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions or tuple(torch.FloatTensor)

参数

input_ids (torch.LongTensor，形状为(batch_size, sequence_length)) — 输入序列标记在词汇表中的索引。
可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.call()和 PreTrainedTokenizer.encode()。
什么是输入 ID？
attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）— 用于避免在填充标记索引上执行注意力的掩码。在[0, 1]中选择的掩码值：

1 表示未被屏蔽的标记，
0 表示被屏蔽的标记。

什么是注意力掩码？
position_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 每个输入序列标记的位置在位置嵌入中的索引。在范围[0, config.max_position_embeddings - 1]中选择。
什么是位置 ID？
head_mask（形状为(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可选）— 用于使自注意力模块的选定头部失效的掩码。在[0, 1]中选择的掩码值：

1 表示头部未被屏蔽，
0 表示头部被屏蔽。

inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制权来将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。
output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。
output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。
return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。
encoder_hidden_states（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 编码器最后一层的隐藏状态序列。如果模型配置为解码器，则在交叉注意力中使用。
encoder_attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）— 用于避免在编码器输入的填充标记索引上执行注意力的掩码。如果模型配置为解码器，则在交叉注意力中使用此掩码。在[0, 1]中选择的掩码值：对于未屏蔽的标记为1，对于屏蔽的标记为0。
past_key_values（长度为config.n_layers的tuple(tuple(torch.FloatTensor))，每个元组包含形状为(batch_size, num_heads, sequence_length - 1, embed_size_per_head)的 4 个张量）— 包含注意力块的预计算键和值隐藏状态。可用于加速解码。
如果使用past_key_values，用户可以选择仅输入最后的decoder_input_ids（这些没有将其过去的键值状态提供给此模型的）的形状为(batch_size, 1)的张量，而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。
use_cache（bool，可选）— 如果设置为True，则返回past_key_values键值状态，可用于加速解码（参见past_key_values）。

transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions 或tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置（BertGenerationConfig）和输入的不同元素。

last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor） — 模型最后一层的隐藏状态序列。
如果使用past_key_values，则仅输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。
past_key_values (tuple(tuple(torch.FloatTensor)), 可选, 当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的元组tuple(torch.FloatTensor)，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量，如果config.is_encoder_decoder=True，还有 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。
包含预先计算的隐藏状态（自注意力块中的键和值，以及在交叉注意力块中，如果config.is_encoder_decoder=True，还可以使用）可用于加速顺序解码的（请参见past_key_values输入）。
hidden_states (tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入输出的输出+每层的输出）。
模型在每一层输出的隐藏状态加上可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。
自注意力头中注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
cross_attentions (tuple(torch.FloatTensor), 可选, 当传递output_attentions=True和config.add_cross_attention=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。
解码器的交叉注意力层的注意力权重，在注意力 softmax 后使用，用于计算交叉注意力头中的加权平均值。

BertGenerationEncoder 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的配方需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, BertGenerationEncoder
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("google/bert_for_seq_generation_L-24_bbc_encoder")
>>> model = BertGenerationEncoder.from_pretrained("google/bert_for_seq_generation_L-24_bbc_encoder")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_state

BertGenerationDecoder

`class transformers.BertGenerationDecoder`

<来源>

( config )

参数

config（BertGenerationConfig） — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。

带有顶部语言建模头部的 BertGeneration 模型，用于 CLM 微调。

此模型继承自 PreTrainedModel。查看超类文档以了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。

此模型还是一个 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以了解与一般使用和行为相关的所有事项。

`forward`

<来源>

( input_ids: Optional = None attention_mask: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None encoder_hidden_states: Optional = None encoder_attention_mask: Optional = None labels: Optional = None past_key_values: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.CausalLMOutputWithCrossAttentions or tuple(torch.FloatTensor)

参数

input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）— 词汇表中输入序列标记的索引。
可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.call()和 PreTrainedTokenizer.encode()。
什么是输入 ID？
attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）— 用于避免在填充标记索引上执行注意力的掩码。选择的掩码值在[0, 1]中：

1 表示未被屏蔽的标记，
0 表示被屏蔽的标记。

什么是注意力掩码？
position_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 每个输入序列标记的位置索引。选择范围为[0, config.max_position_embeddings - 1]。
什么是位置 ID？
head_mask（形状为(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可选）— 用于使自注意力模块的选定头部失效的掩码。选择的掩码值在[0, 1]中：

1 表示头部未被屏蔽，
0 表示头部被屏蔽。

inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。
output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。
output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。
return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。
encoder_hidden_states（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 编码器最后一层的隐藏状态序列。如果模型配置为解码器，则在交叉注意力中使用。
encoder_attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）— 用于避免在编码器输入的填充标记索引上执行注意力的掩码。如果模型配置为解码器，则在交叉注意力中使用此掩码。选择的掩码值在[0, 1]中：

1 表示未被屏蔽的标记，
0 表示被屏蔽的标记。

labels (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用于计算从左到右的语言建模损失（下一个词预测）的标签。索引应在[-100, 0, ..., config.vocab_size]范围内（参见input_ids文档字符串）。索引设置为-100的标记将被忽略（掩码），损失仅计算具有[0, ..., config.vocab_size]标签的标记。
past_key_values (tuple(tuple(torch.FloatTensor))，长度为config.n_layers，每个元组包含形状为(batch_size, num_heads, sequence_length - 1, embed_size_per_head)的 4 个张量） — 包含注意力块的预计算键和值隐藏状态。可用于加速解码。
如果使用past_key_values，用户可以选择仅输入形状为(batch_size, 1)的最后decoder_input_ids（那些没有将它们的过去键值状态提供给此模型的）而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。
use_cache (bool, optional) — 如果设置为True，将返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。

transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或torch.FloatTensor元组

一个 transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置（BertGenerationConfig）和输入的各种元素。

loss (torch.FloatTensor of shape (1,), optional, 当提供labels时返回) — 语言建模损失（用于下一个标记预测）。
logits (torch.FloatTensor of shape (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型具有嵌入层，则为嵌入输出的输出+每层输出的输出）。
模型在每一层输出处的隐藏状态以及可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。
在自注意力头中用于计算加权平均值的注意力 softmax 之后的注意力权重。
cross_attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。
在交叉注意力头中用于计算加权平均值的交叉注意力 softmax 之后的注意力权重。
past_key_values (tuple(tuple(torch.FloatTensor)), optional, 当传递use_cache=True或config.use_cache=True时返回) — 包含config.n_layers长度的torch.FloatTensor元组，每个元组包含自注意力和交叉注意力层的缓存键、值状态。仅在config.is_decoder = True时相关。
包含预计算的隐藏状态（注意力块中的键和值），可用于加速顺序解码。

BertGenerationDecoder 的前向方法覆盖了__call__特殊方法。

尽管前向传递的配方需要在此函数内定义，但应该在此之后调用Module实例，而不是这个，因为前者负责运行预处理和后处理步骤，而后者则会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, BertGenerationDecoder, BertGenerationConfig
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("google/bert_for_seq_generation_L-24_bbc_encoder")
>>> config = BertGenerationConfig.from_pretrained("google/bert_for_seq_generation_L-24_bbc_encoder")
>>> config.is_decoder = True
>>> model = BertGenerationDecoder.from_pretrained(
...     "google/bert_for_seq_generation_L-24_bbc_encoder", config=config
... )
>>> inputs = tokenizer("Hello, my dog is cute", return_token_type_ids=False, return_tensors="pt")
>>> outputs = model(**inputs)
>>> prediction_logits = outputs.logits

BertJapanese

原始文本：huggingface.co/docs/transformers/v4.37.2/en/model_doc/bert-japanese

概述

在日文文本上训练的 BERT 模型。

有两种不同的分词方法的模型：

使用 MeCab 和 WordPiece 进行标记化。这需要一些额外的依赖项，fugashi是MeCab的包装器。
将标记化为字符。

要使用MecabTokenizer，您应该pip install transformers["ja"]（或者如果您从源代码安装，则应该pip install -e .["ja"]）来安装依赖项。

请参阅cl-tohoku 存储库上的详细信息。

使用 MeCab 和 WordPiece 分词的模型的示例：

>>> import torch
>>> from transformers import AutoModel, AutoTokenizer
>>> bertjapanese = AutoModel.from_pretrained("cl-tohoku/bert-base-japanese")
>>> tokenizer = AutoTokenizer.from_pretrained("cl-tohoku/bert-base-japanese")
>>> ## Input Japanese Text
>>> line = "吾輩は猫である。"
>>> inputs = tokenizer(line, return_tensors="pt")
>>> print(tokenizer.decode(inputs["input_ids"][0]))
[CLS] 吾輩 は 猫 で ある 。 [SEP]
>>> outputs = bertjapanese(**inputs)

使用字符分词的模型示例：

>>> bertjapanese = AutoModel.from_pretrained("cl-tohoku/bert-base-japanese-char")
>>> tokenizer = AutoTokenizer.from_pretrained("cl-tohoku/bert-base-japanese-char")
>>> ## Input Japanese Text
>>> line = "吾輩は猫である。"
>>> inputs = tokenizer(line, return_tensors="pt")
>>> print(tokenizer.decode(inputs["input_ids"][0]))
[CLS] 吾 輩 は 猫 で あ る 。 [SEP]
>>> outputs = bertjapanese(**inputs)

这个模型是由cl-tohoku贡献的。

这个实现与 BERT 相同，只是分词方法不同。有关 API 参考信息，请参考 BERT 文档。

BertJapaneseTokenizer

`class transformers.BertJapaneseTokenizer`

<来源>

( vocab_file spm_file = None do_lower_case = False do_word_tokenize = True do_subword_tokenize = True word_tokenizer_type = 'basic' subword_tokenizer_type = 'wordpiece' never_split = None unk_token = '[UNK]' sep_token = '[SEP]' pad_token = '[PAD]' cls_token = '[CLS]' mask_token = '[MASK]' mecab_kwargs = None sudachi_kwargs = None jumanpp_kwargs = None **kwargs )

参数

vocab_file (str) — 指向一个每行一个 wordpiece 的词汇文件的路径。
spm_file (str, 可选) — 指向包含词汇表的SentencePiece文件的路径（通常具有.spm 或.model 扩展名）。
do_lower_case (bool, 可选, 默认为True) — 是否将输入转换为小写。仅在 do_basic_tokenize=True 时有效。
do_word_tokenize (bool, 可选, 默认为True) — 是否进行词分词。
do_subword_tokenize (bool, 可选, 默认为True) — 是否进行子词分词。
word_tokenizer_type (str, 可选, 默认为"basic") — 词分词器的类型。可选择从["basic", “mecab”, “sudachi”, “jumanpp”]中选择。
subword_tokenizer_type (str, 可选, 默认为"wordpiece") — 子词分词器的类型。可选择从["wordpiece", “character”, “sentencepiece”]中选择。
mecab_kwargs (dict, 可选) — 传递给MecabTokenizer构造函数的字典。
sudachi_kwargs (dict, 可选) — 传递给SudachiTokenizer构造函数的字典。
jumanpp_kwargs (dict, 可选) — 传递给JumanppTokenizer构造函数的字典。

为日文文本构建一个 BERT 分词器。

这个分词器继承自 PreTrainedTokenizer，其中包含大多数主要方法。用户应参考：这个超类以获取有关这些方法的更多信息。

`build_inputs_with_special_tokens`

<来源>

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

token_ids_0 (List[int]) — ID 列表，将添加特殊标记。
token_ids_1 (List[int], 可选) — 序列对的可选第二个 ID 列表。

List[int]

包含适当特殊标记的输入 ID 列表。

通过连接和添加特殊标记，从序列或序列对构建用于序列分类任务的模型输入。BERT 序列的格式如下：

单个序列：[CLS] X [SEP]
序列对：[CLS] A [SEP] B [SEP]

`convert_tokens_to_string`

<来源>

( tokens )

将一系列标记（字符串）转换为单个字符串。

`create_token_type_ids_from_sequences`

<来源>

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

token_ids_0 (List[int]) — ID 列表。
token_ids_1 (List[int], 可选) — 序列对的可选第二个 ID 列表。

List[int]

根据给定序列的标记类型 ID 列表。

从传递的两个序列中创建一个用于序列对分类任务的掩码。一个 BERT 序列

序列掩码的格式如下：

0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1
| first sequence    | second sequence |

如果token_ids_1为None，则此方法仅返回掩码的第一部分（0）。

`get_special_tokens_mask`

<来源>

( token_ids_0: List token_ids_1: Optional = None already_has_special_tokens: bool = False ) → export const metadata = 'undefined';List[int]

参数

token_ids_0 (List[int]) — ID 列表。
token_ids_1 (List[int], 可选) — 序列对的可选第二个 ID 列表。
already_has_special_tokens (bool, 可选，默认为False) — 标记列表是否已经使用特殊标记格式化。

List[int]

一个整数列表，范围在[0, 1]之间：1 表示特殊标记，0 表示序列标记。

从没有添加特殊标记的标记列表中检索序列 ID。当使用分词器prepare_for_model方法添加特殊标记时调用此方法。

BERTweet

原文链接：huggingface.co/docs/transformers/v4.37.2/en/model_doc/bertweet

概述

BERTweet 模型是由 Dat Quoc Nguyen、Thanh Vu 和 Anh Tuan Nguyen 在BERTweet: A pre-trained language model for English Tweets中提出的。

从论文中摘录如下：

我们提出了 BERTweet，这是第一个用于英文推文的公开大规模预训练语言模型。我们的 BERTweet 与 BERT-base（Devlin 等人，2019）具有相同的架构，使用 RoBERTa 预训练过程进行训练（Liu 等人，2019）。实验表明，BERTweet 优于强基线 RoBERTa-base 和 XLM-R-base（Conneau 等人，2020），在三个推文 NLP 任务（词性标注、命名实体识别和文本分类）上产生比先前最先进模型更好的性能结果。

此模型由dqnguyen贡献。原始代码可在此处找到。

用法示例

>>> import torch
>>> from transformers import AutoModel, AutoTokenizer
>>> bertweet = AutoModel.from_pretrained("vinai/bertweet-base")
>>> # For transformers v4.x+:
>>> tokenizer = AutoTokenizer.from_pretrained("vinai/bertweet-base", use_fast=False)
>>> # For transformers v3.x:
>>> # tokenizer = AutoTokenizer.from_pretrained("vinai/bertweet-base")
>>> # INPUT TWEET IS ALREADY NORMALIZED!
>>> line = "SC has first two presumptive cases of coronavirus , DHEC confirms HTTPURL via @USER :cry:"
>>> input_ids = torch.tensor([tokenizer.encode(line)])
>>> with torch.no_grad():
...     features = bertweet(input_ids)  # Models outputs are now tuples
>>> # With TensorFlow 2.0+:
>>> # from transformers import TFAutoModel
>>> # bertweet = TFAutoModel.from_pretrained("vinai/bertweet-base")

此实现与 BERT 相同，仅在分词方法上有所不同。有关 API 参考信息，请参考 BERT 文档。

Transformers 4.37 中文文档（二十三）（2）https://developer.aliyun.com/article/1563761

Transformers 4.37 中文文档（二十三）（1）

BertGeneration

概述

用法示例和提示

BertGenerationConfig

`class transformers.BertGenerationConfig`

BertGenerationTokenizer

`class transformers.BertGenerationTokenizer`

`save_vocabulary`

BertGenerationEncoder

`class transformers.BertGenerationEncoder`

`forward`

BertGenerationDecoder

`class transformers.BertGenerationDecoder`

`forward`

BertJapanese

概述

BertJapaneseTokenizer

`class transformers.BertJapaneseTokenizer`

`build_inputs_with_special_tokens`

`convert_tokens_to_string`

`create_token_type_ids_from_sequences`

`get_special_tokens_mask`

BERTweet

概述

用法示例

热门文章

最新文章

相关课程

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Transformers 4.37 中文文档（二十三）（1）

BertGeneration

概述

用法示例和提示

BertGenerationConfig

class transformers.BertGenerationConfig

BertGenerationTokenizer

class transformers.BertGenerationTokenizer

save_vocabulary

BertGenerationEncoder

class transformers.BertGenerationEncoder

forward

BertGenerationDecoder

class transformers.BertGenerationDecoder

forward

BertJapanese

概述

BertJapaneseTokenizer

class transformers.BertJapaneseTokenizer

build_inputs_with_special_tokens

convert_tokens_to_string

create_token_type_ids_from_sequences

get_special_tokens_mask

BERTweet

概述

用法示例

热门文章

最新文章

相关课程

相关电子书

`class transformers.BertGenerationConfig`

`class transformers.BertGenerationTokenizer`

`save_vocabulary`

`class transformers.BertGenerationEncoder`

`forward`

`class transformers.BertGenerationDecoder`

`forward`

`class transformers.BertJapaneseTokenizer`

`build_inputs_with_special_tokens`

`convert_tokens_to_string`

`create_token_type_ids_from_sequences`

`get_special_tokens_mask`