Transformers documentation
ERNIE
Este modelo se publicó en HF papers el 19-04-2019 y se contribuyó a Hugging Face Transformers el 09-09-2022.
ERNIE
ERNIE1.0, ERNIE2.0, ERNIE3.0, ERNIE-Gram y ERNIE-health son una serie de modelos potentes propuestos por baidu, especialmente en tareas de chino.
ERNIE (Enhanced Representation through kNowledge IntEgration) está diseñado para aprender representaciones del lenguaje mejoradas mediante estrategias de enmascarado de conocimiento, que incluyen el enmascarado a nivel de entidad y el enmascarado a nivel de frase.
Otros modelos ERNIE publicados por baidu pueden encontrarse en Ernie 4.5 y Ernie 4.5 MoE.
Este modelo fue aportado por nghuyong, y el código oficial se puede encontrar en PaddleNLP (en PaddlePaddle).
Haz clic en los modelos ERNIE en la barra lateral derecha para ver más ejemplos de cómo aplicar ERNIE a diferentes tareas de lenguaje.
El siguiente ejemplo demuestra cómo predecir el token [MASK] con Pipeline, AutoModel y desde la línea de comandos.
from transformers import pipeline
pipeline = pipeline(
task="fill-mask",
model="nghuyong/ernie-3.0-xbase-zh"
)
pipeline("巴黎是[MASK]国的首都。")import torch
from transformers import AutoModelForMaskedLM, AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained(
"nghuyong/ernie-3.0-xbase-zh",
)
model = AutoModelForMaskedLM.from_pretrained(
"nghuyong/ernie-3.0-xbase-zh",
device_map="auto"
)
inputs = tokenizer("巴黎是[MASK]国的首都。", return_tensors="pt").to(model.device)
with torch.no_grad():
outputs = model(**inputs)
predictions = outputs.logits
masked_index = torch.where(inputs['input_ids'] == tokenizer.mask_token_id)[1]
predicted_token_id = predictions[0, masked_index].argmax(dim=-1)
predicted_token = tokenizer.decode(predicted_token_id)
print(f"The predicted token is: {predicted_token}")Notas
Las variantes de modelos están disponibles en diferentes tamaños y idiomas.
| Nombre del modelo | Idioma | Descripción |
|---|---|---|
| ernie-1.0-base-zh | Chino | Capa:12, Cabezas:12, Oculta:768 |
| ernie-2.0-base-en | Inglés | Capa:12, Cabezas:12, Oculta:768 |
| ernie-2.0-large-en | Inglés | Capa:24, Cabezas:16, Oculta:1024 |
| ernie-3.0-base-zh | Chino | Capa:12, Cabezas:12, Oculta:768 |
| ernie-3.0-medium-zh | Chino | Capa:6, Cabezas:12, Oculta:768 |
| ernie-3.0-mini-zh | Chino | Capa:6, Cabezas:12, Oculta:384 |
| ernie-3.0-micro-zh | Chino | Capa:4, Cabezas:12, Oculta:384 |
| ernie-3.0-nano-zh | Chino | Capa:4, Cabezas:12, Oculta:312 |
| ernie-health-zh | Chino | Capa:12, Cabezas:12, Oculta:768 |
| ernie-gram-zh | Chino | Capa:12, Cabezas:12, Oculta:768 |
Recursos
Puedes encontrar todos los modelos compatibles en el hub de modelos de huggingface: huggingface.co/nghuyong, y los detalles de los modelos en el repositorio oficial de paddle: PaddleNLP y la rama legacy de ERNIE.
ErnieConfig
clase transformers.ErnieConfig
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevocab_size: int = 30522hidden_size: int = 768num_hidden_layers: int = 12num_attention_heads: int = 12intermediate_size: int = 3072hidden_act: str = 'gelu'hidden_dropout_prob: float | int = 0.1attention_probs_dropout_prob: float | int = 0.1max_position_embeddings: int = 512type_vocab_size: int = 2task_type_vocab_size: int = 3use_task_id: bool = Falseinitializer_range: float = 0.02layer_norm_eps: float = 1e-12pad_token_id: int | None = 0use_cache: bool = Trueclassifier_dropout: float | int | None = Noneis_decoder: bool = Falseadd_cross_attention: bool = Falsebos_token_id: int | None = Noneeos_token_id: int | list[int] | None = Nonetie_word_embeddings: bool = True )
Parámetros
- vocab_size (
int, opcional, valor predeterminado30522) — Tamaño del vocabulario del modelo. Define el número de tokens diferentes que pueden representarse medianteinput_ids. - hidden_size (
int, opcional, valor predeterminado768) — Dimensión de las representaciones ocultas. - num_hidden_layers (
int, opcional, valor predeterminado12) — Número de capas ocultas en el decodificador del Transformer. - num_attention_heads (
int, opcional, valor predeterminado12) — Número de cabezas de atención para cada capa de atención en el decodificador Transformer. - intermediate_size (
int, opcional, valor predeterminado3072) — Dimensión de las representaciones del MLP. - hidden_act (
str, opcional, valor predeterminadogelu) — La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo,"gelu","relu","silu", etc. - hidden_dropout_prob (
Union[float, int], opcional, valor predeterminado0.1) — La probabilidad de dropout para todas las capas totalmente conectadas en las incrustaciones, el codificador y el pooler. - attention_probs_dropout_prob (
Union[float, int], opcional, valor predeterminado0.1) — La proporción de dropout para las probabilidades de atención. - max_position_embeddings (
int, opcional, valor predeterminado512) — La longitud máxima de secuencia con la que se podría utilizar este modelo. - type_vocab_size (
int, opcional, valor predeterminado2) — El tamaño del vocabulario detoken_type_ids. - task_type_vocab_size (
int, opcional, valor predeterminado 3) — El tamaño del vocabulario detask_type_idspara el modelo ERNIE2.0/ERNIE3.0 - use_task_id (
bool, opcional, valor predeterminadoFalse) — Indica si el modelo admitetask_type_ids - initializer_range (
float, opcional, valor predeterminado0.02) — La desviación estándar del truncated_normal_initializer para inicializar todas las matrices de pesos. - layer_norm_eps (
float, opcional, valor predeterminado1e-12) — El epsilon utilizado por las capas de normalización de capa. - pad_token_id (
int, opcional, valor predeterminado0) — Id del token utilizado para el relleno en el vocabulario. - use_cache (
bool, opcional, valor predeterminadoTrue) — Indica si el modelo debe devolver las últimas claves/valores de atención (no utilizado por todos los modelos). Solo es relevante siconfig.is_decoder=Trueo cuando el modelo es un modelo generativo solo de decodificador. - classifier_dropout (
Union[float, int], opcional) — La proporción de dropout para el clasificador. - is_decoder (
bool, opcional, valor predeterminadoFalse) — Indica si el modelo se utiliza como decodificador o no. Si esFalse, el modelo se utiliza como codificador. - add_cross_attention (
bool, opcional, valor predeterminadoFalse) — Si se deben añadir capas de atención cruzada al modelo. - bos_token_id (
int, opcional) — Id del token utilizado para el inicio de la secuencia en el vocabulario. - eos_token_id (
Union[int, list[int]], opcional) — Id del token utilizado para el fin de secuencia en el vocabulario. - tie_word_embeddings (
bool, opcional, valor predeterminadoTrue) — Si se deben vincular las matrices de pesos de embeddings según el mapeotied_weights_keysdel modelo.
Esta es la clase de configuración para almacenar la configuración de un ErnieModel. Se utiliza para instanciar un modelo Ernie según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de nghuyong/ernie-3.0-base-zh
Los objetos de configuración heredan de PreTrainedConfig y se pueden usar para controlar las salidas del modelo. Lea la documentación de PreTrainedConfig para obtener más información.
Ejemplos:
>>> from transformers import ErnieConfig, ErnieModel
>>> # Initializing a ERNIE nghuyong/ernie-3.0-base-zh style configuration
>>> configuration = ErnieConfig()
>>> # Initializing a model (with random weights) from the nghuyong/ernie-3.0-base-zh style configuration
>>> model = ErnieModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configSalidas específicas de Ernie
clase transformers.models.ernie.modeling_ernie.ErnieForPreTrainingOutput
< source >( loss: typing.Optional[torch.Tensor] = Noneprediction_logits: typing.Optional[torch.Tensor] = Noneseq_relationship_logits: typing.Optional[torch.Tensor] = Nonehidden_states: tuple[torch.Tensor] | None = Noneattentions: tuple[torch.Tensor] | None = None )
Parámetros
- loss (
*optional*, returned whenlabelsis provided,torch.Tensorof shape(1,)) — Pérdida total como la suma de la pérdida de modelado de lenguaje enmascarado y la pérdida de predicción de la siguiente secuencia (clasificación). - prediction_logits (
torch.Tensorde forma(batch_size, sequence_length, config.vocab_size)) — Puntuaciones de predicción de la cabeza de modelado de lenguaje (puntuaciones para cada token del vocabulario antes de SoftMax). - seq_relationship_logits (
torch.Tensorde forma(batch_size, 2)) — Puntuaciones de predicción de la cabeza de predicción de la siguiente secuencia (clasificación) (puntuaciones de continuación True/False antes del SoftMax). - hidden_states (
tuple[torch.Tensor], opcional, se devuelve cuandooutput_hidden_states=Truese pasa o cuandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(uno para la salida de los embeddings, si el modelo tiene una capa de embedding, + uno para la salida de cada capa) de forma(batch_size, sequence_length, hidden_size).Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
- attentions (
tuple[torch.Tensor], opcional, se devuelve cuandooutput_attentions=Truese pasa o cuandoconfig.output_attentions=True) — Tupla detorch.Tensor(uno por cada capa) con forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
Tipo de salida de ErnieForPreTraining.
ErnieModel
clase transformers.ErnieModel
< source >( config: ErnieConfigadd_pooling_layer = True )
Parámetros
- config (ErnieConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.
- add_pooling_layer (
bool, opcional, valor predeterminadoTrue) — Si se debe añadir una capa de pooling
El modelo puede funcionar como un codificador (con solo autoatención) y también como un decodificador, en cuyo caso se añade una capa de atención cruzada entre las capas de autoatención, siguiendo la arquitectura descrita en Attention is all you need de Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser e Illia Polosukhin.
Para que el modelo se comporte como un decodificador, debe inicializarse con el argumento is_decoder de la configuración establecido en True. Para usarse en un modelo Seq2Seq, el modelo debe inicializarse con el argumento is_decoder y add_cross_attention establecidos en True; en ese caso, se espera que encoder_hidden_states sea una entrada para la pasada hacia adelante.
Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).
Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.
forward
< source >( input_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Nonetask_type_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneencoder_hidden_states: typing.Optional[torch.Tensor] = Noneencoder_attention_mask: typing.Optional[torch.Tensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPoolingAndCrossAttentions or tuple(torch.Tensor)
Parámetros
- input_ids (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada.Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.
- attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens que no están enmascarados,
- 0 para los tokens que están enmascarados.
- token_type_ids (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Índices de tokens de segmento para indicar las primeras y segundas partes de las entradas. Los índices se seleccionan en[0, 1]:- 0 corresponde a un token de sentence A,
- 1 corresponde a un token de sentence B.
- task_type_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — El embedding de tipo de tarea es un embedding especial para representar la característica de diferentes tareas, como la tarea de preentrenamiento consciente de palabras, la tarea de preentrenamiento consciente de estructura y la tarea de preentrenamiento consciente de semántica. Asignamos untask_type_ida cada tarea y eltask_type_idestá en el rango `[0, config.task_type_vocab_size-1] - position_ids (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango[0, config.n_positions - 1]. - inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasarinput_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices deinput_idsen los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo. - encoder_hidden_states (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Secuencia de estados ocultos en la salida de la última capa del codificador. Se utiliza en la atención cruzada si el modelo está configurado como decodificador. - encoder_attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno de la entrada del codificador. Esta máscara se utiliza en la atención cruzada si el modelo está configurado como decodificador. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens que no están enmascarados,
- 0 para los tokens que están enmascarados.
- past_key_values (
~cache_utils.Cache, opcional) — Estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden usar para acelerar la decodificación secuencial. Esto generalmente consiste en lapast_key_valuesdevuelta por el modelo en una etapa anterior de la decodificación, cuandouse_cache=Trueoconfig.use_cache=True.Solo se permite una instancia de Cache como entrada, consulte nuestra guía de caché kv. Si no se pasan
past_key_values, DynamicCache se inicializará de forma predeterminada.El modelo generará el mismo formato de caché que se proporciona como entrada.
Si se utilizan
past_key_values, se espera que el usuario introduzca únicamente losinput_idsno procesados (aquellos que no tienen sus estados de clave y valor pasados proporcionados a este modelo) con forma(batch_size, unprocessed_length)en lugar de todos losinput_idscon forma(batch_size, sequence_length). - use_cache (
bool, opcional) — Si se establece enTrue, se devuelven los estados de clave-valor depast_key_valuesy pueden usarse para acelerar la decodificación (verpast_key_values).
Devuelve
BaseModelOutputWithPoolingAndCrossAttentions o tuple(torch.Tensor)
Un BaseModelOutputWithPoolingAndCrossAttentions o una tupla de
torch.Tensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios
elementos según la configuración (ErnieConfig) y las entradas.
El método forward de ErnieModel sobrescribe el método especial __call__.
Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de
Moduledespués en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.
last_hidden_state (
torch.Tensorde forma(batch_size, sequence_length, hidden_size)) — Secuencia de estados ocultos en la salida de la última capa del modelo.pooler_output (
torch.Tensorde forma(batch_size, hidden_size)) — Estado oculto de la última capa del primer token de la secuencia (token de clasificación) después de un procesamiento adicional a través de las capas utilizadas para la tarea de preentrenamiento auxiliar. Por ejemplo, para la familia de modelos BERT, esto devuelve el token de clasificación después de procesarlo a través de una capa lineal y una función de activación tanh. Los pesos de la capa lineal se entrenan a partir del objetivo de predicción de la siguiente oración (clasificación) durante el preentrenamiento.hidden_states (
tuple(torch.Tensor), opcional, devuelto cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma(batch_size, sequence_length, hidden_size).Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
attentions (
tuple(torch.Tensor), opcional, se devuelve cuando se pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.Tensor(una por cada capa) de forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
cross_attentions (
tuple(torch.Tensor), opcional, se devuelve cuando se pasaoutput_attentions=Trueyconfig.add_cross_attention=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.Tensor(una por cada capa) de forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atención de la capa de atención cruzada del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada.
past_key_values (
Cache, opcional, se devuelve cuando se pasause_cache=Trueo cuandoconfig.use_cache=True) — Es una instancia de Cache. Para más detalles, consulta nuestra guía de caché kv.Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención y, opcionalmente, si
config.is_encoder_decoder=True, en los bloques de atención cruzada) que pueden utilizarse (véase la entradapast_key_values) para acelerar la decodificación secuencial.
ErnieForPreTraining
clase transformers.ErnieForPreTraining
< source >( config: ErnieConfig )
Parámetros
- config (ErnieConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.
Modelo Ernie con dos cabezas en la parte superior, tal como se hizo durante el preentrenamiento: una cabeza de masked language modeling y una cabeza de next sentence prediction (classification).
Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).
Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.
forward
< source >( input_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Nonetask_type_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = Nonenext_sentence_label: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → ErnieForPreTrainingOutput or tuple(torch.Tensor)
Parámetros
- input_ids (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada.Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.
- attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens que no están enmascarados,
- 0 para los tokens que están enmascarados.
- token_type_ids (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Índices de tokens de segmento para indicar las primeras y segundas partes de las entradas. Los índices se seleccionan en[0, 1]:- 0 corresponde a un token de sentence A,
- 1 corresponde a un token de sentence B.
- task_type_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — El embedding de tipo de tarea es un embedding especial para representar la característica de diferentes tareas, como la tarea de preentrenamiento consciente de palabras, la tarea de preentrenamiento consciente de estructura y la tarea de preentrenamiento consciente de semántica. Asignamos untask_type_ida cada tarea y eltask_type_idestá en el rango `[0, config.task_type_vocab_size-1] - position_ids (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango[0, config.n_positions - 1]. - inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasarinput_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices deinput_idsen los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo. - labels (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Etiquetas para calcular la pérdida de modelado de lenguaje enmascarado. Los índices deben estar en[-100, 0, ..., config.vocab_size](ver la docstring deinput_ids). Los tokens con índices establecidos en-100se ignoran (se enmascaran); la pérdida solo se calcula para los tokens con etiquetas en[0, ..., config.vocab_size] - next_sentence_label (
torch.LongTensorde forma(batch_size,), opcional) — Etiquetas para calcular la pérdida de predicción de la siguiente secuencia (clasificación). La entrada debe ser un par de secuencias (verinput_idsdocstring) Los índices deben estar en[0, 1]:- 0 indica que la secuencia B es una continuación de la secuencia A,
- 1 indica que la secuencia B es una secuencia aleatoria.
Devuelve
ErnieForPreTrainingOutput o tuple(torch.Tensor)
Un ErnieForPreTrainingOutput o una tupla de
torch.Tensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios
elementos según la configuración (ErnieConfig) y las entradas.
El método forward de ErnieForPreTraining sobrescribe el método especial __call__.
Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de
Moduledespués en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.
loss (
*optional*, returned whenlabelsis provided,torch.Tensorof shape(1,)) — Pérdida total como la suma de la pérdida de modelado de lenguaje enmascarado y la pérdida de predicción de la siguiente secuencia (clasificación).prediction_logits (
torch.Tensorde forma(batch_size, sequence_length, config.vocab_size)) — Puntuaciones de predicción de la cabeza de modelado de lenguaje (puntuaciones para cada token del vocabulario antes de SoftMax).seq_relationship_logits (
torch.Tensorde forma(batch_size, 2)) — Puntuaciones de predicción de la cabeza de predicción de la siguiente secuencia (clasificación) (puntuaciones de continuación True/False antes del SoftMax).hidden_states (
tuple[torch.Tensor], opcional, se devuelve cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma(batch_size, sequence_length, hidden_size).Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
attentions (
tuple[torch.Tensor], opcional, se devuelve cuando se pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.Tensor(una por cada capa) de forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
Ejemplo:
>>> from transformers import AutoTokenizer, ErnieForPreTraining
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("nghuyong/ernie-1.0-base-zh")
>>> model = ErnieForPreTraining.from_pretrained("nghuyong/ernie-1.0-base-zh")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)
>>> prediction_logits = outputs.prediction_logits
>>> seq_relationship_logits = outputs.seq_relationship_logitsErnieForCausalLM
clase transformers.ErnieForCausalLM
< source >( config: ErnieConfig )
Parámetros
- config (ErnieConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.
Modelo Ernie con una cabeza de language modeling en la parte superior para el ajuste fino de CLM.
Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).
Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.
forward
< source >( input_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Nonetask_type_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneencoder_hidden_states: typing.Optional[torch.Tensor] = Noneencoder_attention_mask: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = Nonepast_key_values: list[torch.Tensor] | None = Noneuse_cache: bool | None = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → CausalLMOutputWithCrossAttentions or tuple(torch.Tensor)
Parámetros
- input_ids (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada.Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.
- attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens que no están enmascarados,
- 0 para los tokens que están enmascarados.
- token_type_ids (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Índices de tokens de segmento para indicar las primeras y segundas partes de las entradas. Los índices se seleccionan en[0, 1]:- 0 corresponde a un token de sentence A,
- 1 corresponde a un token de sentence B.
- task_type_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — El embedding de tipo de tarea es un embedding especial para representar la característica de diferentes tareas, como la tarea de preentrenamiento consciente de palabras, la tarea de preentrenamiento consciente de estructura y la tarea de preentrenamiento consciente de semántica. Asignamos untask_type_ida cada tarea y eltask_type_idestá en el rango `[0, config.task_type_vocab_size-1] - position_ids (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango[0, config.n_positions - 1]. - inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasarinput_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices deinput_idsen los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo. - encoder_hidden_states (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Secuencia de estados ocultos en la salida de la última capa del codificador. Se utiliza en la atención cruzada si el modelo está configurado como decodificador. - encoder_attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno de la entrada del codificador. Esta máscara se utiliza en la atención cruzada si el modelo está configurado como decodificador. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens que no están enmascarados,
- 0 para los tokens que están enmascarados.
- labels (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Etiquetas para calcular la pérdida de modelado de lenguaje de izquierda a derecha (predicción de la siguiente palabra). Los índices deben estar en[-100, 0, ..., config.vocab_size](ver la docstring deinput_ids). Los tokens con índices establecidos en-100se ignoran (se enmascaran); la pérdida solo se calcula para los tokens con etiquetas en[0, ..., config.vocab_size] - past_key_values (
list[torch.Tensor], opcional) — Estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden usar para acelerar la decodificación secuencial. Esto generalmente consiste en lapast_key_valuesdevuelta por el modelo en una etapa anterior de la decodificación, cuandouse_cache=Trueoconfig.use_cache=True.Solo se permite una instancia de Cache como entrada, consulte nuestra guía de caché kv. Si no se pasan
past_key_values, DynamicCache se inicializará de forma predeterminada.El modelo generará el mismo formato de caché que se proporciona como entrada.
Si se utilizan
past_key_values, se espera que el usuario introduzca únicamente losinput_idsno procesados (aquellos que no tienen sus estados de clave y valor pasados proporcionados a este modelo) con forma(batch_size, unprocessed_length)en lugar de todos losinput_idscon forma(batch_size, sequence_length). - use_cache (
bool, opcional) — Si se establece enTrue, se devuelven los estados de clave-valor depast_key_valuesy pueden usarse para acelerar la decodificación (verpast_key_values). - logits_to_keep (
Union[int, torch.Tensor], opcional, valor predeterminado0) — Si es unint, calcula los logits para los últimoslogits_to_keeptokens. Si es0, calcula los logits para todos losinput_ids(caso especial). Solo se necesitan los logits del último token para la generación, y calcularlos solo para ese token puede ahorrar memoria, lo cual se vuelve bastante significativo para secuencias largas o un tamaño de vocabulario grande. Si es untorch.Tensor, debe ser de 1D y corresponder a los índices a conservar en la dimensión de longitud de secuencia. Esto es útil al usar el formato de tensor empaquetado (una sola dimensión para el lote y la longitud de secuencia).
Devuelve
CausalLMOutputWithCrossAttentions o tuple(torch.Tensor)
Un CausalLMOutputWithCrossAttentions o una tupla de
torch.Tensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios
elementos según la configuración (ErnieConfig) y las entradas.
El método forward de ErnieForCausalLM sobrescribe el método especial __call__.
Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de
Moduledespués en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.
loss (
torch.Tensorde forma(1,), opcional, se devuelve cuando se proporcionalabels) — Pérdida de modelado de lenguaje (para la predicción del siguiente token).logits (
torch.Tensorde forma(batch_size, sequence_length, config.vocab_size)) — Puntuaciones de predicción de la cabeza de modelado de lenguaje (puntuaciones para cada token del vocabulario antes de SoftMax).hidden_states (
tuple(torch.Tensor), opcional, devuelto cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma(batch_size, sequence_length, hidden_size).Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
attentions (
tuple(torch.Tensor), opcional, se devuelve cuando se pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.Tensor(una por cada capa) de forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
cross_attentions (
tuple(torch.Tensor), opcional, se devuelve cuando se pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.Tensor(una por cada capa) de forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de las atenciones cruzadas después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada.
past_key_values (
Cache, opcional, se devuelve cuando se pasause_cache=Trueo cuandoconfig.use_cache=True) — Es una instancia de Cache. Para más detalles, consulta nuestra guía de caché kv.Contiene estados ocultos precalculados (claves y valores en los bloques de atención) que se pueden utilizar (véase la entrada
past_key_values) para acelerar la decodificación secuencial.
ErnieForMaskedLM
clase transformers.ErnieForMaskedLM
< source >( config: ErnieConfig )
Parámetros
- config (ErnieConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.
El modelo Ernie con una cabeza de language modeling en la parte superior.”
Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).
Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.
forward
< source >( input_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Nonetask_type_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneencoder_hidden_states: typing.Optional[torch.Tensor] = Noneencoder_attention_mask: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → MaskedLMOutput or tuple(torch.Tensor)
Parámetros
- input_ids (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada.Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.
- attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens que no están enmascarados,
- 0 para los tokens que están enmascarados.
- token_type_ids (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Índices de tokens de segmento para indicar las primeras y segundas partes de las entradas. Los índices se seleccionan en[0, 1]:- 0 corresponde a un token de sentence A,
- 1 corresponde a un token de sentence B.
- task_type_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — El embedding de tipo de tarea es un embedding especial para representar la característica de diferentes tareas, como la tarea de preentrenamiento consciente de palabras, la tarea de preentrenamiento consciente de estructura y la tarea de preentrenamiento consciente de semántica. Asignamos untask_type_ida cada tarea y eltask_type_idestá en el rango `[0, config.task_type_vocab_size-1] - position_ids (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango[0, config.n_positions - 1]. - inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasarinput_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices deinput_idsen los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo. - encoder_hidden_states (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Secuencia de estados ocultos en la salida de la última capa del codificador. Se utiliza en la atención cruzada si el modelo está configurado como decodificador. - encoder_attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno de la entrada del codificador. Esta máscara se utiliza en la atención cruzada si el modelo está configurado como decodificador. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens que no están enmascarados,
- 0 para los tokens que están enmascarados.
- labels (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Etiquetas para calcular la pérdida de modelado de lenguaje enmascarado. Los índices deben estar en[-100, 0, ..., config.vocab_size](ver la docstring deinput_ids). Los tokens con índices establecidos en-100se ignoran (se enmascaran); la pérdida solo se calcula para los tokens con etiquetas en[0, ..., config.vocab_size].
Devuelve
MaskedLMOutput o tuple(torch.Tensor)
Un MaskedLMOutput o una tupla de
torch.Tensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios
elementos según la configuración (ErnieConfig) y las entradas.
El método forward de ErnieForMaskedLM sobrescribe el método especial __call__.
Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de
Moduledespués en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.
loss (
torch.Tensorde forma(1,), opcional, se devuelve cuando se proporcionalabels) — Pérdida de modelado de lenguaje enmascarado (MLM).logits (
torch.Tensorde forma(batch_size, sequence_length, config.vocab_size)) — Puntuaciones de predicción de la cabeza de modelado de lenguaje (puntuaciones para cada token del vocabulario antes de SoftMax).hidden_states (
tuple(torch.Tensor), opcional, devuelto cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma(batch_size, sequence_length, hidden_size).Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
attentions (
tuple(torch.Tensor), opcional, se devuelve cuando se pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.Tensor(una por cada capa) de forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
Ejemplo:
>>> from transformers import AutoTokenizer, ErnieForMaskedLM
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("nghuyong/ernie-3.0-base-zh")
>>> model = ErnieForMaskedLM.from_pretrained("nghuyong/ernie-3.0-base-zh")
>>> inputs = tokenizer("The capital of France is <mask>.", return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> # retrieve index of <mask>
>>> mask_token_index = (inputs.input_ids == tokenizer.mask_token_id)[0].nonzero(as_tuple=True)[0]
>>> predicted_token_id = logits[0, mask_token_index].argmax(axis=-1)
>>> tokenizer.decode(predicted_token_id)
...
>>> labels = tokenizer("The capital of France is Paris.", return_tensors="pt")["input_ids"]
>>> # mask labels of non-<mask> tokens
>>> labels = torch.where(inputs.input_ids == tokenizer.mask_token_id, labels, -100)
>>> outputs = model(**inputs, labels=labels)
>>> round(outputs.loss.item(), 2)
...ErnieForNextSentencePrediction
clase transformers.ErnieForNextSentencePrediction
< source >( config: ErnieConfig )
Parámetros
- config (ErnieConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.
Modelo Ernie con una cabeza de next sentence prediction (classification) en la parte superior.
Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).
Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.
forward
< source >( input_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Nonetask_type_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → NextSentencePredictorOutput or tuple(torch.Tensor)
Parámetros
- input_ids (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada.Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.
- attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens que no están enmascarados,
- 0 para los tokens que están enmascarados.
- token_type_ids (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Índices de tokens de segmento para indicar las primeras y segundas partes de las entradas. Los índices se seleccionan en[0, 1]:- 0 corresponde a un token de sentence A,
- 1 corresponde a un token de sentence B.
- task_type_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — El embedding de tipo de tarea es un embedding especial para representar la característica de diferentes tareas, como la tarea de preentrenamiento consciente de palabras, la tarea de preentrenamiento consciente de estructura y la tarea de preentrenamiento consciente de semántica. Asignamos untask_type_ida cada tarea y eltask_type_idestá en el rango `[0, config.task_type_vocab_size-1] - position_ids (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango[0, config.n_positions - 1]. - inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasarinput_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices deinput_idsen los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo. - labels (
torch.LongTensorde forma(batch_size,), opcional) — Etiquetas para calcular la pérdida de predicción de la siguiente secuencia (clasificación). La entrada debe ser un par de secuencias (verinput_idsdocstring). Los índices deben estar en[0, 1]:- 0 indica que la secuencia B es una continuación de la secuencia A,
- 1 indica que la secuencia B es una secuencia aleatoria.
Devuelve
NextSentencePredictorOutput o tuple(torch.Tensor)
Un NextSentencePredictorOutput o una tupla de
torch.Tensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios
elementos según la configuración (ErnieConfig) y las entradas.
El método forward de ErnieForNextSentencePrediction sobrescribe el método especial __call__.
Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de
Moduledespués en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.
loss (
torch.Tensorde forma(1,), opcional, devuelta cuando se proporcionanext_sentence_label) — Pérdida de predicción de la siguiente secuencia (clasificación).logits (
torch.Tensorde forma(batch_size, 2)) — Puntuaciones de predicción de la cabeza de predicción de la siguiente secuencia (clasificación) (puntuaciones de continuación True/False antes del SoftMax).hidden_states (
tuple(torch.Tensor), opcional, devuelto cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma(batch_size, sequence_length, hidden_size).Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
attentions (
tuple(torch.Tensor), opcional, se devuelve cuando se pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.Tensor(una por cada capa) de forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
Ejemplo:
>>> from transformers import AutoTokenizer, ErnieForNextSentencePrediction
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("nghuyong/ernie-1.0-base-zh")
>>> model = ErnieForNextSentencePrediction.from_pretrained("nghuyong/ernie-1.0-base-zh")
>>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
>>> next_sentence = "The sky is blue due to the shorter wavelength of blue light."
>>> encoding = tokenizer(prompt, next_sentence, return_tensors="pt")
>>> outputs = model(**encoding, labels=torch.LongTensor([1]))
>>> logits = outputs.logits
>>> assert logits[0, 0] < logits[0, 1] # next sentence was randomErnieForSequenceClassification
clase transformers.ErnieForSequenceClassification
< source >( config: ErnieConfig )
Parámetros
- config (ErnieConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.
Transformador del modelo Ernie con una cabeza de clasificación/regresión de secuencias en la parte superior (una capa lineal sobre la salida agrupada), por ejemplo, para tareas de GLUE.
Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).
Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.
forward
< source >( input_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Nonetask_type_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → SequenceClassifierOutput or tuple(torch.Tensor)
Parámetros
- input_ids (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada.Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.
- attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens que no están enmascarados,
- 0 para los tokens que están enmascarados.
- token_type_ids (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Índices de tokens de segmento para indicar las primeras y segundas partes de las entradas. Los índices se seleccionan en[0, 1]:- 0 corresponde a un token de sentence A,
- 1 corresponde a un token de sentence B.
- task_type_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — El embedding de tipo de tarea es un embedding especial para representar la característica de diferentes tareas, como la tarea de preentrenamiento consciente de palabras, la tarea de preentrenamiento consciente de estructura y la tarea de preentrenamiento consciente de semántica. Asignamos untask_type_ida cada tarea y eltask_type_idestá en el rango `[0, config.task_type_vocab_size-1] - position_ids (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango[0, config.n_positions - 1]. - inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasarinput_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices deinput_idsen los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo. - labels (
torch.LongTensorde forma(batch_size,), opcional) — Etiquetas para calcular la pérdida de clasificación/regresión de secuencia. Los índices deben estar en[0, ..., config.num_labels - 1]. Siconfig.num_labels == 1se calcula una pérdida de regresión (pérdida de error cuadrático medio), siconfig.num_labels > 1se calcula una pérdida de clasificación (entropía cruzada).
Devuelve
SequenceClassifierOutput o tuple(torch.Tensor)
Un SequenceClassifierOutput o una tupla de
torch.Tensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios
elementos según la configuración (ErnieConfig) y las entradas.
El método forward de ErnieForSequenceClassification sobrescribe el método especial __call__.
Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de
Moduledespués en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.
loss (
torch.Tensorde forma(1,), opcional, se devuelve cuando se proporcionalabels) — Pérdida de clasificación (o de regresión si config.num_labels==1).logits (
torch.Tensorde forma(batch_size, config.num_labels)) — Puntuaciones de clasificación (o de regresión si config.num_labels==1) (antes de SoftMax).hidden_states (
tuple(torch.Tensor), opcional, devuelto cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma(batch_size, sequence_length, hidden_size).Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
attentions (
tuple(torch.Tensor), opcional, se devuelve cuando se pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.Tensor(una por cada capa) de forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
Ejemplo de clasificación de una sola etiqueta:
>>> import torch
>>> from transformers import AutoTokenizer, ErnieForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("nghuyong/ernie-3.0-base-zh")
>>> model = ErnieForSequenceClassification.from_pretrained("nghuyong/ernie-3.0-base-zh")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_class_id = logits.argmax().item()
>>> model.config.id2label[predicted_class_id]
...
>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = ErnieForSequenceClassification.from_pretrained("nghuyong/ernie-3.0-base-zh", num_labels=num_labels)
>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...Ejemplo de clasificación multietiqueta:
>>> import torch
>>> from transformers import AutoTokenizer, ErnieForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("nghuyong/ernie-3.0-base-zh")
>>> model = ErnieForSequenceClassification.from_pretrained("nghuyong/ernie-3.0-base-zh", problem_type="multi_label_classification")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5]
>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = ErnieForSequenceClassification.from_pretrained(
... "nghuyong/ernie-3.0-base-zh", num_labels=num_labels, problem_type="multi_label_classification"
... )
>>> labels = torch.sum(
... torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1
... ).to(torch.float)
>>> loss = model(**inputs, labels=labels).lossErnieForMultipleChoice
clase transformers.ErnieForMultipleChoice
< source >( config: ErnieConfig )
Parámetros
- config (ErnieConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.
El modelo Ernie con una cabeza de clasificación de opción múltiple en la parte superior (una capa lineal sobre la salida agrupada y un softmax), por ejemplo, para las tareas RocStories/SWAG.
Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).
Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.
forward
< source >( input_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Nonetask_type_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → MultipleChoiceModelOutput or tuple(torch.Tensor)
Parámetros
- input_ids (
torch.LongTensorde forma(batch_size, num_choices, sequence_length)) — Índices de los tokens de la secuencia de entrada en el vocabulario.Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.
- attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens que no están enmascarados,
- 0 para los tokens que están enmascarados.
- token_type_ids (
torch.LongTensorde forma(batch_size, num_choices, sequence_length), opcional) — Índices de tokens de segmento para indicar las primeras y segundas partes de las entradas. Los índices se seleccionan en[0, 1]:- 0 corresponde a un token de sentence A,
- 1 corresponde a un token de sentence B.
- task_type_ids (
torch.LongTensorde forma(batch_size, num_choices, sequence_length), opcional) — El embedding de tipo de tarea es un embedding especial para representar la característica de diferentes tareas, como la tarea de preentrenamiento consciente de palabras, la tarea de preentrenamiento consciente de estructura y la tarea de preentrenamiento consciente de semántica. Asignamos untask_type_ida cada tarea y eltask_type_idestá en el rango `[0, config.task_type_vocab_size-1] - position_ids (
torch.LongTensorde forma(batch_size, num_choices, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango[0, config.max_position_embeddings - 1]. - inputs_embeds (
torch.Tensorde forma(batch_size, num_choices, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasarinput_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices deinput_idsen los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo. - labels (
torch.LongTensorde forma(batch_size,), opcional) — Etiquetas para calcular la pérdida de clasificación de opción múltiple. Los índices deben estar en[0, ..., num_choices-1], dondenum_choiceses el tamaño de la segunda dimensión de los tensores de entrada. (Véaseinput_idsarriba)
Devuelve
MultipleChoiceModelOutput o tuple(torch.Tensor)
Un MultipleChoiceModelOutput o una tupla de
torch.Tensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios
elementos según la configuración (ErnieConfig) y las entradas.
El método forward de ErnieForMultipleChoice sobrescribe el método especial __call__.
Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de
Moduledespués en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.
loss (
torch.Tensorde forma (1,), opcional, devuelta cuando se proporcionalabels) — Pérdida de clasificación.logits (
torch.Tensorde forma(batch_size, num_choices)) — num_choices es la segunda dimensión de los tensores de entrada. (ver input_ids arriba).Puntuaciones de clasificación (antes de SoftMax).
hidden_states (
tuple(torch.Tensor), opcional, devuelto cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma(batch_size, sequence_length, hidden_size).Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
attentions (
tuple(torch.Tensor), opcional, se devuelve cuando se pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.Tensor(una por cada capa) de forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
Ejemplo:
>>> from transformers import AutoTokenizer, ErnieForMultipleChoice
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("nghuyong/ernie-3.0-base-zh")
>>> model = ErnieForMultipleChoice.from_pretrained("nghuyong/ernie-3.0-base-zh")
>>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
>>> choice0 = "It is eaten with a fork and a knife."
>>> choice1 = "It is eaten while held in the hand."
>>> labels = torch.tensor(0).unsqueeze(0) # choice0 is correct (according to Wikipedia ;)), batch size 1
>>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors="pt", padding=True)
>>> outputs = model(**{k: v.unsqueeze(0) for k, v in encoding.items()}, labels=labels) # batch size is 1
>>> # the linear classifier still needs to be trained
>>> loss = outputs.loss
>>> logits = outputs.logitsErnieForTokenClassification
clase transformers.ErnieForTokenClassification
< source >( config: ErnieConfig )
Parámetros
- config (ErnieConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.
El transformer Ernie con una cabeza de clasificación de tokens en la parte superior (una capa lineal sobre la salida de los estados ocultos), por ejemplo, para tareas de reconocimiento de entidades nombradas (NER).
Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).
Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.
forward
< source >( input_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Nonetask_type_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → TokenClassifierOutput or tuple(torch.Tensor)
Parámetros
- input_ids (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada.Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.
- attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens que no están enmascarados,
- 0 para los tokens que están enmascarados.
- token_type_ids (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Índices de tokens de segmento para indicar las primeras y segundas partes de las entradas. Los índices se seleccionan en[0, 1]:- 0 corresponde a un token de sentence A,
- 1 corresponde a un token de sentence B.
- task_type_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — El embedding de tipo de tarea es un embedding especial para representar la característica de diferentes tareas, como la tarea de preentrenamiento consciente de palabras, la tarea de preentrenamiento consciente de estructura y la tarea de preentrenamiento consciente de semántica. Asignamos untask_type_ida cada tarea y eltask_type_idestá en el rango `[0, config.task_type_vocab_size-1] - position_ids (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango[0, config.n_positions - 1]. - inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasarinput_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices deinput_idsen los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo. - labels (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Etiquetas para calcular la pérdida de clasificación de tokens. Los índices deben estar en[0, ..., config.num_labels - 1].
Devuelve
TokenClassifierOutput o tuple(torch.Tensor)
Un TokenClassifierOutput o una tupla de
torch.Tensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios
elementos según la configuración (ErnieConfig) y las entradas.
El método forward de ErnieForTokenClassification sobrescribe el método especial __call__.
Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de
Moduledespués en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.
loss (
torch.Tensorde forma(1,), opcional, se devuelve cuando se proporcionalabels) — Pérdida de clasificación.logits (
torch.Tensorde forma(batch_size, sequence_length, config.num_labels)) — Puntuaciones de clasificación (antes de SoftMax).hidden_states (
tuple(torch.Tensor), opcional, devuelto cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma(batch_size, sequence_length, hidden_size).Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
attentions (
tuple(torch.Tensor), opcional, se devuelve cuando se pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.Tensor(una por cada capa) de forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
Ejemplo:
>>> from transformers import AutoTokenizer, ErnieForTokenClassification
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("nghuyong/ernie-3.0-base-zh")
>>> model = ErnieForTokenClassification.from_pretrained("nghuyong/ernie-3.0-base-zh")
>>> inputs = tokenizer(
... "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="pt"
... )
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_token_class_ids = logits.argmax(-1)
>>> # Note that tokens are classified rather then input words which means that
>>> # there might be more predicted token classes than words.
>>> # Multiple token classes might account for the same word
>>> predicted_tokens_classes = [model.config.id2label[t.item()] for t in predicted_token_class_ids[0]]
>>> predicted_tokens_classes
...
>>> labels = predicted_token_class_ids
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...ErnieForQuestionAnswering
clase transformers.ErnieForQuestionAnswering
< source >( config: ErnieConfig )
Parámetros
- config (ErnieConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.
El transformador Ernie con una cabeza de clasificación de tramos en la parte superior para tareas de respuesta a preguntas extractivas como SQuAD (una capa lineal sobre la salida de los estados ocultos para calcular span start logits y span end logits).
Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).
Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.
forward
< source >( input_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Nonetask_type_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonestart_positions: typing.Optional[torch.Tensor] = Noneend_positions: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → QuestionAnsweringModelOutput or tuple(torch.Tensor)
Parámetros
- input_ids (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada.Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.
- attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens que no están enmascarados,
- 0 para los tokens que están enmascarados.
- token_type_ids (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Índices de tokens de segmento para indicar las primeras y segundas partes de las entradas. Los índices se seleccionan en[0, 1]:- 0 corresponde a un token de sentence A,
- 1 corresponde a un token de sentence B.
- task_type_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — El embedding de tipo de tarea es un embedding especial para representar la característica de diferentes tareas, como la tarea de preentrenamiento consciente de palabras, la tarea de preentrenamiento consciente de estructura y la tarea de preentrenamiento consciente de semántica. Asignamos untask_type_ida cada tarea y eltask_type_idestá en el rango `[0, config.task_type_vocab_size-1] - position_ids (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango[0, config.n_positions - 1]. - inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasarinput_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices deinput_idsen los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo. - start_positions (
torch.Tensorde forma(batch_size,), opcional) — Etiquetas para la posición (índice) del inicio del span etiquetado para calcular la pérdida de clasificación de tokens. Las posiciones se limitan a la longitud de la secuencia (sequence_length). Las posiciones fuera de la secuencia no se tienen en cuenta para calcular la pérdida. - end_positions (
torch.Tensorde forma(batch_size,), opcional) — Etiquetas para la posición (índice) del final del span etiquetado para calcular la pérdida de clasificación de tokens. Las posiciones se limitan a la longitud de la secuencia (sequence_length). Las posiciones fuera de la secuencia no se tienen en cuenta para calcular la pérdida.
Devuelve
QuestionAnsweringModelOutput o tuple(torch.Tensor)
Un QuestionAnsweringModelOutput o una tupla de
torch.Tensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios
elementos según la configuración (ErnieConfig) y las entradas.
El método forward de ErnieForQuestionAnswering sobrescribe el método especial __call__.
Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de
Moduledespués en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.
loss (
torch.Tensorde forma(1,), opcional, se devuelve cuando se proporcionalabels) — La pérdida total de extracción de tramos es la suma de una Entropía Cruzada para las posiciones de inicio y fin.start_logits (
torch.Tensorde forma(batch_size, sequence_length)) — Puntuaciones de inicio de tramo (antes de SoftMax).end_logits (
torch.Tensorde forma(batch_size, sequence_length)) — Puntuaciones de fin de tramo (antes de SoftMax).hidden_states (
tuple(torch.Tensor), opcional, devuelto cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma(batch_size, sequence_length, hidden_size).Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
attentions (
tuple(torch.Tensor), opcional, se devuelve cuando se pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.Tensor(una por cada capa) de forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
Ejemplo:
>>> from transformers import AutoTokenizer, ErnieForQuestionAnswering
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("nghuyong/ernie-3.0-base-zh")
>>> model = ErnieForQuestionAnswering.from_pretrained("nghuyong/ernie-3.0-base-zh")
>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"
>>> inputs = tokenizer(question, text, return_tensors="pt")
>>> with torch.no_grad():
... outputs = model(**inputs)
>>> answer_start_index = outputs.start_logits.argmax()
>>> answer_end_index = outputs.end_logits.argmax()
>>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]
>>> tokenizer.decode(predict_answer_tokens, skip_special_tokens=True)
...
>>> # target is "nice puppet"
>>> target_start_index = torch.tensor([14])
>>> target_end_index = torch.tensor([15])
>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
>>> loss = outputs.loss
>>> round(loss.item(), 2)
...