paddlenlp.transformers.unified_transformer.modeling 源代码

# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Modeling classes for UnifiedTransformer model."""

import paddle
import paddle.nn as nn
import paddle.nn.functional as F
from paddle.nn import TransformerEncoder

from .. import PretrainedModel, register_base_model
from ..model_outputs import CausalLMOutputWithCrossAttentions

__all__ = [
    "UnifiedTransformerPretrainedModel",
    'UnifiedTransformerModel',
    'UnifiedTransformerLMHeadModel',
    'UnifiedTransformerForMaskedLM',
]


[文档]class UnifiedTransformerPretrainedModel(PretrainedModel): """ An abstract class for pretrained UnifiedTransformer models. It provides UnifiedTransformer related `model_config_file`, `resource_files_names`, `pretrained_resource_files_map`, `pretrained_init_configuration`, `base_model_prefix` for downloading and loading pretrained models. See :class:`~paddlenlp.transformers.model_utils.PretrainedModel` for more details. """ pretrained_init_configuration = { "unified_transformer-12L-cn": { "vocab_size": 30004, "hidden_size": 768, "num_hidden_layers": 12, "num_attention_heads": 12, "intermediate_size": 3072, "hidden_act": "gelu", "hidden_dropout_prob": 0.1, "attention_probs_dropout_prob": 0.1, "normalize_before": True, "max_position_embeddings": 512, "type_vocab_size": 2, "initializer_range": 0.02, "unk_token_id": 0, "pad_token_id": 0, "bos_token_id": 1, "eos_token_id": 2, "mask_token_id": 30000, }, "unified_transformer-12L-cn-luge": { "vocab_size": 30004, "hidden_size": 768, "num_hidden_layers": 12, "num_attention_heads": 12, "intermediate_size": 3072, "hidden_act": "gelu", "hidden_dropout_prob": 0.1, "attention_probs_dropout_prob": 0.1, "normalize_before": True, "max_position_embeddings": 512, "type_vocab_size": 2, "initializer_range": 0.02, "unk_token_id": 0, "pad_token_id": 0, "bos_token_id": 1, "eos_token_id": 2, "mask_token_id": 30000, }, "plato-mini": { "vocab_size": 30001, "hidden_size": 768, "num_hidden_layers": 6, "num_attention_heads": 12, "intermediate_size": 3072, "hidden_act": "gelu", "hidden_dropout_prob": 0.1, "attention_probs_dropout_prob": 0.1, "normalize_before": True, "max_position_embeddings": 512, "type_vocab_size": 2, "initializer_range": 0.02, "unk_token_id": 0, "pad_token_id": 0, "bos_token_id": 1, "eos_token_id": 2, "mask_token_id": 30000, }, "plato-xl": { "vocab_size": 8001, "hidden_size": 3072, "num_hidden_layers": 72, "num_attention_heads": 32, "intermediate_size": 18432, "hidden_act": "gelu", "hidden_dropout_prob": 0.1, "attention_probs_dropout_prob": 0.1, "normalize_before": True, "max_position_embeddings": 1024, "type_vocab_size": 3, "role_type_size": 128, "initializer_range": 0.02, "unk_token_id": 0, "pad_token_id": 0, "bos_token_id": 1, "eos_token_id": 2, "mask_token_id": 8000, } } pretrained_resource_files_map = { "model_state": { "unified_transformer-12L-cn": "https://bj.bcebos.com/paddlenlp/models/transformers/unified_transformer/unified_transformer-12L-cn.pdparams", "unified_transformer-12L-cn-luge": "https://bj.bcebos.com/paddlenlp/models/transformers/unified_transformer/unified_transformer-12L-cn-luge.pdparams", "plato-mini": "https://bj.bcebos.com/paddlenlp/models/transformers/unified_transformer/plato-mini.pdparams", "plato-xl": "https://bj.bcebos.com/paddlenlp/models/transformers/unified_transformer/plato-xl.pdparams", } } base_model_prefix = "unified_transformer" def init_weights(self, layer): # Initialization hook if isinstance(layer, (nn.Linear, nn.Embedding)): # In the dygraph mode, use the `set_value` to reset the parameter directly, # and reset the `state_dict` to update parameter in static mode. if isinstance( layer.weight, paddle.Tensor) and paddle.get_default_dtype() == "float32": layer.weight.set_value( # TODO(guosheng): `normal` does not support float16, and # need to handle this when using fp16 as default dtype for # big models. paddle.tensor.normal( mean=0.0, std=self.initializer_range if hasattr( self, "initializer_range") else self.unified_transformer.config["initializer_range"], shape=layer.weight.shape))
class UnifiedTransformerEmbeddings(nn.Layer): #Include embeddings from word, position and token_type. def __init__(self, vocab_size, hidden_size=768, hidden_dropout_prob=0.1, max_position_embeddings=512, type_vocab_size=2, role_type_size=None, pad_token_id=None): super(UnifiedTransformerEmbeddings, self).__init__() self.word_embeddings = nn.Embedding(vocab_size, hidden_size) self.position_embeddings = nn.Embedding(max_position_embeddings, hidden_size) self.token_type_embeddings = nn.Embedding(type_vocab_size, hidden_size) self.role_embeddings = None if role_type_size is None else nn.Embedding( role_type_size, hidden_size) self.dropout = nn.Dropout(hidden_dropout_prob) self.pad_token_id = pad_token_id def forward(self, input_ids, token_type_ids=None, position_ids=None, role_ids=None): if position_ids is None: if self.pad_token_id is None: position_ids = paddle.expand_as( paddle.arange(end=paddle.shape(input_ids)[1], dtype="int64"), input_ids) else: # NOTE: If there is a unk_token_id in input_ids, the following logic is wrong. # In that case, the position_ids must be provided. # And this is for left padding input_ids. num_pad = paddle.sum( (input_ids == self.pad_token_id).astype("float32"), axis=-1, keepdim=True) position_ids = F.relu( paddle.expand_as( paddle.arange(end=paddle.shape(input_ids)[1], dtype="float32"), input_ids) - num_pad).astype("int64") position_ids.stop_gradient = True input_embedings = self.word_embeddings(input_ids) position_embeddings = self.position_embeddings(position_ids) if token_type_ids is None: token_type_ids = paddle.zeros_like(input_ids, dtype="int64") token_type_ids.stop_gradient = True token_type_embeddings = self.token_type_embeddings(token_type_ids) embeddings = input_embedings + position_embeddings + token_type_embeddings # A model with role_embeddings can generate without role_ids. if role_ids is not None: embeddings += self.role_embeddings(role_ids) embeddings = self.dropout(embeddings) return embeddings
[文档]@register_base_model class UnifiedTransformerModel(UnifiedTransformerPretrainedModel): """ The bare UnifiedTransformer Model outputting raw hidden-states. This model inherits from :class:`~paddlenlp.transformers.model_utils.PretrainedModel`. Refer to the superclass documentation for the generic methods. This model is also a `paddle.nn.Layer <https://www.paddlepaddle.org.cn /documentation/docs/en/api/paddle/fluid/dygraph/layers/Layer_en.html>`__ subclass. Use it as a regular Paddle Layer and refer to the Paddle documentation for all matter related to general usage and behavior. Args: vocab_size (int): Vocabulary size of `inputs_ids` in :class:`UnifiedTransformerModel`. Also is the vocab size of token embedding matrix. hidden_size (int, optional): Dimensionality of the embedding layers, encoder layers and pooler layer. Defaults to 768. num_hidden_layers (int, optional): The number of hidden layers in the encoder. Defaults to 12. num_attention_heads (int, optional): The number of heads in multi-head attention(MHA). Defaults to 12. intermediate_size (int, optional): Dimensionality of the feed-forward layer in the encoder. Input tensors to feed-forward layers are firstly projected from `hidden_size` to `intermediate_size`, and then projected back to `hidden_size`. Typically `intermediate_size` is larger than `hidden_size`. Defaults to 3072. hidden_act (str, optional): The activation function in the feedforward network. Defaults to "gelu". hidden_dropout_prob(float, optional): The dropout probability used in pre-process and post-precess of MHA and FFN sub-layer. Defaults to 0.1. attention_probs_dropout_prob (float, optional): The dropout probability used in MHA to drop some attention target. Defaults to 0.1. normalize_before (bool, optional): Indicate whether to put layer normalization into preprocessing of MHA and FFN sub-layers. If True, pre-process is layer normalization and post-precess includes dropout, residual connection. Otherwise, no pre-process and post-precess includes dropout, residual connection, layer normalization. Defaults to True. max_position_embeddings (int, optional): The maximum length of input `position_ids`. Defaults to 512. type_vocab_size (int, optional): The size of the input `token_type_ids`. Defaults to 2. initializer_range (float, optional): The standard deviation of the normal initializer. Defaults to 0.02. .. note:: A normal_initializer initializes weight matrices as normal distributions. See :meth:`UnifiedTransformerPretrainedModel.init_weights` method for how weights are initialized in :class:`UnifiedTransformerModel`. unk_token_id (int, optional): The id of special token `unk_token`. Defaults to 0. pad_token_id (int, optional): The id of special token `pad_token`. Defaults to 0. bos_token_id (int, optional): The id of special token `bos_token`. Defaults to 1. eos_token_id (int, optional): The id of special token `eos_token`. Defaults to 2. mask_token_id (int, optional): The id of special token `mask_token`. Defaults to 30000. """ def __init__(self, vocab_size, hidden_size=768, num_hidden_layers=12, num_attention_heads=12, intermediate_size=3072, hidden_act="gelu", hidden_dropout_prob=0.1, attention_probs_dropout_prob=0.1, normalize_before=True, max_position_embeddings=512, type_vocab_size=2, initializer_range=0.02, unk_token_id=0, pad_token_id=0, bos_token_id=1, eos_token_id=2, mask_token_id=30000, role_type_size=None): super(UnifiedTransformerModel, self).__init__() self.unk_token_id = unk_token_id self.pad_token_id = pad_token_id self.bos_token_id = bos_token_id self.eos_token_id = eos_token_id self.mask_token_id = mask_token_id self.initializer_range = initializer_range self.embeddings = UnifiedTransformerEmbeddings(vocab_size, hidden_size, hidden_dropout_prob, max_position_embeddings, type_vocab_size, role_type_size, self.pad_token_id) encoder_layer = nn.TransformerEncoderLayer( hidden_size, num_attention_heads, intermediate_size, dropout=hidden_dropout_prob, activation=hidden_act, attn_dropout=attention_probs_dropout_prob, act_dropout=0, normalize_before=normalize_before) encoder_norm = nn.LayerNorm(hidden_size) self.encoder = nn.TransformerEncoder(encoder_layer, num_hidden_layers, encoder_norm) self.apply(self.init_weights)
[文档] def get_input_embeddings(self): return self.embeddings.word_embeddings
[文档] def set_input_embeddings(self, value): self.embeddings.word_embeddings = value
[文档] def forward(self, input_ids, token_type_ids=None, position_ids=None, attention_mask=None, use_cache=False, cache=None, role_ids=None, output_attentions=False, output_hidden_states=False, return_dict=False): r""" The UnifiedTransformerModel forward method, overrides the special :meth:`__call__` method. Args: input_ids (Tensor): Indices of input sequence tokens in the vocabulary. They are numerical representations of tokens that build the input sequence. It's data type should be `int64` and has a shape of [batch_size, sequence_length]. token_type_ids (Tensor): Segment token indices to indicate first and second portions of the inputs. Indices can be either 0 or 1: - 0 corresponds to a **sentence A** token, - 1 corresponds to a **sentence B** token. It's data type should be `int64` and has a shape of [batch_size, sequence_length]. position_ids (Tensor): The position indices of input sequence tokens. It's data type should be `int64` and has a shape of [batch_size, sequence_length]. attention_mask (Tensor): A tensor used in multi-head attention to prevents attention to some unwanted positions, usually the paddings or the subsequent positions. It is a tensor with shape broadcasted to [batch_size, n_head, sequence_length, sequence_length]. - When the data type is bool, the unwanted positions have `False` values and the others have `True` values. - When the data type is int, the unwanted positions have 0 values and the others have 1 values. - When the data type is float, the unwanted positions have `-INF` values and the others have 0 values. use_cache: (bool, optional): Whether or not use the model cache to speed up decoding. Defaults to False. cache (list, optional): It is a list, and each element in the list is `incremental_cache` produced by :meth:`paddle.nn.TransformerEncoderLayer.gen_cache` method. See :meth:`paddle.nn.TransformerEncoder.gen_cache` method for more details. It is only used for inference and should be None for training. Defaults to None. role_ids (Tensor, optional): Indices of role ids indicated different roles. It's data type should be `int64` and has a shape of [batch_size, sequence_length]. Defaults to None. output_attentions (bool, optional): Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned tensors for more detail. Defaults to `False`. output_hidden_states (bool, optional): Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for more detail. Defaults to `False`. return_dict (bool, optional): Whether to return a :class:`~paddlenlp.transformers.model_outputs.BaseModelOutputWithPastAndCrossAttentions` object. If `False`, the output will be a tuple of tensors. Defaults to `False`. Returns: An instance of :class:`~paddlenlp.transformers.model_outputs.BaseModelOutputWithPastAndCrossAttentions` if `return_dict=True`. Otherwise it returns a tuple of tensors corresponding to ordered and not None (depending on the input arguments) fields of :class:`~paddlenlp.transformers.model_outputs.BaseModelOutputWithPastAndCrossAttentions`. Especially, When `return_dict=output_hidden_states=output_attentions=False` and `cache=None`, returns a tensor representing the output of :class:`UnifiedTransformerModel`, with shape [batch_size, sequence_length, hidden_size]. The data type is float32 or float64. Example: .. code-block:: from paddlenlp.transformers import UnifiedTransformerModel from paddlenlp.transformers import UnifiedTransformerTokenizer model = UnifiedTransformerModel.from_pretrained('plato-mini') tokenizer = UnifiedTransformerTokenizer.from_pretrained('plato-mini') history = '我爱祖国' inputs = tokenizer.dialogue_encode( history, return_tensors=True, is_split_into_words=False) outputs = model(**inputs) """ if attention_mask is None: attention_mask = ((input_ids == self.pad_token_id).astype( paddle.get_default_dtype()) * -1e4).unsqueeze([1, 2]) attention_mask.stop_gradient = True embedding_output = self.embeddings(input_ids, token_type_ids, position_ids, role_ids=role_ids) if use_cache and cache is None: cache = self.encoder.gen_cache(embedding_output) sequence_output = self.encoder( embedding_output, attention_mask, cache, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, ) return sequence_output
class UnifiedTransformerLMHead(nn.Layer): def __init__(self, hidden_size, vocab_size, activation, embedding_weights=None): super(UnifiedTransformerLMHead, self).__init__() self.transform = nn.Linear(hidden_size, hidden_size) self.activation = getattr(nn.functional, activation) self.layer_norm = nn.LayerNorm(hidden_size) self.decoder_weight = self.create_parameter( shape=[vocab_size, hidden_size], dtype=self.transform.weight.dtype, is_bias=False) if embedding_weights is None else embedding_weights self.decoder_bias = self.create_parameter( shape=[vocab_size], dtype=self.decoder_weight.dtype, is_bias=True) def forward(self, hidden_states, masked_positions=None): if masked_positions is not None: hidden_states = paddle.reshape(hidden_states, [-1, hidden_states.shape[-1]]) hidden_states = paddle.tensor.gather(hidden_states, masked_positions) hidden_states = self.transform(hidden_states) hidden_states = self.activation(hidden_states) hidden_states = self.layer_norm(hidden_states) logits = paddle.tensor.matmul(hidden_states, self.decoder_weight, transpose_y=True) + self.decoder_bias return logits
[文档]class UnifiedTransformerLMHeadModel(UnifiedTransformerPretrainedModel): """ The UnifiedTransformer Model with a language modeling head on top for generation tasks. Args: unified_transformer (:class:`UnifiedTransformerModel`): An instance of :class:`UnifiedTransformerModel`. """ def __init__(self, unified_transformer): super(UnifiedTransformerLMHeadModel, self).__init__() self.unified_transformer = unified_transformer self.lm_head = UnifiedTransformerLMHead( self.unified_transformer.config["hidden_size"], self.unified_transformer.config["vocab_size"], self.unified_transformer.config["hidden_act"], self.unified_transformer.embeddings.word_embeddings.weight) self.apply(self.init_weights)
[文档] def forward(self, input_ids, token_type_ids=None, position_ids=None, attention_mask=None, masked_positions=None, use_cache=False, cache=None, role_ids=None, labels=None, output_attentions=False, output_hidden_states=False, return_dict=False): r""" The UnifiedTransformerLMHeadModel forward method, overrides the special :meth:`__call__` method. Args: input_ids (Tensor): See :class:`UnifiedTransformerModel`. token_type_ids (Tensor): See :class:`UnifiedTransformerModel`. position_ids (Tensor): See :class:`UnifiedTransformerModel`. attention_mask (Tensor): See :class:`UnifiedTransformerModel`. use_cache: (bool, optional): See :class:`UnifiedTransformerModel`. cache (list, optional): See :class:`UnifiedTransformerModel`. role_ids: (Tensor, optional): See :class:`UnifiedTransformerModel`. labels: (Tensor, optional): Labels for computing the left-to-right language modeling loss. Indices should be in `[-100, 0, ..., vocab_size]` (see `input_ids` docstring) Tokens with indices set to `-100` are ignored (masked), the loss is only computed for the tokens with labels n `[0, ..., vocab_size]` output_attentions (bool, optional): See :class: `UnifiedTransformerModel` output_hidden_states (bool, optional): See :class: `UnifiedTransformerModel` return_dict (bool, optional): See :class: `UnifiedTransformerModel` Returns: An instance of :class:`~paddlenlp.transformers.model_outputs.CausalLMOutputWithCrossAttentions` if `return_dict=True`. Otherwise it returns a tuple of tensors corresponding to ordered and not None (depending on the input arguments) fields of :class:`~paddlenlp.transformers.model_outputs.CausalLMOutputWithCrossAttentions`. Especially, When `return_dict=output_hidden_states=output_attentions=False` and `cache=labels=None`, returns a tensor representing the output of :class:`UnifiedTransformerLMHeadModel`, with shape [batch_size, sequence_length, vocab_size]. The data type is float32 or float64. Example: .. code-block:: from paddlenlp.transformers import UnifiedTransformerLMHeadModel from paddlenlp.transformers import UnifiedTransformerTokenizer model = UnifiedTransformerLMHeadModel.from_pretrained('plato-mini') tokenizer = UnifiedTransformerTokenizer.from_pretrained('plato-mini') history = '我爱祖国' inputs = tokenizer.dialogue_encode( history, return_tensors=True, is_split_into_words=False) logits = model(**inputs) """ outputs = self.unified_transformer( input_ids, token_type_ids, position_ids, attention_mask, use_cache, cache, role_ids=role_ids, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, ) sequence_output = outputs if isinstance(outputs, type(input_ids)) else outputs[0] logits = self.lm_head(sequence_output, masked_positions) lm_loss = None if labels is not None: loss_fct = nn.CrossEntropyLoss() lm_loss = loss_fct(logits.reshape((-1, logits.shape[-1])), labels.reshape([-1])) if not return_dict: if isinstance(outputs, type(input_ids)): return (lm_loss, logits) if lm_loss is not None else logits else: outputs = (logits, ) + outputs[1:] return ((lm_loss, ) + outputs) if lm_loss is not None else outputs return CausalLMOutputWithCrossAttentions( loss=lm_loss, logits=logits, past_key_values=outputs.past_key_values, hidden_states=outputs.hidden_states, attentions=outputs.attentions, cross_attentions=outputs.cross_attentions, )
def prepare_faster_entry(self, kwargs): from paddlenlp.ops import FasterUnifiedTransformer use_fp16_decoding = kwargs.get('use_fp16_decoding', False) decode_strategy = kwargs.get('decode_strategy') if decode_strategy == 'sampling' and kwargs.get( 'top_k') != 0 and kwargs.get('top_p') != 1: raise AttributeError( "Only topk sampling or topp sampling are supported. " \ "Topk sampling and topp sampling cannot be both applied in the faster version.") if kwargs['repetition_penalty'] != 1.0: # not support for repetition_penalty yet in the faster version raise AttributeError( "'repetition_penalty != 1' is not supported yet in the faster version" ) if kwargs['forced_bos_token_id'] is not None: # not support for min_length yet in the faster version raise AttributeError( "'forced_bos_token_id != None' is not supported yet in the faster version" ) self._faster_entry = FasterUnifiedTransformer( self, use_fp16_decoding=use_fp16_decoding).forward return self._faster_entry def adjust_logits_during_generation(self, logits): # pre-process distribution logits[:, self.unified_transformer.unk_token_id] = -1e4 logits[:, self.unified_transformer.bos_token_id] = -1e4 logits[:, self.unified_transformer.mask_token_id] = -1e4 return logits def prepare_inputs_for_generation(self, input_ids, token_type_ids=None, position_ids=None, attention_mask=None, use_cache=False, cache=None, **kwargs): role_ids = kwargs.get("role_ids", None) if position_ids is None: if self.pad_token_id is None: position_ids = paddle.expand_as( paddle.arange(end=paddle.shape(input_ids)[1], dtype="int64"), input_ids) else: # NOTE: If there is a unk_token_id in input_ids, the following logic is wrong. # In that case, the position_ids must be provided. # And this is for left padding input_ids. num_pad = paddle.sum( (input_ids == self.pad_token_id).astype("float32"), axis=-1, keepdim=True) position_ids = F.relu( paddle.expand_as( paddle.arange(end=paddle.shape(input_ids)[1], dtype="float32"), input_ids) - num_pad).astype("int64") position_ids.stop_gradient = True if token_type_ids is None: token_type_ids = paddle.zeros_like(input_ids, dtype="int64") token_type_ids.stop_gradient = True if attention_mask is None: attention_mask = ((input_ids == self.pad_token_id).astype( paddle.get_default_dtype()) * -1e4).unsqueeze([1, 2]) attention_mask.stop_gradient = True # only last token for inputs_ids if cache is defined in kwargs if cache is not None: input_ids = input_ids[:, -1:] if token_type_ids is not None: token_type_ids = token_type_ids[:, -1:] if position_ids is not None: position_ids = position_ids[:, -1:] if role_ids is not None: role_ids = role_ids[:, -1:] if attention_mask is not None: attention_mask = attention_mask[:, :, -1:, :] return { "input_ids": input_ids, "token_type_ids": token_type_ids, "position_ids": position_ids, "attention_mask": attention_mask, "use_cache": use_cache, "cache": cache, "role_ids": role_ids } def __getattr__(self, name): try: return super().__getattr__(name) except AttributeError as e: try: return getattr(getattr(self, self.base_model_prefix), name) except AttributeError: try: return getattr(self, self.base_model_prefix).config[name] except KeyError: raise e
UnifiedTransformerForMaskedLM = UnifiedTransformerLMHeadModel